From 2e84c66be8e562d14be44a5c692378f7d68adcad Mon Sep 17 00:00:00 2001 From: bircni Date: Sun, 5 Jan 2025 17:54:11 +0000 Subject: [PATCH] deploy: 141203205994f7551505008ed1901bd6f9902130 --- crates.js | 3 +- help.html | 2 +- search-index.js | 5 +- settings.html | 2 +- src-files.js | 5 +- src/trayracer/main.rs.html | 8 +- src/trayracer/raytracer/mod.rs.html | 6 +- src/trayracer/raytracer/render.rs.html | 6 +- src/trayracer/scene/camera.rs.html | 6 +- src/trayracer/scene/light.rs.html | 6 +- src/trayracer/scene/material.rs.html | 6 +- src/trayracer/scene/mod.rs.html | 6 +- src/trayracer/scene/object.rs.html | 6 +- src/trayracer/scene/settings.rs.html | 6 +- src/trayracer/scene/skybox.rs.html | 6 +- src/trayracer/scene/triangle.rs.html | 6 +- src/trayracer/scene/yaml.rs.html | 6 +- src/trayracer/ui/mod.rs.html | 6 +- src/trayracer/ui/preview/gpu.rs.html | 12 +- src/trayracer/ui/preview/mod.rs.html | 10 +- src/trayracer/ui/properties.rs.html | 26 +++-- src/trayracer/ui/renderresult.rs.html | 6 +- src/trayracer/ui/statusbar.rs.html | 6 +- src/trayracer/ui/yamlmenu.rs.html | 12 +- static.files/main-f070b9041d14864c.js | 11 ++ static.files/noscript-0111fcff984fae8f.css | 1 + static.files/rustdoc-b0742ba02757f159.css | 53 +++++++++ .../scrape-examples-46fc985aa763a438.js | 1 + static.files/search-f0d225181b97f9a4.js | 6 + static.files/settings-805db61a62df4bd2.js | 17 +++ static.files/storage-1d39b6787ed640ff.js | 23 ++++ trait.impl/bvh/aabb/trait.Bounded.js | 12 +- .../bvh/bounding_hierarchy/trait.BHShape.js | 12 +- trait.impl/bytemuck/pod/trait.Pod.js | 12 +- .../bytemuck/zeroable/trait.Zeroable.js | 12 +- trait.impl/core/clone/trait.Clone.js | 12 +- trait.impl/core/cmp/trait.Eq.js | 12 +- trait.impl/core/cmp/trait.PartialEq.js | 12 +- trait.impl/core/default/trait.Default.js | 12 +- trait.impl/core/fmt/trait.Debug.js | 12 +- trait.impl/core/marker/trait.Copy.js | 12 +- trait.impl/core/marker/trait.Freeze.js | 12 +- trait.impl/core/marker/trait.Send.js | 12 +- .../core/marker/trait.StructuralPartialEq.js | 12 +- trait.impl/core/marker/trait.Sync.js | 12 +- trait.impl/core/marker/trait.Unpin.js | 12 +- .../panic/unwind_safe/trait.RefUnwindSafe.js | 12 +- .../panic/unwind_safe/trait.UnwindSafe.js | 12 +- trait.impl/eframe/epi/trait.App.js | 12 +- .../egui_wgpu/renderer/trait.CallbackTrait.js | 12 +- trait.impl/serde/de/trait.Deserialize.js | 12 +- trait.impl/serde/de/trait.DeserializeSeed.js | 12 +- trait.impl/serde/ser/trait.Serialize.js | 12 +- trayracer/all.html | 2 +- trayracer/fn.main.html | 2 +- trayracer/index.html | 2 +- trayracer/raytracer/index.html | 2 +- trayracer/raytracer/render/index.html | 2 +- trayracer/raytracer/render/struct.Render.html | 67 +++++------ .../render/struct.RenderingThread.html | 67 +++++------ trayracer/raytracer/struct.Hit.html | 68 +++++------ trayracer/raytracer/struct.Ray.html | 68 +++++------ trayracer/raytracer/struct.Raytracer.html | 69 +++++------ trayracer/scene/camera/index.html | 2 +- trayracer/scene/camera/struct.Camera.html | 85 +++++++------- trayracer/scene/camera/yaml/index.html | 2 +- .../scene/camera/yaml/struct.CameraDef.html | 69 +++++------ trayracer/scene/index.html | 2 +- trayracer/scene/light/index.html | 2 +- trayracer/scene/light/struct.Light.html | 80 ++++++------- trayracer/scene/light/yaml/index.html | 2 +- .../scene/light/yaml/struct.LightDef.html | 63 +++++----- trayracer/scene/material/index.html | 2 +- .../material/struct.IlluminationModel.html | 76 ++++++------ trayracer/scene/material/struct.Material.html | 72 ++++++------ trayracer/scene/object/fn.filename.html | 2 +- trayracer/scene/object/fn.load_texture.html | 2 +- trayracer/scene/object/fn.triangulate.html | 8 +- trayracer/scene/object/index.html | 2 +- trayracer/scene/object/struct.Object.html | 86 +++++++------- .../scene/object/struct.WithRelativePath.html | 65 ++++++----- trayracer/scene/object/yaml/index.html | 2 +- .../scene/object/yaml/struct.ObjectDef.html | 65 ++++++----- trayracer/scene/settings/index.html | 2 +- trayracer/scene/settings/struct.Settings.html | 83 ++++++------- trayracer/scene/settings/yaml/index.html | 2 +- .../settings/yaml/struct.SettingsDef.html | 65 ++++++----- trayracer/scene/skybox/enum.Skybox.html | 77 +++++++------ trayracer/scene/skybox/index.html | 2 +- .../scene/skybox/yaml/enum.SkyboxDef.html | 61 +++++----- trayracer/scene/skybox/yaml/index.html | 2 +- trayracer/scene/struct.Scene.html | 66 ++++++----- trayracer/scene/struct.WithRelativePath.html | 65 ++++++----- trayracer/scene/triangle/index.html | 2 +- trayracer/scene/triangle/struct.Triangle.html | 109 +++++++++--------- trayracer/scene/type.Color.html | 6 +- .../scene/yaml/color/fn.deserialize.html | 4 +- trayracer/scene/yaml/color/fn.serialize.html | 8 +- trayracer/scene/yaml/color/index.html | 2 +- trayracer/scene/yaml/color/struct.Yaml.html | 63 +++++----- trayracer/scene/yaml/index.html | 2 +- .../scene/yaml/point/fn.deserialize.html | 4 +- trayracer/scene/yaml/point/fn.serialize.html | 8 +- trayracer/scene/yaml/point/index.html | 2 +- trayracer/scene/yaml/point/struct.Yaml.html | 63 +++++----- .../scene/yaml/vector/fn.deserialize.html | 4 +- trayracer/scene/yaml/vector/fn.serialize.html | 8 +- trayracer/scene/yaml/vector/index.html | 2 +- trayracer/scene/yaml/vector/struct.Yaml.html | 63 +++++----- trayracer/static._RUST_I18N_BACKEND.html | 2 +- .../static._RUST_I18N_FALLBACK_LOCALE.html | 2 +- trayracer/static._RUST_I18N_MINIFY_KEY.html | 2 +- .../static._RUST_I18N_MINIFY_KEY_LEN.html | 2 +- .../static._RUST_I18N_MINIFY_KEY_PREFIX.html | 2 +- .../static._RUST_I18N_MINIFY_KEY_THRESH.html | 2 +- trayracer/ui/enum.Tab.html | 54 ++++----- trayracer/ui/index.html | 2 +- trayracer/ui/preview/gpu/fn.init_wgpu.html | 2 +- trayracer/ui/preview/gpu/index.html | 2 +- .../ui/preview/gpu/struct.Resources.html | 51 ++++---- .../ui/preview/gpu/struct.ShaderLight.html | 75 ++++++------ .../ui/preview/gpu/struct.ShaderUniforms.html | 77 +++++++------ .../ui/preview/gpu/struct.VertexCount.html | 49 ++++---- .../ui/preview/gpu/struct.WgpuPainter.html | 66 ++++++----- trayracer/ui/preview/index.html | 2 +- trayracer/ui/preview/struct.Preview.html | 70 +++++------ .../ui/properties/fn.xyz_drag_value.html | 2 +- trayracer/ui/properties/index.html | 2 +- .../ui/properties/struct.Properties.html | 58 +++++----- trayracer/ui/renderresult/index.html | 2 +- .../ui/renderresult/struct.RenderResult.html | 53 ++++----- trayracer/ui/statusbar/index.html | 2 +- trayracer/ui/statusbar/struct.StatusBar.html | 60 +++++----- trayracer/ui/struct.App.html | 56 +++++---- trayracer/ui/yamlmenu/index.html | 2 +- trayracer/ui/yamlmenu/struct.YamlMenu.html | 54 ++++----- type.impl/nalgebra/base/alias/type.Vector3.js | 12 +- 137 files changed, 1700 insertions(+), 1423 deletions(-) create mode 100644 static.files/main-f070b9041d14864c.js create mode 100644 static.files/noscript-0111fcff984fae8f.css create mode 100644 static.files/rustdoc-b0742ba02757f159.css create mode 100644 static.files/scrape-examples-46fc985aa763a438.js create mode 100644 static.files/search-f0d225181b97f9a4.js create mode 100644 static.files/settings-805db61a62df4bd2.js create mode 100644 static.files/storage-1d39b6787ed640ff.js diff --git a/crates.js b/crates.js index 36e653c6..db17489f 100644 --- a/crates.js +++ b/crates.js @@ -1 +1,2 @@ -window.ALL_CRATES = ["trayracer"]; \ No newline at end of file +window.ALL_CRATES = ["trayracer"]; +//{"start":21,"fragment_lengths":[11]} \ No newline at end of file diff --git a/help.html b/help.html index 30ff2ab7..2843d841 100644 --- a/help.html +++ b/help.html @@ -1 +1 @@ -Help

Rustdoc help

Back
\ No newline at end of file +Help

Rustdoc help

Back
\ No newline at end of file diff --git a/search-index.js b/search-index.js index 4449e2da..d3df098d 100644 --- a/search-index.js +++ b/search-index.js @@ -1,5 +1,4 @@ -var searchIndex = new Map(JSON.parse('[\ -["trayracer",{"t":"JJJJJJHCCCFTFFNNNNNNNNNNNNNNNNNNNONNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOONOOONNNCNONNNNNNNNNNNNNNNNNNNNNNNNONNNFFNNNNNNNNOOONNNNNNNNNNNNOONNNNNNNNNNNNNOONNOOOOOONNNNNNNNNNNNNNEIEEEFEEFNNNNNNNNCONNNONNNNNNNNNNNNNNNNNNNNNNNNNNCONCCOONCOCNNNNNCNNNNNNNNNNCFNNNNNNNNNNNNNNNONNNNNNNNONONONNNNNNNONNCFNNNNNNNNNONNONNNNNNOONNNNNNONNOFNNNNNNNNONNNNNNNNNNNONNNNNNONNNNNNNNNCFNNNNNNNNNNNNONNNNNOONNNNNNNNFFNNNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNONNNNNNNNNNNNONNONOONNNNNNNNNNNNNNNNNFFNNNNNNNNONNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNHOOOOOONNNNNNNOOHNNNNNNNNNNCFNNNNNNNNNONNNNNNNNOOONNNNNNNNFOOONNNNNNNNNNNNNNNNNNNNNNNONONONNNNNNNNCFOONNNNNNNNNNNNNNNNNOONONNNNNNNPPGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOOPPGNNNNNNNNNNNNNNNNNNNNNNNNNFOOONNNOOONNNOOOONNNNNNNNNNNNNNNNNNONNNNNNNNNNCCCFNNONNNNHNNNNNONNNNNNOHNNNNNNNNFNNNNNNHNNNNNNNNNNNHNNNNNNNNOOOFNNNNNNHNNNNNNNNNNNHNNNNNNNNOOOFPPGNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNCOCOOOCOCONNNNNNNNNNNNNNNOCFONNNNNNNNNNNNONNCONNNNNNNNNONNONNNNNNNNTTFFFFFOOOONNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHONNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNOONONNNNNNNNNNNNNONNNNNNNNNNNNNNNONNNNNOONNNNNFNNNNNNNNNNNNNNNNNNNNNNONNNNONNNNNNNNHFNNNNNNNNNNNNNNNNNONNNNNNNNOFNNNNNNNNNNNNNNNNNNNNNNONONNNNNNNFNNNNNNONNNNNNNNNNNNNNONNNNNNNNN","n":["_RUST_I18N_BACKEND","_RUST_I18N_FALLBACK_LOCALE","_RUST_I18N_MINIFY_KEY","_RUST_I18N_MINIFY_KEY_LEN","_RUST_I18N_MINIFY_KEY_PREFIX","_RUST_I18N_MINIFY_KEY_THRESH","main","raytracer","scene","ui","Hit","NO_MATERIAL_COLOR","Ray","Raytracer","as_any","as_any","as_any","as_any_mut","as_any_mut","as_any_mut","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","delta","deref","deref","deref","deref_mut","deref_mut","deref_mut","direction","downcast","downcast","downcast","drop","drop","drop","eq","fmt","fmt","from","from","from","from_subset","from_subset","from_subset","init","init","init","into","into","into","into_any","into_any","into_any","into_any_arc","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","is_in_subset","material","max_depth","name","new","normal","origin","point","raycast","raycast_transparent","reflect","render","render","scene","shade","shade_impl","skybox","texture","to_owned","to_owned","to_subset","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","to_subset_unchecked","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","upcast","upcast","upcast","uv","vzip","vzip","vzip","Render","RenderingThread","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","cancel","cancel","ctx","deref","deref","deref_mut","deref_mut","downcast","downcast","drop","drop","from","from","from_subset","from_subset","image","image","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","new","progress","progress","render","run","scene","texture","texture","thread","time","time","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","try_from","try_from","try_into","try_into","type_id","type_id","upcast","upcast","vzip","vzip","Camera","Color","Light","Material","Object","Scene","Settings","Skybox","WithRelativePath","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","camera","camera","clone","clone_into","clone_to_uninit","data","deref","deref","deref_mut","deref_mut","deserialize","downcast","downcast","drop","drop","fmt","from","from","from_subset","from_subset","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","light","lights","load","material","object","objects","path","serialize","settings","settings","skybox","to_owned","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","triangle","try_from","try_from","try_into","try_into","type_id","type_id","upcast","upcast","vzip","vzip","yaml","Camera","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","fov","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","look_at","null_value","position","ray","resolution","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","up","upcast","vzip","yaml","CameraDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","field_of_view","from","from_subset","height","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","look_at","position","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","up_vec","upcast","vzip","width","Light","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","clone_to_uninit","color","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","intensity","into","into_any","into_any_arc","into_any_rc","is_in_subset","null_value","position","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","LightDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","intensity","into","into_any","into_any_arc","into_any_rc","is_in_subset","ke","position","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","IlluminationModel","Material","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","default","deref","deref","deref_mut","deref_mut","diffuse_color","diffuse_texture","dissolve","downcast","downcast","drop","drop","eq","equivalent","equivalent","equivalent","fmt","fmt","from","from","from_i32","from_subset","from_subset","illumination_model","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","name","null_value","reflection","refraction_index","specular","specular_color","specular_exponent","to_owned","to_owned","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","transparency","try_from","try_from","try_into","try_into","type_id","type_id","upcast","upcast","vzip","vzip","Object","WithRelativePath","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","bvh","clone","clone_into","clone_to_uninit","deref","deref","deref_mut","deref_mut","deserialize","downcast","downcast","drop","drop","filename","fmt","from","from","from_obj","from_subset","from_subset","init","init","intersect","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","load_texture","material_name","materials","name","path","rotation","scale","serialize","to_owned","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","transform","translation","triangles","triangulate","try_from","try_from","try_into","try_into","type_id","type_id","upcast","upcast","vzip","vzip","yaml","ObjectDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","file_path","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","position","rotation","scale","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Settings","ambient_color","ambient_intensity","anti_aliasing","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","max_bounces","null_value","samples","serialize","skybox","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","SettingsDef","ambient_color","anti_aliasing","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","max_bounces","samples","serialize","skybox","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Color","Image","Skybox","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","load_from_path","null_value","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","image","path","Color","Path","SkyboxDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Triangle","a","a_normal","a_uv","aabb","as_any","as_any_mut","b","b_normal","b_uv","bh_node_index","borrow","borrow_mut","bvh_index","c","c_normal","c_uv","clone","clone_into","clone_to_uninit","deref","deref_mut","downcast","drop","eq","fmt","from","from_subset","init","intersect","into","into_any","into_any_arc","into_any_rc","is_in_subset","material_index","new","set_bh_node_index","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","color","point","vector","Yaml","as_any","as_any_mut","b","borrow","borrow_mut","deref","deref_mut","deserialize","deserialize","downcast","drop","from","from_subset","g","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","r","serialize","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Yaml","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","x","y","z","Yaml","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","x","y","z","App","Preview","RenderResult","Tab","as_any","as_any","as_any_mut","as_any_mut","borrow","borrow","borrow_mut","borrow_mut","current_tab","deref","deref","deref_mut","deref_mut","downcast","downcast","drop","drop","eq","from","from","from_subset","from_subset","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","new","preview","preview","properties","properties","render","render_result","renderresult","scene","statusbar","statusbar","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","try_from","try_from","try_into","try_into","type_id","type_id","upcast","upcast","update","vzip","vzip","yaml_menu","yamlmenu","Preview","active","as_any","as_any_mut","borrow","borrow_mut","change_preview_movement","clone","clone_into","clone_to_uninit","deref","deref_mut","downcast","drop","dropped_files","from","from_subset","gpu","gpu","handle_file","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","move_camera","new","sensitivity","show","show_hover_overlay","speed","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","MAX_LIGHTS","MAX_OBJECTS","Resources","ShaderLight","ShaderUniforms","VertexCount","WgpuPainter","_pad","_pad","ambient_color","ambient_intensity","as_any","as_any","as_any","as_any","as_any","as_any_mut","as_any_mut","as_any_mut","as_any_mut","as_any_mut","bind_group","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","clone_to_uninit","color","default","default","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","downcast","downcast","downcast","downcast","downcast","drop","drop","drop","drop","drop","fmt","fmt","from","from","from","from","from","from_subset","from_subset","from_subset","from_subset","from_subset","init","init","init","init","init","init_wgpu","intensity","into","into","into","into","into","into_any","into_any","into_any","into_any","into_any","into_any_arc","into_any_arc","into_any_arc","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_any_rc","into_any_rc","into_any_rc","is_in_subset","is_in_subset","is_in_subset","is_in_subset","is_in_subset","is_valid_bit_pattern","is_valid_bit_pattern","lights_buffer","lights_count","new","null_value","null_value","paint","pipeline","position","prepare","scene","to_owned","to_owned","to_owned","to_subset","to_subset","to_subset","to_subset","to_subset","to_subset_unchecked","to_subset_unchecked","to_subset_unchecked","to_subset_unchecked","to_subset_unchecked","transforms_buffer","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","uniform_buffer","upcast","upcast","upcast","upcast","upcast","vertex_buffer","view","vzip","vzip","vzip","vzip","vzip","Properties","ambient_options","as_any","as_any_mut","borrow","borrow_mut","camera_settings","deref","deref_mut","downcast","drop","format_render_size","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","lights","load_skybox_img","new","object_dialog","objects","render_options","scene_settings","show","skybox_dialog","skybox_options","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","xyz_drag_value","RenderResult","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","new","position","show","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","zoom","StatusBar","about_us_button","about_window","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","downcast","drop","export_button","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","new","progress_bar","render_button","save_render_dialog","show","show_about","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","YamlMenu","as_any","as_any_mut","borrow","borrow_mut","buttons","create_scene","create_yaml_dialog","deref","deref_mut","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","load_scene","new","open_yaml_dialog","save_scene","show","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip"],"q":[[0,"trayracer"],[10,"trayracer::raytracer"],[115,"trayracer::raytracer::render"],[179,"trayracer::scene"],[256,"trayracer::scene::camera"],[297,"trayracer::scene::camera::yaml"],[329,"trayracer::scene::light"],[368,"trayracer::scene::light::yaml"],[397,"trayracer::scene::material"],[474,"trayracer::scene::object"],[545,"trayracer::scene::object::yaml"],[575,"trayracer::scene::settings"],[616,"trayracer::scene::settings::yaml"],[647,"trayracer::scene::skybox"],[685,"trayracer::scene::skybox::Skybox"],[687,"trayracer::scene::skybox::yaml"],[715,"trayracer::scene::triangle"],[761,"trayracer::scene::yaml"],[764,"trayracer::scene::yaml::color"],[795,"trayracer::scene::yaml::point"],[826,"trayracer::scene::yaml::vector"],[857,"trayracer::ui"],[923,"trayracer::ui::preview"],[963,"trayracer::ui::preview::gpu"],[1127,"trayracer::ui::properties"],[1165,"trayracer::ui::renderresult"],[1193,"trayracer::ui::statusbar"],[1226,"trayracer::ui::yamlmenu"],[1258,"anyhow"],[1259,"core::any"],[1260,"core::fmt"],[1261,"alloc::boxed"],[1262,"alloc::sync"],[1263,"alloc::rc"],[1264,"core::option"],[1265,"nalgebra::base::alias"],[1266,"image::buffer_"],[1267,"core::result"],[1268,"epaint::texture_handle"],[1269,"epaint::mutex::mutex_impl"],[1270,"egui::context"],[1271,"std::path"],[1272,"core::convert"],[1273,"core::marker"],[1274,"serde::de"],[1275,"serde::ser"],[1276,"alloc::string"],[1277,"nalgebra::geometry::translation_alias"],[1278,"nalgebra::geometry::quaternion"],[1279,"nalgebra::geometry::scale_alias"],[1280,"nalgebra::geometry::transform_alias"],[1281,"obj::obj"],[1282,"alloc::vec"],[1283,"bvh::aabb"],[1284,"nalgebra::geometry::point_alias"],[1285,"eframe::epi"],[1286,"egui::ui"],[1287,"egui::response"],[1288,"epaint::mutex::rw_lock_impl"],[1289,"emath::rect"],[1290,"egui_wgpu"],[1291,"epaint::shape"],[1292,"wgpu"],[1293,"egui_wgpu::renderer"],[1294,"nalgebra::base::coordinates"]],"i":[0,0,0,0,0,0,0,0,0,0,0,18,0,0,18,6,7,18,6,7,18,6,7,18,6,7,6,7,6,7,6,6,7,18,18,6,7,18,6,7,6,18,6,7,18,6,7,6,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,7,18,7,18,7,6,7,18,18,18,0,18,18,18,18,18,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,18,6,7,7,18,6,7,0,0,29,31,29,31,29,31,29,31,29,31,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,29,31,29,31,31,29,31,29,29,31,29,31,29,31,29,31,29,31,29,31,29,31,29,31,0,0,0,0,0,0,0,0,0,32,15,32,15,32,15,32,15,0,15,15,15,15,94,32,15,32,15,32,32,15,32,15,15,32,15,32,15,32,15,32,15,32,15,32,15,32,15,32,15,0,15,15,0,0,15,15,15,0,15,0,15,32,15,32,15,0,32,15,32,15,32,15,32,15,32,15,0,0,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,0,0,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,39,0,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,0,0,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,0,0,42,43,42,43,42,43,42,43,42,43,42,43,42,43,43,43,42,43,42,43,42,42,42,42,43,42,43,43,43,43,43,42,43,42,43,43,42,43,42,42,43,42,43,42,43,42,43,42,43,42,43,42,43,43,42,43,42,42,42,43,42,43,42,43,43,42,43,42,43,42,43,42,43,42,43,0,0,46,45,46,45,46,45,46,45,45,45,45,45,46,45,46,45,46,46,45,46,45,0,45,46,45,45,46,45,46,45,45,46,45,46,45,46,45,46,45,46,45,0,45,45,45,45,45,45,45,45,46,45,46,45,45,45,45,0,46,45,46,45,46,45,46,45,46,45,0,0,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,0,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,0,0,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,59,59,0,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,0,95,95,60,60,0,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,0,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,0,0,0,0,63,63,63,63,63,63,63,0,63,63,63,63,63,63,63,63,63,63,63,63,63,0,63,63,63,63,63,63,63,63,0,64,64,64,64,64,64,0,64,64,64,64,64,64,64,64,64,64,64,0,64,64,64,64,64,64,64,64,64,64,64,0,65,65,65,65,65,65,0,65,65,65,65,65,65,65,65,65,65,65,0,65,65,65,65,65,65,65,65,65,65,65,0,66,66,0,68,66,68,66,68,66,68,66,68,68,66,68,66,68,66,68,66,66,68,66,68,66,68,66,68,66,68,66,68,66,68,66,68,66,68,0,68,0,68,68,68,0,68,0,68,68,66,68,66,68,66,68,66,68,66,68,66,68,68,66,68,0,0,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,0,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,70,76,76,0,0,0,0,0,77,78,77,77,96,97,76,77,78,96,97,76,77,78,96,96,97,76,77,78,96,97,76,77,78,76,77,78,76,77,78,76,77,77,78,78,78,77,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,77,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,0,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,77,78,96,77,76,77,78,76,96,78,76,76,76,77,78,96,97,76,77,78,96,97,76,77,78,96,96,97,76,77,78,96,97,76,77,78,96,97,76,77,78,96,96,97,76,77,78,96,77,96,97,76,77,78,0,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,0,0,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,0,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,0,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93],"f":"``````{{}{{d{b}}}}```````{{{f{c}}}{{f{h}}}{}}00{{{f{jc}}}{{f{jh}}}{}}00{{{f{c}}}{{f{e}}}{}{}}00{{{f{jc}}}{{f{je}}}{}{}}00{{{f{l}}}l}{{{f{n}}}n}{{{f{c}}{f{je}}}b{}{}}0{{{f{c}}}b{}}00`{A`{{f{c}}}{}}00{A`{{f{jc}}}{}}00`777{A`b}00{{{f{l}}{f{l}}}Ab}{{{f{l}}{f{jAd}}}Af}{{{f{n}}{f{jAd}}}Af}{cc{}}00{{{f{c}}}e{}{}}00{{}A`}00{ce{}{}}00{{{Ah{c}}}{{Ah{h}}}{}}00{{{Aj{c}}}{{Aj{h}}}{}}00{{{Al{c}}}{{Al{h}}}{}}00{{{f{c}}}Ab{}}00```{{AnB`Bb}Bd}```{{{f{Bd}}l}{{Bf{n}}}}{{{f{Bd}}l}{{Ah{{Bh{n}}}}}}{{{Bj{B`}}{Bj{B`}}}{{Bj{B`}}}}`{{{f{Bd}}{Bl{BbBb}}{Bl{BbBb}}Ab}{{Bj{B`}}}}`{{{f{Bd}}lBb}{{Bj{B`}}}}{{{f{Bd}}l{f{n}}Bb}{{Bj{B`}}}}{{{f{Bd}}{Bj{B`}}}{{Bj{B`}}}}{{{f{Bn}}{C`{B`}}}{{Bj{B`}}}}??{{{f{c}}}{{Bf{e}}}{}{}}00{{{f{c}}}e{}{}}00{c{{Cb{e}}}{}{}}00000{{{f{c}}}Cd{}}00{{{f{c}}}{{Bf{{f{e}}}}}{}{}}00`{ce{}{}}00``{{{f{c}}}{{f{h}}}{}}0{{{f{jc}}}{{f{jh}}}{}}0{{{f{c}}}{{f{e}}}{}{}}0{{{f{jc}}}{{f{je}}}{}{}}0```{A`{{f{c}}}{}}0{A`{{f{jc}}}{}}033{A`b}0{cc{}}0<<``{{}A`}099{{{Ah{c}}}{{Ah{h}}}{}}0{{{Aj{c}}}{{Aj{h}}}{}}0{{{Al{c}}}{{Al{h}}}{}}0{{{f{c}}}Ab{}}0{{Cf{Aj{{Ch{Bn}}}}}Cj}``{{{f{jCj}}Cl{f{An}}}b}{Cnb}``````{{{f{c}}}{{Bf{e}}}{}{}}0{{{f{c}}}e{}{}}0{c{{Cb{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0{ce{}{}}0`````````{{{f{c}}}{{f{h}}}{}}0{{{f{jc}}}{{f{jh}}}{}}0{{{f{c}}}{{f{e}}}{}{}}0{{{f{jc}}}{{f{je}}}{}{}}0``{{{f{An}}}An}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}`{A`{{f{c}}}{}}0{A`{{f{jc}}}{}}0{{{D`{c}}e}{{Cb{g}}}{{Dd{Db}}Df}Dh{}}77{A`b}0{{{f{An}}{f{jAd}}}Af}{cc{}}0{{{f{c}}}e{}{}}0{{}A`}0??{{{Ah{c}}}{{Ah{h}}}{}}0{{{Aj{c}}}{{Aj{h}}}{}}0{{{Al{c}}}{{Al{h}}}{}}0{{{f{c}}}Ab{}}0``{c{{d{An}}}{{Dd{Db}}}}````{{{f{An}}c}CbDj}```7{{{f{c}}}{{Bf{e}}}{}{}}088`{c{{Cb{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0{ce{}{}}0``{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{Dl}}}Dl}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{{}Dl}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Dl}}}Dh}8{A`b}{{{f{Dl}}{f{Dl}}}Ab}{{{f{Dl}}{f{jAd}}}Af}`{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}`{{}c{}}`{{{f{Dl}}B`B`}l}`{{{f{Dl}}c}CbDj}9{{{f{c}}}{{Bf{e}}}{}{}}:{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}`{{{f{c}}}{{Bf{{f{e}}}}}{}{}};``{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Dn}}}Dh}4{A`b}`{cc{}}{{{f{c}}}e{}{}}`{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}``{{{f{Dn}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}8{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}`{{{f{c}}}{{Bf{{f{e}}}}}{}{}}9``{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{E`}}}E`}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}0`{{}E`}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{E`}}}Dh}8{A`b}{{{f{E`}}{f{E`}}}Ab}{{{f{E`}}{f{jAd}}}Af}{cc{}}{{{f{c}}}e{}{}}{{}A`}`{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{}c{}}`{{{f{E`}}c}CbDj}8{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:``{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Eb}}}Dh}4{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}`{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}``{{{f{Eb}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}8{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}9``{{{f{c}}}{{f{h}}}{}}0{{{f{jc}}}{{f{jh}}}{}}0{{{f{c}}}{{f{e}}}{}{}}0{{{f{jc}}}{{f{je}}}{}{}}0{{{f{Ed}}}Ed}{{{f{Ef}}}Ef}{{{f{c}}{f{je}}}b{}{}}0{{{f{c}}}b{}}00{{}Ef}{A`{{f{c}}}{}}0{A`{{f{jc}}}{}}0```88{A`b}0{{{f{Ef}}{f{Ef}}}Ab}{{{f{c}}{f{e}}}Ab{}{}}00{{{f{Ed}}{f{jAd}}}Af}{{{f{Ef}}{f{jAd}}}Af}{cc{}}0{Eh{{Bf{Ef}}}}{{{f{c}}}e{}{}}0`{{}A`}0{ce{}{}}0{{{Ah{c}}}{{Ah{h}}}{}}0{{{Aj{c}}}{{Aj{h}}}{}}0{{{Al{c}}}{{Al{h}}}{}}0{{{f{c}}}Ab{}}0`{{}c{}}{EfAb}`0``88{{{f{c}}}{{Bf{e}}}{}{}}0991{c{{Cb{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0::``{{{f{c}}}{{f{h}}}{}}0{{{f{jc}}}{{f{jh}}}{}}0{{{f{c}}}{{f{e}}}{}{}}0{{{f{jc}}}{{f{je}}}{}{}}0`{{{f{Ej}}}Ej}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{A`{{f{c}}}{}}0{A`{{f{jc}}}{}}0{{{El{c}}e}{{Cb{g}}}{{Dd{Db}}}Dh{}}77{A`b}0{cEn{{Dd{Db}}}}{{{f{Ej}}{f{jAd}}}Af}{cc{}}0{{c{F`{B`}}{Fb{B`}}{Fd{B`}}}{{d{Ej}}}{{Dd{Db}}}}{{{f{c}}}e{}{}}0{{}A`}0{{{f{Ej}}lB`}{{Bf{n}}}}{ce{}{}}0{{{Ah{c}}}{{Ah{h}}}{}}0{{{Aj{c}}}{{Aj{h}}}{}}0{{{Al{c}}}{{Al{h}}}{}}0{{{f{c}}}Ab{}}0{c{{d{Bn}}}{{Dd{Db}}}}``````{{{f{Ej}}c}CbDj}9{{{f{c}}}{{Bf{e}}}{}{}}0::{{{f{Ej}}}{{Ff{B`}}}}``{{{f{Fh}}{f{Fj}}{Bf{A`}}{f{j{Bl{BbBbBb}}}}}{{Fn{Fl}}}}{c{{Cb{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0<<``{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{G`}}}Dh}4{A`b}`{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}```{{{f{G`}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}8{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}9````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{Gb}}}Gb}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{{}Gb}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Gb}}}Dh}8{A`b}{{{f{Gb}}{f{Gb}}}Ab}{{{f{Gb}}{f{jAd}}}Af}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}`{{}c{}}`{{{f{Gb}}c}CbDj}`8{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Gd}}}Dh}4{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}``{{{f{Gd}}c}CbDj}`{{{f{c}}}{{Bf{e}}}{}{}}8{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}9```{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{Gf}}}Gf}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{{}Gf}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Gf}}}Dh}8{A`b}{{{f{Gf}}{f{Gf}}}Ab}{{{f{Gf}}{f{jAd}}}Af}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{c{{d{Gf}}}{{Dd{Db}}}}{{}c{}}{{{f{Gf}}c}CbDj}9{{{f{c}}}{{Bf{e}}}{}{}}:{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}};``````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{Gh}}}Dh}4{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{{f{Gh}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}8{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}9````{{{f{Fl}}}{{Gj{B`}}}}{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}```{{{f{Fl}}}A`}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}````{{{f{Fl}}}Fl}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}6{A`b}{{{f{Fl}}{f{Fl}}}Ab}{{{f{Fl}}{f{jAd}}}Af}{cc{}}{{{f{c}}}e{}{}}{{}A`}{{{f{Fl}}lB`}{{Bf{{Bl{B`B`B`}}}}}}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}`{{{Gl{B`}}{Gl{B`}}{Gl{B`}}{Bj{B`}}{Bj{B`}}{Bj{B`}}{C`{B`}}{C`{B`}}{C`{B`}}{Bf{A`}}}Fl}{{{f{jFl}}A`}b}9{{{f{c}}}{{Bf{e}}}{}{}}:{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}`{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{{Bj{B`}}}}}Dh}{c{{Cb{Gn}}}Dh}5{A`b}{cc{}}{{{f{c}}}e{}{}}`{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}`{{{f{{Bj{B`}}}}c}CbDj}{{{f{Gn}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:`{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{{Gl{B`}}}}}Dh}{c{{Cb{H`}}}Dh}5{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{{f{{Gl{B`}}}}c}CbDj}{{{f{H`}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}{c{{Cb{{Bj{B`}}}}}Dh}{c{{Cb{Hb}}}Dh}5{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{{f{{Bj{B`}}}}c}CbDj}{{{f{Hb}}c}CbDj}{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:```````{{{f{c}}}{{f{h}}}{}}0{{{f{jc}}}{{f{jh}}}{}}0{{{f{c}}}{{f{e}}}{}{}}0{{{f{jc}}}{{f{je}}}{}{}}0`{A`{{f{c}}}{}}0{A`{{f{jc}}}{}}033{A`b}0{{{f{Hd}}{f{Hd}}}Ab}{cc{}}0{{{f{c}}}e{}{}}0{{}A`}0{ce{}{}}0{{{Ah{c}}}{{Ah{h}}}{}}0{{{Aj{c}}}{{Aj{h}}}{}}0{{{Al{c}}}{{Al{h}}}{}}0{{{f{c}}}Ab{}}0{{{f{Hf}}}{{d{Hh}}}}``````````{{{f{c}}}{{Bf{e}}}{}{}}088{c{{Cb{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0{{{f{jHh}}{f{Cl}}{f{jHj}}}b}::````{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{jHl}}{f{Hn}}{f{I`}}Ab}b}{{{f{Hl}}}Hl}{{{f{c}}{f{je}}}b{}{}}{{{f{c}}}b{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}7{A`b}`{cc{}}{{{f{c}}}e{}{}}``{{{f{Ib}}{f{j{Bf{An}}}}}b}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{{f{jHl}}{f{Hn}}{f{I`}}{f{jAn}}}b}{{{Aj{{Id{{Bf{An}}}}}}}Hl}`{{{f{jHl}}{f{jHn}}{f{j{Bf{An}}}}}b}{{{f{Cl}}{f{{Bf{An}}}}If}b}`;{{{f{c}}}{{Bf{e}}}{}{}}<{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}<```````````{{{f{c}}}{{f{h}}}{}}0000{{{f{jc}}}{{f{jh}}}{}}0000`{{{f{c}}}{{f{e}}}{}{}}0000{{{f{jc}}}{{f{je}}}{}{}}0000{{{f{Ih}}}Ih}{{{f{Ij}}}Ij}{{{f{Il}}}Il}{{{f{c}}{f{je}}}b{}{}}00{{{f{c}}}b{}}0000`{{}Ij}{{}Il}{A`{{f{c}}}{}}0000{A`{{f{jc}}}{}}0000:::::{A`b}0000{{{f{Ij}}{f{jAd}}}Af}{{{f{Il}}{f{jAd}}}Af}{cc{}}0000{{{f{c}}}e{}{}}0000{{}A`}0000{{{f{In}}}b}`{ce{}{}}0000{{{Ah{c}}}{{Ah{h}}}{}}0000{{{Aj{c}}}{{Aj{h}}}{}}0000{{{Al{c}}}{{Al{h}}}{}}0000{{{f{c}}}Ab{}}000000``{{{Aj{{Id{{Bf{An}}}}}}}Ih}{{}c{}}0{{{f{Ih}}J`{f{jJb}}{f{Jd}}}b}``{{{f{Ih}}{f{Jf}}{f{Jh}}{f{Jj}}{f{jJl}}{f{jJd}}}{{Fn{Jn}}}}`;;;{{{f{c}}}{{Bf{e}}}{}{}}0000<<<<<`{c{{Cb{e}}}{}{}}000000000{{{f{c}}}Cd{}}0000`{{{f{c}}}{{Bf{{f{e}}}}}{}{}}0000``<<<<<`{{{f{jHn}}{f{jAn}}}b}{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{jAn}}{f{jHn}}}b}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}4{A`b}{{{Bl{BbBb}}}{{f{K`}}}}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{{f{jHn}}{f{jAn}}}b}{{{f{jKb}}}b}{{}Kb}`{{{f{jKb}}{f{jHn}}{f{jAn}}}b}{{{f{jHn}}{f{Cj}}{f{jAn}}}b}{{{f{jKb}}{f{jAn}}{f{jHn}}{f{Cj}}}b}0`2{{{f{c}}}{{Bf{e}}}{}{}}={c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}>{{{f{jHn}}{f{j{Kd{B`}}}}}b}`{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}3{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{}Kf}`{{{f{jKf}}{f{jHn}}{f{An}}{f{Cj}}}b}{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:``{{{f{jKh}}{f{jHn}}}b}{{{f{jKh}}{f{Hn}}}b}{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{A`{{f{c}}}{}}{A`{{f{jc}}}{}}3{A`b}{{{f{jKh}}{f{jHn}}{f{Cj}}}b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}}{{}Kh}{{{f{jHn}}{f{Cj}}}b}{{{f{jHn}}{f{jCj}}{Bf{{f{jAn}}}}{f{jHd}}}b}`{{{f{jKh}}{f{jHn}}{Bf{{f{jAn}}}}{f{jCj}}{f{jHd}}}b}`{{{f{c}}}{{Bf{e}}}{}{}};{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}<`{{{f{c}}}{{f{h}}}{}}{{{f{jc}}}{{f{jh}}}{}}{{{f{c}}}{{f{e}}}{}{}}{{{f{jc}}}{{f{je}}}{}{}}{{{f{jKj}}{f{j{Bf{An}}}}{f{jHn}}}b}{{{f{jKj}}}b}`{A`{{f{c}}}{}}{A`{{f{jc}}}{}}5{A`b}{cc{}}{{{f{c}}}e{}{}}{{}A`}{ce{}{}}{{{Ah{c}}}{{Ah{h}}}{}}{{{Aj{c}}}{{Aj{h}}}{}}{{{Al{c}}}{{Al{h}}}{}}{{{f{c}}}Ab{}};{{}Kj}`{{{f{{Bf{An}}}}}b}>{{{f{c}}}{{Bf{e}}}{}{}}9{c{{Cb{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{c}}}{{Bf{{f{e}}}}}{}{}}:","D":"Ld","p":[[1,"unit"],[8,"Result",1258],[1,"reference"],[10,"Any",1259],[0,"mut"],[5,"Ray",10],[5,"Hit",10],[1,"usize"],[1,"bool"],[5,"Formatter",1260],[8,"Result",1260],[5,"Box",1261],[5,"Arc",1262],[5,"Rc",1263],[5,"Scene",179],[1,"f32"],[1,"u32"],[5,"Raytracer",10],[6,"Option",1264],[1,"slice"],[8,"Vector3",1265],[1,"tuple"],[8,"RgbImage",1266],[8,"Vector2",1265],[6,"Result",1267],[5,"TypeId",1259],[5,"TextureHandle",1268],[5,"Mutex",1269],[5,"Render",115],[5,"Context",1270],[5,"RenderingThread",115],[5,"WithRelativePath",179],[5,"Path",1271],[10,"AsRef",1272],[10,"Sync",1273],[10,"Deserializer",1274],[10,"Serializer",1275],[5,"Camera",256],[5,"CameraDef",297],[5,"Light",329],[5,"LightDef",368],[5,"Material",397],[5,"IlluminationModel",397],[1,"i32"],[5,"Object",474],[5,"WithRelativePath",474],[5,"String",1276],[8,"Translation3",1277],[8,"UnitQuaternion",1278],[8,"Scale3",1279],[8,"Affine3",1280],[5,"Obj",1281],[5,"SimplePolygon",1281],[5,"Triangle",715],[5,"Vec",1282],[5,"ObjectDef",545],[5,"Settings",575],[5,"SettingsDef",616],[6,"Skybox",647],[6,"SkyboxDef",687],[5,"Aabb",1283],[8,"Point3",1284],[5,"Yaml",764],[5,"Yaml",795],[5,"Yaml",826],[6,"Tab",857],[5,"CreationContext",1285],[5,"App",857],[5,"Frame",1285],[5,"Preview",923],[5,"Ui",1286],[5,"Response",1287],[5,"PathBuf",1271],[5,"RwLock",1288],[5,"Rect",1289],[5,"WgpuPainter",963],[5,"ShaderUniforms",963],[5,"ShaderLight",963],[5,"RenderState",1290],[5,"PaintCallbackInfo",1291],[5,"RenderPass",1292],[8,"CallbackResources",1293],[5,"Device",1292],[5,"Queue",1292],[5,"ScreenDescriptor",1293],[5,"CommandEncoder",1292],[5,"CommandBuffer",1292],[1,"str"],[5,"Properties",1127],[5,"XYZ",1294],[5,"RenderResult",1165],[5,"StatusBar",1193],[5,"YamlMenu",1226],[8,"Color",179],[15,"Image",685],[5,"Resources",963],[5,"VertexCount",963]],"r":[[179,256],[181,329],[182,397],[183,474],[185,575],[186,647]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAIgERgAAAAAAAgAwADYABQA/AAwATQAFAFQAAQBYACUAgAAIAIsAAgCPAAEAkwAIAJ4AAACgAAEAowAAAKYAIwDLAAkA1wADAN0ANAATAQEAFgEGAB4BFgA2AQIAOgEhAF0BAgBhARkAfAECAIABDQCPASEAswEFALsBOAD2AQUA/gEXABcCFQAuAgEAMQIhAFQCAQBXAh0AdgIBAHkCIACbAgEAngIdAL0CAQDAAiUA5wIBAOsCDgD9AgsACgMCAA4DGAAoAwEAKwMaAEcDAQBKAw8AWwMUAHIDAwB4AzIArAMEALIDVQANBAsAHgRVAHUEAQB4BAYAgAQDAIUEEQCYBAEAmwQaALcEAQC6BAgAxAQSANgEAQDbBA8A"}]\ -]')); +var searchIndex = new Map(JSON.parse('[["trayracer",{"t":"JJJJJJHCCCFTFFNNNNNNNNNNNNNNNNNNNNONNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOONOOONNNCNONNNNNNNNNNNNNNNNNNNNNNNNONNNFFNNNNNNNNOOONNNNNNNNNNNNOONNNNNNNNNNNNNOONNOOOOOONNNNNNNNNNNNNNEIEEEFEEFNNNNNNNNNCONNNONNNNNNNNNNNNNNNNNNNNNNNNNNCONCCOONCOCNNNNNCNNNNNNNNNNCFNNNNNNNNNNNNNNNNONNNNNNNNONONONNNNNNNONNCFNNNNNNNNNONNONNNNNNOONNNNNNONNOFNNNNNNNNONNNNNNNNNNNONNNNNNONNNNNNNNNCFNNNNNNNNNNNNONNNNNOONNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNONNNNNNNNNNNNONNONOONNNNNNNNNNNNNNNNNFFNNNNNNNNNONNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNHOOOOOONNNNNNNOOHNNNNNNNNNNCFNNNNNNNNNONNNNNNNNOOONNNNNNNNFNOOONNNNNNNNNNNNNNNNNNNNNNNONONONNNNNNNNCFOONNNNNNNNNNNNNNNNNOONONNNNNNNPPGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOOPPGNNNNNNNNNNNNNNNNNNNNNNNNNFNOOONNNOOONNNOOOONNNNNNNNNNNNNNNNNNONNNNNNNNNNCCCFNNONNNNHNNNNNONNNNNNOHNNNNNNNNFNNNNNNHNNNNNNNNNNNHNNNNNNNNOOOFNNNNNNHNNNNNNNNNNNHNNNNNNNNOOOFPPGNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNCOCOOOCOCONNNNNNNNNNNNNNNOCFNONNNNNNNNNNNNONNCONNNNNNNNNONNONNNNNNNNTTFFFFFNNNOOOONNNNNNNNNNONNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHONNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNOONONNNNNNNNNNNNNONNNNNNNNNNNNNNNONNNNNOONNNNNFNNNNNNNNNNNNNNNNNNNNNONNNNONNNNNNNNHFNNNNNNNNNNNNNNNNNONNNNNNNNOFNNNNNNNNNNNNNNNNNNNNNONONNNNNNNFNNNNNNONNNNNNNNNNNNNONNNNNNNNN","n":["_RUST_I18N_BACKEND","_RUST_I18N_FALLBACK_LOCALE","_RUST_I18N_MINIFY_KEY","_RUST_I18N_MINIFY_KEY_LEN","_RUST_I18N_MINIFY_KEY_PREFIX","_RUST_I18N_MINIFY_KEY_THRESH","main","raytracer","scene","ui","Hit","NO_MATERIAL_COLOR","Ray","Raytracer","__clone_box","","as_any","","","as_any_mut","","","borrow","","","borrow_mut","","","clone","","clone_into","","clone_to_uninit","","delta","deref","","","deref_mut","","","direction","downcast","","","drop","","","eq","fmt","","from","","","from_subset","","","init","","","into","","","into_any","","","into_any_arc","","","into_any_rc","","","is_in_subset","","","material","max_depth","name","new","normal","origin","point","raycast","raycast_transparent","reflect","render","","scene","shade","shade_impl","skybox","texture","to_owned","","to_subset","","","to_subset_unchecked","","","try_from","","","try_into","","","type_id","","","upcast","","","uv","vzip","","","Render","RenderingThread","as_any","","as_any_mut","","borrow","","borrow_mut","","cancel","","ctx","deref","","deref_mut","","downcast","","drop","","from","","from_subset","","image","","init","","into","","into_any","","into_any_arc","","into_any_rc","","is_in_subset","","new","progress","","render","run","scene","texture","","thread","time","","to_subset","","to_subset_unchecked","","try_from","","try_into","","type_id","","upcast","","vzip","","Camera","Color","Light","Material","Object","Scene","Settings","Skybox","WithRelativePath","__clone_box","as_any","","as_any_mut","","borrow","","borrow_mut","","camera","","clone","clone_into","clone_to_uninit","data","deref","","deref_mut","","deserialize","downcast","","drop","","fmt","from","","from_subset","","init","","into","","into_any","","into_any_arc","","into_any_rc","","is_in_subset","","light","lights","load","material","object","objects","path","serialize","settings","","skybox","to_owned","to_subset","","to_subset_unchecked","","triangle","try_from","","try_into","","type_id","","upcast","","vzip","","yaml","Camera","__clone_box","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","fov","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","look_at","null_value","position","ray","resolution","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","up","upcast","vzip","yaml","CameraDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","field_of_view","from","from_subset","height","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","look_at","position","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","up_vec","upcast","vzip","width","Light","__clone_box","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","color","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","intensity","into","into_any","into_any_arc","into_any_rc","is_in_subset","null_value","position","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","LightDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","intensity","into","into_any","into_any_arc","into_any_rc","is_in_subset","ke","position","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","IlluminationModel","Material","__clone_box","","as_any","","as_any_mut","","borrow","","borrow_mut","","clone","","clone_into","","clone_to_uninit","","default","deref","","deref_mut","","diffuse_color","diffuse_texture","dissolve","downcast","","drop","","eq","equivalent","","","fmt","","from","","from_i32","from_subset","","illumination_model","init","","into","","into_any","","into_any_arc","","into_any_rc","","is_in_subset","","name","null_value","reflection","refraction_index","specular","specular_color","specular_exponent","to_owned","","to_subset","","to_subset_unchecked","","transparency","try_from","","try_into","","type_id","","upcast","","vzip","","Object","WithRelativePath","__clone_box","as_any","","as_any_mut","","borrow","","borrow_mut","","bvh","clone","clone_into","clone_to_uninit","deref","","deref_mut","","deserialize","downcast","","drop","","filename","fmt","from","","from_obj","from_subset","","init","","intersect","into","","into_any","","into_any_arc","","into_any_rc","","is_in_subset","","load_texture","material_name","materials","name","path","rotation","scale","serialize","to_owned","to_subset","","to_subset_unchecked","","transform","translation","triangles","triangulate","try_from","","try_into","","type_id","","upcast","","vzip","","yaml","ObjectDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","file_path","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","position","rotation","scale","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Settings","__clone_box","ambient_color","ambient_intensity","anti_aliasing","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","max_bounces","null_value","samples","serialize","skybox","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","SettingsDef","ambient_color","anti_aliasing","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","max_bounces","samples","serialize","skybox","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Color","Image","Skybox","__clone_box","as_any","as_any_mut","borrow","borrow_mut","clone","clone_into","clone_to_uninit","default","deref","deref_mut","deserialize","downcast","drop","eq","fmt","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","load_from_path","null_value","serialize","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","yaml","image","path","Color","Path","SkyboxDef","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Triangle","__clone_box","a","a_normal","a_uv","aabb","as_any","as_any_mut","b","b_normal","b_uv","bh_node_index","borrow","borrow_mut","bvh_index","c","c_normal","c_uv","clone","clone_into","clone_to_uninit","deref","deref_mut","downcast","drop","eq","fmt","from","from_subset","init","intersect","into","into_any","into_any_arc","into_any_rc","is_in_subset","material_index","new","set_bh_node_index","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","color","point","vector","Yaml","as_any","as_any_mut","b","borrow","borrow_mut","deref","deref_mut","deserialize","","downcast","drop","from","from_subset","g","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","r","serialize","","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","Yaml","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","x","y","z","Yaml","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","deserialize","","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","serialize","","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","x","y","z","App","Preview","RenderResult","Tab","as_any","","as_any_mut","","borrow","","borrow_mut","","current_tab","deref","","deref_mut","","downcast","","drop","","eq","from","","from_subset","","init","","into","","into_any","","into_any_arc","into_any_rc","","is_in_subset","","new","preview","","properties","","render","render_result","renderresult","scene","statusbar","","to_subset","","to_subset_unchecked","","try_from","","try_into","","type_id","","upcast","","update","vzip","","yaml_menu","yamlmenu","Preview","__clone_box","active","as_any","as_any_mut","borrow","borrow_mut","change_preview_movement","clone","clone_into","clone_to_uninit","deref","deref_mut","downcast","drop","dropped_files","from","from_subset","gpu","","handle_file","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","move_camera","new","sensitivity","show","show_hover_overlay","speed","to_owned","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","MAX_LIGHTS","MAX_OBJECTS","Resources","ShaderLight","ShaderUniforms","VertexCount","WgpuPainter","__clone_box","","","_pad","","ambient_color","ambient_intensity","as_any","","","","","as_any_mut","","","","","bind_group","borrow","","","","","borrow_mut","","","","","clone","","","clone_into","","","clone_to_uninit","","","color","default","","deref","","","","","deref_mut","","","","","downcast","","","","","drop","","","","","fmt","","from","","","","","from_subset","","","","","init","","","","","init_wgpu","intensity","into","","","","","into_any","","","","","into_any_arc","","","","","into_any_rc","","","","","is_in_subset","","","","","is_valid_bit_pattern","","lights_buffer","lights_count","new","null_value","","paint","pipeline","position","prepare","scene","to_owned","","","to_subset","","","","","to_subset_unchecked","","","","","transforms_buffer","try_from","","","","","try_into","","","","","type_id","","","","","uniform_buffer","upcast","","","","","vertex_buffer","view","vzip","","","","","Properties","ambient_options","as_any","as_any_mut","borrow","borrow_mut","camera_settings","deref","deref_mut","downcast","drop","format_render_size","from","from_subset","init","into","into_any","into_any_rc","is_in_subset","lights","load_skybox_img","new","object_dialog","objects","render_options","scene_settings","show","skybox_dialog","skybox_options","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","xyz_drag_value","RenderResult","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","downcast","drop","from","from_subset","init","into","into_any","into_any_arc","into_any_rc","is_in_subset","new","position","show","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","zoom","StatusBar","about_us_button","about_window","as_any","as_any_mut","borrow","borrow_mut","deref","deref_mut","downcast","drop","export_button","from","from_subset","init","into","into_any","into_any_rc","is_in_subset","new","progress_bar","render_button","save_render_dialog","show","show_about","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip","YamlMenu","as_any","as_any_mut","borrow","borrow_mut","buttons","create_scene","create_yaml_dialog","deref","deref_mut","downcast","drop","from","from_subset","init","into","into_any","into_any_rc","is_in_subset","load_scene","new","open_yaml_dialog","save_scene","show","to_subset","to_subset_unchecked","try_from","try_into","type_id","upcast","vzip"],"q":[[0,"trayracer"],[10,"trayracer::raytracer"],[116,"trayracer::raytracer::render"],[180,"trayracer::scene"],[258,"trayracer::scene::camera"],[300,"trayracer::scene::camera::yaml"],[332,"trayracer::scene::light"],[371,"trayracer::scene::light::yaml"],[400,"trayracer::scene::material"],[478,"trayracer::scene::object"],[550,"trayracer::scene::object::yaml"],[580,"trayracer::scene::settings"],[622,"trayracer::scene::settings::yaml"],[653,"trayracer::scene::skybox"],[692,"trayracer::scene::skybox::Skybox"],[694,"trayracer::scene::skybox::yaml"],[722,"trayracer::scene::triangle"],[769,"trayracer::scene::yaml"],[772,"trayracer::scene::yaml::color"],[803,"trayracer::scene::yaml::point"],[834,"trayracer::scene::yaml::vector"],[865,"trayracer::ui"],[930,"trayracer::ui::preview"],[971,"trayracer::ui::preview::gpu"],[1136,"trayracer::ui::properties"],[1173,"trayracer::ui::renderresult"],[1201,"trayracer::ui::statusbar"],[1233,"trayracer::ui::yamlmenu"],[1264,"anyhow"],[1265,"dyn_clone::sealed"],[1266,"core::any"],[1267,"core::fmt"],[1268,"alloc::boxed"],[1269,"alloc::sync"],[1270,"alloc::rc"],[1271,"core::option"],[1272,"nalgebra::base::alias"],[1273,"image::buffer_"],[1274,"core::result"],[1275,"epaint::texture_handle"],[1276,"epaint::mutex::mutex_impl"],[1277,"egui::context"],[1278,"std::path"],[1279,"core::convert"],[1280,"core::marker"],[1281,"serde::de"],[1282,"serde::ser"],[1283,"alloc::string"],[1284,"nalgebra::geometry::translation_alias"],[1285,"nalgebra::geometry::quaternion"],[1286,"nalgebra::geometry::scale_alias"],[1287,"nalgebra::geometry::transform_alias"],[1288,"obj::obj"],[1289,"alloc::vec"],[1290,"bvh::aabb"],[1291,"nalgebra::geometry::point_alias"],[1292,"eframe::epi"],[1293,"egui::ui"],[1294,"egui::response"],[1295,"epaint::mutex::rw_lock_impl"],[1296,"emath::rect"],[1297,"egui_wgpu"],[1298,"epaint::shape"],[1299,"wgpu::api::render_pass"],[1300,"egui_wgpu::renderer"],[1301,"wgpu::api::device"],[1302,"wgpu::api::queue"],[1303,"wgpu::api::command_encoder"],[1304,"wgpu::api::command_buffer"],[1305,"nalgebra::base::coordinates"]],"i":"```````````Bf``nA`210210210210101010221021012102101102102102102102102102102100202010222`222222102102102102102102100210``ClD`101010100101010101010101010101010101101001011010101010101010`````````B`Db1010101`1111Kn12121121221212121212121212`22``222`2`21212`1212121212``Dn000000000000000000000000000000000000000``E`000000000000000000000000000000`Eb000000000000000000000000000000000000``Ed000000000000000000000000000``EfEh10101010101010010101111010000010100101101010101010100101110101001010101010``ElEn10101011111010100101`1011010110101010101`111111110101111`0101010101``Gb0000000000000000000000000000`Gd000000000000000000000000000000000000000``Gf00000000000000000000000000000Gh0`00000000000000000000000000000000000`L`0Gj0`0000000000000000000000000`Fn000000000000000000000000000000000000000000000````H`000000`0000000000000`00000000`Hb00000`00000000000`00000000000`Hd00000`00000000000`00000000000`Hf0`Hj101010100101010110101010101101010`0`000`0`00101010101010010``Hn0000000000000000`0000000000000000000000Ij0`````0IlIn1011LbLd43210432110432104324324324322321043210432104321043232104321043210432`21043210432104321043210432321343241244432104321043211043210432104321104321310432`Kd0000000000000000000000000000000000``Kh00000000000000000000000000`Kj000000000000000000000000000000`Kl00000000000000000000000000000","f":"``````{{}{{d{b}}}}```````{{fh}b}0{f{{f{j}}}}00{{{f{l}}}{{f{lj}}}}00{f{{f{c}}}{}}00{{{f{l}}}{{f{lc}}}{}}00{{{f{n}}}n}{{{f{A`}}}A`}{{f{f{lc}}}b{}}0{fb}0`{Ab{{f{c}}}{}}00{Ab{{f{lc}}}{}}00`777{Abb}00{{{f{n}}{f{n}}}Ad}{{{f{n}}{f{lAf}}}Ah}{{{f{A`}}{f{lAf}}}Ah}{cc{}}00{{{f{c}}}e{}{}}00{{}Ab}00{{}c{}}00{{{Aj{c}}}{{Aj{j}}}{}}00{{{Al{c}}}{{Al{j}}}{}}00{{{An{c}}}{{An{j}}}{}}00{fAd}00```{{B`BbBd}Bf}```{{{f{Bf}}n}{{Bh{A`}}}}{{{f{Bf}}n}{{Aj{{Bj{A`}}}}}}{{{Bl{Bb}}{Bl{Bb}}}{{Bl{Bb}}}}`{{{f{Bf}}{Bn{BdBd}}{Bn{BdBd}}Ad}{{Bl{Bb}}}}`{{{f{Bf}}nBd}{{Bl{Bb}}}}{{{f{Bf}}n{f{A`}}Bd}{{Bl{Bb}}}}{{{f{Bf}}{Bl{Bb}}}{{Bl{Bb}}}}{{{f{C`}}{Cb{Bb}}}{{Bl{Bb}}}}{fc{}}0{f{{Bh{c}}}{}}00111{c{{Cd{e}}}{}{}}00{{}{{Cd{c}}}{}}00{fCf}00{f{{Bh{{f{c}}}}}{}}00`{{}c{}}00``{f{{f{j}}}}0{{{f{l}}}{{f{lj}}}}0{f{{f{c}}}{}}0{{{f{l}}}{{f{lc}}}{}}0```{Ab{{f{c}}}{}}0{Ab{{f{lc}}}{}}033{Abb}0{cc{}}0{{{f{c}}}e{}{}}0``{{}Ab}0::{{{Aj{c}}}{{Aj{j}}}{}}0{{{Al{c}}}{{Al{j}}}{}}0{{{An{c}}}{{An{j}}}{}}0{fAd}0{{Ch{Al{{Cj{C`}}}}}Cl}``{{{f{lCl}}Cn{f{B`}}}b}{D`b}``````{f{{Bh{c}}}{}}0{fc{}}0{c{{Cd{e}}}{}{}}0{{}{{Cd{c}}}{}}0{fCf}0{f{{Bh{{f{c}}}}}{}}0{{}c{}}0`````````{{fh}b}{f{{f{j}}}}0{{{f{l}}}{{f{lj}}}}0{f{{f{c}}}{}}0{{{f{l}}}{{f{lc}}}{}}0``{{{f{B`}}}B`}{{f{f{lc}}}b{}}{fb}`{Ab{{f{c}}}{}}0{Ab{{f{lc}}}{}}0{{{Db{c}}e}{{Cd{g}}}{{Df{Dd}}Dh}Dj{}}77{Abb}0{{{f{B`}}{f{lAf}}}Ah}{cc{}}0{{{f{c}}}e{}{}}0{{}Ab}0{{}c{}}0{{{Aj{c}}}{{Aj{j}}}{}}0{{{Al{c}}}{{Al{j}}}{}}0{{{An{c}}}{{An{j}}}{}}0{fAd}0``{c{{d{B`}}}{{Df{Dd}}}}````{{{f{B`}}c}CdDl}```{fc{}}{f{{Bh{c}}}{}}011`{c{{Cd{e}}}{}{}}0{{}{{Cd{c}}}{}}0{fCf}0{f{{Bh{{f{c}}}}}{}}0<<``{{fh}b}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{Dn}}}Dn}{{f{f{lc}}}b{}}{fb}{{}Dn}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Dn}}}Dj}8{Abb}{{{f{Dn}}{f{Dn}}}Ad}{{{f{Dn}}{f{lAf}}}Ah}`{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}`4`{{{f{Dn}}BbBb}n}`{{{f{Dn}}c}CdDl}{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}`{f{{Bh{{f{c}}}}}{}}<``{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{E`}}}Dj}4{Abb}`{cc{}}{{{f{c}}}e{}{}}`{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}``{{{f{E`}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}`{f{{Bh{{f{c}}}}}{}};``{{fh}b}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{Eb}}}Eb}{{f{f{lc}}}b{}}{fb}`{{}Eb}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Eb}}}Dj}8{Abb}{{{f{Eb}}{f{Eb}}}Ad}{{{f{Eb}}{f{lAf}}}Ah}{cc{}}{{{f{c}}}e{}{}}{{}Ab}`{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}4`{{{f{Eb}}c}CdDl}{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};``{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Ed}}}Dj}4{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}`{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}``{{{f{Ed}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};``{{fh}b}0{f{{f{j}}}}0{{{f{l}}}{{f{lj}}}}0{f{{f{c}}}{}}0{{{f{l}}}{{f{lc}}}{}}0{{{f{Ef}}}Ef}{{{f{Eh}}}Eh}{{f{f{lc}}}b{}}0{fb}0{{}Eh}{Ab{{f{c}}}{}}0{Ab{{f{lc}}}{}}0```88{Abb}0{{{f{Eh}}{f{Eh}}}Ad}{{f{f{c}}}Ad{}}00{{{f{Ef}}{f{lAf}}}Ah}{{{f{Eh}}{f{lAf}}}Ah}{cc{}}0{Ej{{Bh{Eh}}}}{{{f{c}}}e{}{}}0`{{}Ab}0{{}c{}}0{{{Aj{c}}}{{Aj{j}}}{}}0{{{Al{c}}}{{Al{j}}}{}}0{{{An{c}}}{{An{j}}}{}}0{fAd}0`4{EhAd}`0``{fc{}}0{f{{Bh{c}}}{}}0112{c{{Cd{e}}}{}{}}0{{}{{Cd{c}}}{}}0{fCf}0{f{{Bh{{f{c}}}}}{}}0;;``{{fh}b}{f{{f{j}}}}0{{{f{l}}}{{f{lj}}}}0{f{{f{c}}}{}}0{{{f{l}}}{{f{lc}}}{}}0`{{{f{El}}}El}{{f{f{lc}}}b{}}{fb}{Ab{{f{c}}}{}}0{Ab{{f{lc}}}{}}0{{{En{c}}e}{{Cd{g}}}{{Df{Dd}}}Dj{}}77{Abb}0{cF`{{Df{Dd}}}}{{{f{El}}{f{lAf}}}Ah}{cc{}}0{{c{Fb{Bb}}{Fd{Bb}}{Ff{Bb}}}{{d{El}}}{{Df{Dd}}}}{{{f{c}}}e{}{}}0{{}Ab}0{{{f{El}}nBb}{{Bh{A`}}}}{{}c{}}0{{{Aj{c}}}{{Aj{j}}}{}}0{{{Al{c}}}{{Al{j}}}{}}0{{{An{c}}}{{An{j}}}{}}0{fAd}0{c{{d{C`}}}{{Df{Dd}}}}``````{{{f{El}}c}CdDl}{fc{}}{f{{Bh{c}}}{}}011{{{f{El}}}{{Fh{Bb}}}}``{{{f{Fj}}{f{Fl}}{Bh{Ab}}{f{l{Bn{BdBdBd}}}}}{{G`{Fn}}}}{c{{Cd{e}}}{}{}}0{{}{{Cd{c}}}{}}0{fCf}0{f{{Bh{{f{c}}}}}{}}0>>``{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Gb}}}Dj}4{Abb}`{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}```{{{f{Gb}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};`{{fh}b}```{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{Gd}}}Gd}{{f{f{lc}}}b{}}{fb}{{}Gd}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Gd}}}Dj}8{Abb}{{{f{Gd}}{f{Gd}}}Ad}{{{f{Gd}}{f{lAf}}}Ah}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}`4`{{{f{Gd}}c}CdDl}`{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};````{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Gf}}}Dj}4{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}``{{{f{Gf}}c}CdDl}`{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};```{{fh}b}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{Gh}}}Gh}{{f{f{lc}}}b{}}{fb}{{}Gh}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Gh}}}Dj}8{Abb}{{{f{Gh}}{f{Gh}}}Ad}{{{f{Gh}}{f{lAf}}}Ah}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{c{{d{Gh}}}{{Df{Dd}}}}5{{{f{Gh}}c}CdDl}{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<``````{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{Gj}}}Dj}4{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{{f{Gj}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};`{{fh}b}```{{{f{Fn}}}{{Gl{Bb}}}}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}```{{{f{Fn}}}Ab}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}````{{{f{Fn}}}Fn}{{f{f{lc}}}b{}}{fb}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}6{Abb}{{{f{Fn}}{f{Fn}}}Ad}{{{f{Fn}}{f{lAf}}}Ah}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{{f{Fn}}nBb}{{Bh{{Bn{BbBbBb}}}}}}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}`{{{Gn{Bb}}{Gn{Bb}}{Gn{Bb}}{Bl{Bb}}{Bl{Bb}}{Bl{Bb}}{Cb{Bb}}{Cb{Bb}}{Cb{Bb}}{Bh{Ab}}}Fn}{{{f{lFn}}Ab}b}{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<````{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}`{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{{Bl{Bb}}}}}Dj}{c{{Cd{H`}}}Dj}5{Abb}{cc{}}{{{f{c}}}e{}{}}`{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}`{{{f{{Bl{Bb}}}}c}CdDl}{{{f{H`}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<`{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{{Gn{Bb}}}}}Dj}{c{{Cd{Hb}}}Dj}5{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{{f{{Gn{Bb}}}}c}CdDl}{{{f{Hb}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<````{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}{c{{Cd{{Bl{Bb}}}}}Dj}{c{{Cd{Hd}}}Dj}5{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{{f{{Bl{Bb}}}}c}CdDl}{{{f{Hd}}c}CdDl}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<```````{f{{f{j}}}}0{{{f{l}}}{{f{lj}}}}0{f{{f{c}}}{}}0{{{f{l}}}{{f{lc}}}{}}0`{Ab{{f{c}}}{}}0{Ab{{f{lc}}}{}}033{Abb}0{{{f{Hf}}{f{Hf}}}Ad}{cc{}}0{{{f{c}}}e{}{}}0{{}Ab}0{{}c{}}0{{{Aj{c}}}{{Aj{j}}}{}}0{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}0{fAd}0{{{f{Hh}}}{{d{Hj}}}}``````````{f{{Bh{c}}}{}}0{fc{}}0{c{{Cd{e}}}{}{}}0{{}{{Cd{c}}}{}}0{fCf}0{f{{Bh{{f{c}}}}}{}}0{{{f{lHj}}{f{Cn}}{f{lHl}}}b}<<```{{fh}b}`{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{lHn}}{f{I`}}{f{Ib}}Ad}b}{{{f{Hn}}}Hn}{{f{f{lc}}}b{}}{fb}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}7{Abb}`{cc{}}{{{f{c}}}e{}{}}``{{{f{Id}}{f{l{Bh{B`}}}}}b}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{{f{lHn}}{f{I`}}{f{Ib}}{f{lB`}}}b}{{{Al{{If{{Bh{B`}}}}}}}Hn}`{{{f{lHn}}{f{lI`}}{f{l{Bh{B`}}}}}b}{{{f{Cn}}{Bh{{f{B`}}}}Ih}b}`{fc{}}{f{{Bh{c}}}{}}1{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}>```````{{fh}b}00````{f{{f{j}}}}0000{{{f{l}}}{{f{lj}}}}0000`{f{{f{c}}}{}}0000{{{f{l}}}{{f{lc}}}{}}0000{{{f{Ij}}}Ij}{{{f{Il}}}Il}{{{f{In}}}In}{{f{f{lc}}}b{}}00{fb}00`{{}Il}{{}In}{Ab{{f{c}}}{}}0000{Ab{{f{lc}}}{}}0000:::::{Abb}0000{{{f{Il}}{f{lAf}}}Ah}{{{f{In}}{f{lAf}}}Ah}{cc{}}0000{{{f{c}}}e{}{}}0000{{}Ab}0000{{{f{J`}}}b}`{{}c{}}0000{{{Aj{c}}}{{Aj{j}}}{}}0000{{{Al{c}}}{{Al{j}}}{}}0000{{{An{c}}}{{An{j}}}{}}0000{fAd}0000{{{f{c}}}Ad{}}0``{{{Al{{If{{Bh{B`}}}}}}}Ij}66{{{f{Ij}}Jb{f{lJd}}{f{Jf}}}b}``{{{f{Ij}}{f{Jh}}{f{Jj}}{f{Jl}}{f{lJn}}{f{lJf}}}{{G`{K`}}}}`{fc{}}00{f{{Bh{c}}}{}}000011111`{c{{Cd{e}}}{}{}}0000{{}{{Cd{c}}}{}}0000{fCf}0000`{f{{Bh{{f{c}}}}}{}}0000``>>>>>`{{{f{lI`}}{f{lB`}}}b}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{lB`}}{f{lI`}}}b}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}4{Abb}{{{Bn{BdBd}}}{{f{Kb}}}}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{{f{lI`}}{f{lB`}}}b}{{{f{lKd}}}b}{{}Kd}`{{{f{lKd}}{f{lI`}}{f{lB`}}}b}{{{f{lI`}}{f{Cl}}{f{lB`}}}b}{{{f{lKd}}{f{lB`}}{f{lI`}}{f{Cl}}}b}0`2{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}?{{{f{lI`}}{f{l{Kf{Bb}}}}}b}`{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}3{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{Al{c}}}{{Al{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{}Kh}`{{{f{lKh}}{f{lI`}}{f{B`}}{f{Cl}}}b}{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}<``{{{f{lKj}}{f{lI`}}}b}{{{f{lKj}}{f{I`}}}b}{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}3{Abb}{{{f{lKj}}{f{lI`}}{f{Cl}}}b}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}{{}Kj}{{{f{lI`}}{f{Cl}}}b}{{{f{lI`}}{f{lCl}}{Bh{{f{lB`}}}}{f{lHf}}}b}`{{{f{lKj}}{f{lI`}}{Bh{{f{lB`}}}}{f{lCl}}{f{lHf}}}b}`{f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}}=`{f{{f{j}}}}{{{f{l}}}{{f{lj}}}}{f{{f{c}}}{}}{{{f{l}}}{{f{lc}}}{}}{{{f{lKl}}{f{l{Bh{B`}}}}{f{lI`}}}b}{{{f{lKl}}}b}`{Ab{{f{c}}}{}}{Ab{{f{lc}}}{}}5{Abb}{cc{}}{{{f{c}}}e{}{}}{{}Ab}{{}c{}}{{{Aj{c}}}{{Aj{j}}}{}}{{{An{c}}}{{An{j}}}{}}{fAd}:{{}Kl}`{{{Bh{{f{B`}}}}}b}={f{{Bh{c}}}{}}{fc{}}{c{{Cd{e}}}{}{}}{{}{{Cd{c}}}{}}{fCf}{f{{Bh{{f{c}}}}}{}};","D":"Ld","p":[[1,"unit"],[8,"Result",1264],[1,"reference"],[5,"Private",1265],[10,"Any",1266],[0,"mut"],[5,"Ray",10],[5,"Hit",10],[1,"usize"],[1,"bool"],[5,"Formatter",1267],[8,"Result",1267],[5,"Box",1268],[5,"Arc",1269],[5,"Rc",1270],[5,"Scene",180],[1,"f32"],[1,"u32"],[5,"Raytracer",10],[6,"Option",1271],[1,"slice"],[8,"Vector3",1272],[1,"tuple"],[8,"RgbImage",1273],[8,"Vector2",1272],[6,"Result",1274],[5,"TypeId",1266],[5,"TextureHandle",1275],[5,"Mutex",1276],[5,"Render",116],[5,"Context",1277],[5,"RenderingThread",116],[5,"WithRelativePath",180],[5,"Path",1278],[10,"AsRef",1279],[10,"Sync",1280],[10,"Deserializer",1281],[10,"Serializer",1282],[5,"Camera",258],[5,"CameraDef",300],[5,"Light",332],[5,"LightDef",371],[5,"Material",400],[5,"IlluminationModel",400],[1,"i32"],[5,"Object",478],[5,"WithRelativePath",478],[5,"String",1283],[8,"Translation3",1284],[8,"UnitQuaternion",1285],[8,"Scale3",1286],[8,"Affine3",1287],[5,"Obj",1288],[5,"SimplePolygon",1288],[5,"Triangle",722],[5,"Vec",1289],[5,"ObjectDef",550],[5,"Settings",580],[5,"SettingsDef",622],[6,"Skybox",653],[6,"SkyboxDef",694],[5,"Aabb",1290],[8,"Point3",1291],[5,"Yaml",772],[5,"Yaml",803],[5,"Yaml",834],[6,"Tab",865],[5,"CreationContext",1292],[5,"App",865],[5,"Frame",1292],[5,"Preview",930],[5,"Ui",1293],[5,"Response",1294],[5,"PathBuf",1278],[5,"RwLock",1295],[5,"Rect",1296],[5,"WgpuPainter",971],[5,"ShaderUniforms",971],[5,"ShaderLight",971],[5,"RenderState",1297],[5,"PaintCallbackInfo",1298],[5,"RenderPass",1299],[8,"CallbackResources",1300],[5,"Device",1301],[5,"Queue",1302],[5,"ScreenDescriptor",1300],[5,"CommandEncoder",1303],[5,"CommandBuffer",1304],[1,"str"],[5,"Properties",1136],[5,"XYZ",1305],[5,"RenderResult",1173],[5,"StatusBar",1201],[5,"YamlMenu",1233],[8,"Color",180],[15,"Image",692],[5,"Resources",971],[5,"VertexCount",971]],"r":[[180,258],[182,332],[183,400],[184,478],[186,580],[187,653]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAI4ERgAAAAAAAgAxADcABQBAAAwATgAFAFUAAQBZACUAgQAIAIwAAgCQAAEAlAAIAJ8AAAChAAEApAAAAKcAJADNAAkA2QADAN8ANQAWAQEAGQEGACEBFgA5AQIAPQEhAGABAgBkARkAfwECAIMBDQCSASIAtwEFAL8BOQD7AQUAAwIXABwCFQAzAgEANgIiAFoCAQBdAh0AfAIBAH8CIQCiAgEApQIdAMQCAQDHAiYA7wIBAPMCDgAFAwsAEgMCABYDGAAwAwEAMwMaAE8DAQBSAw8AYwMUAHoDAwCAAzIAtAMEALoDVgAWBAsAJwRVAH4EAQCBBAUAiAQDAI0EEQCgBAEAowQaAL8EAQDCBAcAywQSAN8EAQDiBA4A"}]]')); if (typeof exports !== 'undefined') exports.searchIndex = searchIndex; else if (window.initSearch) window.initSearch(searchIndex); +//{"start":39,"fragment_lengths":[29348]} \ No newline at end of file diff --git a/settings.html b/settings.html index 40d1aef9..f18b4d08 100644 --- a/settings.html +++ b/settings.html @@ -1 +1 @@ -Settings

Rustdoc settings

Back
\ No newline at end of file +Settings

Rustdoc settings

Back
\ No newline at end of file diff --git a/src-files.js b/src-files.js index 3d2da43c..c9ad3e88 100644 --- a/src-files.js +++ b/src-files.js @@ -1,4 +1,3 @@ -var srcIndex = new Map(JSON.parse('[\ -["trayracer",["",[["raytracer",[],["mod.rs","render.rs"]],["scene",[],["camera.rs","light.rs","material.rs","mod.rs","object.rs","settings.rs","skybox.rs","triangle.rs","yaml.rs"]],["ui",[["preview",[],["gpu.rs","mod.rs"]]],["mod.rs","properties.rs","renderresult.rs","statusbar.rs","yamlmenu.rs"]]],["main.rs"]]]\ -]')); +var srcIndex = new Map(JSON.parse('[["trayracer",["",[["raytracer",[],["mod.rs","render.rs"]],["scene",[],["camera.rs","light.rs","material.rs","mod.rs","object.rs","settings.rs","skybox.rs","triangle.rs","yaml.rs"]],["ui",[["preview",[],["gpu.rs","mod.rs"]]],["mod.rs","properties.rs","renderresult.rs","statusbar.rs","yamlmenu.rs"]]],["main.rs"]]]]')); createSrcSidebar(); +//{"start":36,"fragment_lengths":[313]} \ No newline at end of file diff --git a/src/trayracer/main.rs.html b/src/trayracer/main.rs.html index 05150f5f..f699c631 100644 --- a/src/trayracer/main.rs.html +++ b/src/trayracer/main.rs.html @@ -1,4 +1,5 @@ -main.rs - source
1
+main.rs - source
trayracer/
main.rs
+1
 2
 3
 4
@@ -64,9 +65,7 @@
 64
 65
 66
-67
-68
-
extern crate rust_i18n;
+67
extern crate rust_i18n;
 
 use anyhow::Context;
 use eframe::Renderer;
@@ -120,7 +119,6 @@
             viewport,
             renderer: Renderer::Wgpu,
             depth_buffer: 32,
-            follow_system_theme: true,
             centered: true,
             ..Default::default()
         },
diff --git a/src/trayracer/raytracer/mod.rs.html b/src/trayracer/raytracer/mod.rs.html
index 68e21d48..f9e7d5c5 100644
--- a/src/trayracer/raytracer/mod.rs.html
+++ b/src/trayracer/raytracer/mod.rs.html
@@ -1,4 +1,5 @@
-mod.rs - source
1
+mod.rs - source
trayracer/raytracer/
mod.rs
+1
 2
 3
 4
@@ -254,8 +255,7 @@
 254
 255
 256
-257
-
use crate::scene::{Color, Material, Scene, Skybox};
+257
use crate::scene::{Color, Material, Scene, Skybox};
 use image::RgbImage;
 use nalgebra::{Point3, Vector2, Vector3};
 use ordered_float::OrderedFloat;
diff --git a/src/trayracer/raytracer/render.rs.html b/src/trayracer/raytracer/render.rs.html
index 1495fc6f..080b4a0e 100644
--- a/src/trayracer/raytracer/render.rs.html
+++ b/src/trayracer/raytracer/render.rs.html
@@ -1,4 +1,5 @@
-render.rs - source
1
+render.rs - source
trayracer/raytracer/
render.rs
+1
 2
 3
 4
@@ -184,8 +185,7 @@
 184
 185
 186
-187
-
use crate::{raytracer::Raytracer, scene::Scene};
+187
use crate::{raytracer::Raytracer, scene::Scene};
 use egui::{mutex::Mutex, Color32, ColorImage, ImageData, TextureHandle, TextureOptions};
 use image::RgbImage;
 use log::{debug, info};
diff --git a/src/trayracer/scene/camera.rs.html b/src/trayracer/scene/camera.rs.html
index 549101b9..b9e4e25f 100644
--- a/src/trayracer/scene/camera.rs.html
+++ b/src/trayracer/scene/camera.rs.html
@@ -1,4 +1,5 @@
-camera.rs - source
1
+camera.rs - source
trayracer/scene/
camera.rs
+1
 2
 3
 4
@@ -94,8 +95,7 @@
 94
 95
 96
-97
-
use crate::raytracer::Ray;
+97
use crate::raytracer::Ray;
 use nalgebra::{Point3, Rotation3, Vector3};
 
 #[derive(Debug, Clone, PartialEq)]
diff --git a/src/trayracer/scene/light.rs.html b/src/trayracer/scene/light.rs.html
index 38d1b700..071bf268 100644
--- a/src/trayracer/scene/light.rs.html
+++ b/src/trayracer/scene/light.rs.html
@@ -1,4 +1,5 @@
-light.rs - source
1
+light.rs - source
trayracer/scene/
light.rs
+1
 2
 3
 4
@@ -49,8 +50,7 @@
 49
 50
 51
-52
-
use super::Color;
+52
use super::Color;
 use nalgebra::Point3;
 
 #[derive(Debug, Copy, Clone, PartialEq, Default)]
diff --git a/src/trayracer/scene/material.rs.html b/src/trayracer/scene/material.rs.html
index c2b33549..4aa13958 100644
--- a/src/trayracer/scene/material.rs.html
+++ b/src/trayracer/scene/material.rs.html
@@ -1,4 +1,5 @@
-material.rs - source
1
+material.rs - source
trayracer/scene/
material.rs
+1
 2
 3
 4
@@ -51,8 +52,7 @@
 51
 52
 53
-54
-
use super::Color;
+54
use super::Color;
 use image::RgbImage;
 
 #[derive(Debug, Clone)]
diff --git a/src/trayracer/scene/mod.rs.html b/src/trayracer/scene/mod.rs.html
index 6eb16196..ddeedf48 100644
--- a/src/trayracer/scene/mod.rs.html
+++ b/src/trayracer/scene/mod.rs.html
@@ -1,4 +1,5 @@
-mod.rs - source
1
+mod.rs - source
trayracer/scene/
mod.rs
+1
 2
 3
 4
@@ -136,8 +137,7 @@
 136
 137
 138
-139
-
use std::path::PathBuf;
+139
use std::path::PathBuf;
 
 use anyhow::Context;
 use log::warn;
diff --git a/src/trayracer/scene/object.rs.html b/src/trayracer/scene/object.rs.html
index b7ad60a6..e2d4ff4f 100644
--- a/src/trayracer/scene/object.rs.html
+++ b/src/trayracer/scene/object.rs.html
@@ -1,4 +1,5 @@
-object.rs - source
1
+object.rs - source
trayracer/scene/
object.rs
+1
 2
 3
 4
@@ -366,8 +367,7 @@
 366
 367
 368
-369
-
use super::{
+369
use super::{
     material::{IlluminationModel, Material},
     triangle::Triangle,
     Color,
diff --git a/src/trayracer/scene/settings.rs.html b/src/trayracer/scene/settings.rs.html
index 08d44175..473b2d15 100644
--- a/src/trayracer/scene/settings.rs.html
+++ b/src/trayracer/scene/settings.rs.html
@@ -1,4 +1,5 @@
-settings.rs - source
1
+settings.rs - source
trayracer/scene/
settings.rs
+1
 2
 3
 4
@@ -74,8 +75,7 @@
 74
 75
 76
-77
-
use super::{Color, Skybox};
+77
use super::{Color, Skybox};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Settings {
diff --git a/src/trayracer/scene/skybox.rs.html b/src/trayracer/scene/skybox.rs.html
index aec479e2..d42cadf1 100644
--- a/src/trayracer/scene/skybox.rs.html
+++ b/src/trayracer/scene/skybox.rs.html
@@ -1,4 +1,5 @@
-skybox.rs - source
1
+skybox.rs - source
trayracer/scene/
skybox.rs
+1
 2
 3
 4
@@ -61,8 +62,7 @@
 61
 62
 63
-64
-
use super::Color;
+64
use super::Color;
 use image::RgbImage;
 use std::path::PathBuf;
 
diff --git a/src/trayracer/scene/triangle.rs.html b/src/trayracer/scene/triangle.rs.html
index 9d484690..ffe0ba28 100644
--- a/src/trayracer/scene/triangle.rs.html
+++ b/src/trayracer/scene/triangle.rs.html
@@ -1,4 +1,5 @@
-triangle.rs - source
1
+triangle.rs - source
trayracer/scene/
triangle.rs
+1
 2
 3
 4
@@ -99,8 +100,7 @@
 99
 100
 101
-102
-
use crate::raytracer::Ray;
+102
use crate::raytracer::Ray;
 use bvh::{aabb::Bounded, bounding_hierarchy::BHShape};
 use nalgebra::{Point3, Vector2, Vector3};
 
diff --git a/src/trayracer/scene/yaml.rs.html b/src/trayracer/scene/yaml.rs.html
index a122630c..0c2c189f 100644
--- a/src/trayracer/scene/yaml.rs.html
+++ b/src/trayracer/scene/yaml.rs.html
@@ -1,4 +1,5 @@
-yaml.rs - source
1
+yaml.rs - source
trayracer/scene/
yaml.rs
+1
 2
 3
 4
@@ -96,8 +97,7 @@
 96
 97
 98
-99
-
/// provide (de)serialization for Color (aka. Vector3<f32>) from r,g,b fields
+99
/// provide (de)serialization for Color (aka. Vector3<f32>) from r,g,b fields
 pub mod color {
     use serde::{Deserialize, Serialize};
 
diff --git a/src/trayracer/ui/mod.rs.html b/src/trayracer/ui/mod.rs.html
index b2b96f25..65dafe0f 100644
--- a/src/trayracer/ui/mod.rs.html
+++ b/src/trayracer/ui/mod.rs.html
@@ -1,4 +1,5 @@
-mod.rs - source
1
+mod.rs - source
trayracer/ui/
mod.rs
+1
 2
 3
 4
@@ -146,8 +147,7 @@
 146
 147
 148
-149
-
use self::preview::Preview;
+149
use self::preview::Preview;
 use self::renderresult::RenderResult;
 use self::statusbar::StatusBar;
 use self::yamlmenu::YamlMenu;
diff --git a/src/trayracer/ui/preview/gpu.rs.html b/src/trayracer/ui/preview/gpu.rs.html
index f28c237d..64d9dafa 100644
--- a/src/trayracer/ui/preview/gpu.rs.html
+++ b/src/trayracer/ui/preview/gpu.rs.html
@@ -1,4 +1,5 @@
-gpu.rs - source
1
+gpu.rs - source
trayracer/ui/preview/
gpu.rs
+1
 2
 3
 4
@@ -413,7 +414,7 @@
 413
 414
 415
-
use std::{borrow::Cow, sync::Arc};
+416
use std::{borrow::Cow, sync::Arc};
 
 use crate::scene::Scene;
 use eframe::wgpu::PipelineCompilationOptions;
@@ -620,7 +621,7 @@
     fn paint<'a>(
         &'a self,
         _info: egui::PaintCallbackInfo,
-        render_pass: &mut wgpu::RenderPass<'a>,
+        render_pass: &mut wgpu::RenderPass<'static>,
         callback_resources: &'a egui_wgpu::CallbackResources,
     ) {
         let resources = callback_resources
@@ -696,7 +697,7 @@
         layout: Some(&pipeline_layout),
         vertex: VertexState {
             module: &shader,
-            entry_point: "vs_main",
+            entry_point: Some("vs_main"),
             buffers: &[VertexBufferLayout {
                 // 3x f32 for position, 3x f32 for normal, 3x f32 for color, 1x u32 for transform index
                 array_stride: std::mem::size_of::<f32>() as u64 * (3 + 3 + 3 + 1),
@@ -732,7 +733,7 @@
         },
         fragment: Some(FragmentState {
             module: &shader,
-            entry_point: "fs_main",
+            entry_point: Some("fs_main"),
             targets: &[Some(ColorTargetState {
                 format: render_state.target_format,
                 blend: None,
@@ -758,6 +759,7 @@
         }),
         multisample: MultisampleState::default(),
         multiview: None,
+        cache: None,
     });
 
     let uniform_buffer = device.create_buffer(&BufferDescriptor {
diff --git a/src/trayracer/ui/preview/mod.rs.html b/src/trayracer/ui/preview/mod.rs.html
index 646e4770..bd7d18c7 100644
--- a/src/trayracer/ui/preview/mod.rs.html
+++ b/src/trayracer/ui/preview/mod.rs.html
@@ -1,4 +1,5 @@
-mod.rs - source
1
+mod.rs - source
trayracer/ui/preview/
mod.rs
+1
 2
 3
 4
@@ -295,8 +296,7 @@
 295
 296
 297
-298
-
use self::gpu::WgpuPainter;
+298
use self::gpu::WgpuPainter;
 use crate::scene::{Object, Scene, Skybox};
 use egui::{
     mutex::RwLock, pos2, Align, Align2, Color32, Context, CursorGrab, DroppedFile, Event, Frame,
@@ -349,7 +349,7 @@
     }
 
     pub fn show(&mut self, ui: &mut Ui, scene: &mut Option<Scene>) {
-        Self::show_hover_overlay(ui.ctx(), scene, ui.available_rect_before_wrap());
+        Self::show_hover_overlay(ui.ctx(), scene.as_ref(), ui.available_rect_before_wrap());
         ui.ctx().input(|i| {
             if !i.raw.dropped_files.is_empty() {
                 //self.dropped_files = i.raw.dropped_files.clone();
@@ -479,7 +479,7 @@
         }
     }
 
-    pub fn show_hover_overlay(ctx: &Context, scene: &Option<Scene>, rect: Rect) {
+    pub fn show_hover_overlay(ctx: &Context, scene: Option<&Scene>, rect: Rect) {
         //TODO: show only when hovering over preview
         if !ctx.input(|i| i.raw.hovered_files.is_empty()) {
             let painter =
diff --git a/src/trayracer/ui/properties.rs.html b/src/trayracer/ui/properties.rs.html
index d5e5cf51..04f5468e 100644
--- a/src/trayracer/ui/properties.rs.html
+++ b/src/trayracer/ui/properties.rs.html
@@ -1,4 +1,5 @@
-properties.rs - source
1
+properties.rs - source
trayracer/ui/
properties.rs
+1
 2
 3
 4
@@ -422,7 +423,11 @@
 422
 423
 424
-
use crate::{
+425
+426
+427
+428
+429
use crate::{
     raytracer::render::Render,
     scene::{Color, Light, Object, Skybox},
     Scene,
@@ -430,7 +435,7 @@
 use anyhow::Context;
 use egui::{
     color_picker, hex_color, include_image, Align, Button, CollapsingHeader, DragValue, FontFamily,
-    ImageButton, Layout, RichText, Slider, Ui,
+    ImageButton, Layout, RichText, Slider, SliderClamping, Ui,
 };
 use egui_file::FileDialog;
 use log::warn;
@@ -504,7 +509,7 @@
                     Slider::new(&mut scene.camera.fov, 0.0..=consts::PI)
                         .step_by(0.01)
                         .custom_formatter(|x, _| format!("{:.2}°", x.to_degrees()))
-                        .clamp_to_range(true),
+                        .clamping(SliderClamping::Edits),
                 );
             });
         });
@@ -533,7 +538,10 @@
         color_picker::color_edit_button_rgb(ui, scene.settings.ambient_color.as_mut());
 
         ui.label(format!("{}:", t!("ambient_intensity")));
-        ui.add(Slider::new(&mut scene.settings.ambient_intensity, 0.0..=1.0).clamp_to_range(true));
+        ui.add(
+            Slider::new(&mut scene.settings.ambient_intensity, 0.0..=1.0)
+                .clamping(SliderClamping::Edits),
+        );
     }
 
     fn render_options(ui: &mut Ui, render: &Render, scene: &mut Scene) {
@@ -542,7 +550,7 @@
             ui.add_enabled_ui(render.thread.is_none(), |ui| {
                 ui.vertical(|ui| {
                     let text = Self::format_render_size(scene.camera.resolution);
-                    egui::ComboBox::from_id_source(0)
+                    egui::ComboBox::from_id_salt(0)
                         .selected_text(text)
                         .show_ui(ui, |ui| {
                             ui.selectable_value(&mut scene.camera.resolution, (1280, 720), "HD");
@@ -564,7 +572,8 @@
                     if scene.settings.anti_aliasing {
                         ui.label("Samples per pixel:");
                         ui.add(
-                            Slider::new(&mut scene.settings.samples, 1..=128).clamp_to_range(true),
+                            Slider::new(&mut scene.settings.samples, 1..=128)
+                                .clamping(SliderClamping::Edits),
                         );
                     }
                 });
@@ -692,7 +701,8 @@
                             ui.label(format!("{}:", t!("intensity")));
 
                             ui.add(
-                                Slider::new(&mut light.intensity, 0.0..=100.0).clamp_to_range(true),
+                                Slider::new(&mut light.intensity, 0.0..=100.0)
+                                    .clamping(SliderClamping::Edits),
                             );
 
                             ui.label(format!("{}:", t!("color")));
diff --git a/src/trayracer/ui/renderresult.rs.html b/src/trayracer/ui/renderresult.rs.html
index d535c05e..89d59a7f 100644
--- a/src/trayracer/ui/renderresult.rs.html
+++ b/src/trayracer/ui/renderresult.rs.html
@@ -1,4 +1,5 @@
-renderresult.rs - source
1
+renderresult.rs - source
trayracer/ui/
renderresult.rs
+1
 2
 3
 4
@@ -90,8 +91,7 @@
 90
 91
 92
-93
-
use crate::{raytracer::render::Render, scene::Scene};
+93
use crate::{raytracer::render::Render, scene::Scene};
 use egui::{pos2, Color32, CursorIcon, Frame, Rect, Rounding, Sense, Stroke, Ui, Vec2};
 
 pub struct RenderResult {
diff --git a/src/trayracer/ui/statusbar.rs.html b/src/trayracer/ui/statusbar.rs.html
index d620e567..7544899e 100644
--- a/src/trayracer/ui/statusbar.rs.html
+++ b/src/trayracer/ui/statusbar.rs.html
@@ -1,4 +1,5 @@
-statusbar.rs - source
1
+statusbar.rs - source
trayracer/ui/
statusbar.rs
+1
 2
 3
 4
@@ -184,8 +185,7 @@
 184
 185
 186
-187
-
use std::sync::atomic::Ordering;
+187
use std::sync::atomic::Ordering;
 
 use egui::special_emojis::GITHUB;
 use egui::{
diff --git a/src/trayracer/ui/yamlmenu.rs.html b/src/trayracer/ui/yamlmenu.rs.html
index 7664610d..70a2568a 100644
--- a/src/trayracer/ui/yamlmenu.rs.html
+++ b/src/trayracer/ui/yamlmenu.rs.html
@@ -1,4 +1,5 @@
-yamlmenu.rs - source
1
+yamlmenu.rs - source
trayracer/ui/
yamlmenu.rs
+1
 2
 3
 4
@@ -199,8 +200,7 @@
 199
 200
 201
-202
-
use crate::scene::{Camera, Scene, Settings};
+202
use crate::scene::{Camera, Scene, Settings};
 use anyhow::Context;
 use egui::{hex_color, include_image, Align, ImageButton, Layout, RichText, Ui};
 use egui_file::FileDialog;
@@ -257,7 +257,7 @@
                             settings: Settings::default(),
                         });
 
-                        Self::save_scene(scene);
+                        Self::save_scene(scene.as_ref());
                     }
                     None => {
                         warn!("Create yaml dialog selected but returned no path");
@@ -347,7 +347,7 @@
                 )
                 .on_hover_text(t!("save_scene"))
                 .clicked()
-                .then(|| Self::save_scene(scene));
+                .then(|| Self::save_scene(scene.as_ref()));
             });
 
             // new button
@@ -384,7 +384,7 @@
         });
     }
 
-    fn save_scene(scene: &Option<Scene>) {
+    fn save_scene(scene: Option<&Scene>) {
         match scene {
             Some(scene) => {
                 serde_yml::to_string(scene)
diff --git a/static.files/main-f070b9041d14864c.js b/static.files/main-f070b9041d14864c.js
new file mode 100644
index 00000000..3d672cb6
--- /dev/null
+++ b/static.files/main-f070b9041d14864c.js
@@ -0,0 +1,11 @@
+"use strict";window.RUSTDOC_TOOLTIP_HOVER_MS=300;window.RUSTDOC_TOOLTIP_HOVER_EXIT_MS=450;function resourcePath(basename,extension){return getVar("root-path")+basename+getVar("resource-suffix")+extension}function hideMain(){addClass(document.getElementById(MAIN_ID),"hidden");const toggle=document.getElementById("toggle-all-docs");if(toggle){toggle.setAttribute("disabled","disabled")}}function showMain(){const main=document.getElementById(MAIN_ID);removeClass(main,"hidden");const mainHeading=main.querySelector(".main-heading");if(mainHeading&&searchState.rustdocToolbar){if(searchState.rustdocToolbar.parentElement){searchState.rustdocToolbar.parentElement.removeChild(searchState.rustdocToolbar)}mainHeading.appendChild(searchState.rustdocToolbar)}const toggle=document.getElementById("toggle-all-docs");if(toggle){toggle.removeAttribute("disabled")}}window.rootPath=getVar("root-path");window.currentCrate=getVar("current-crate");function setMobileTopbar(){const mobileTopbar=document.querySelector(".mobile-topbar");const locationTitle=document.querySelector(".sidebar h2.location");if(mobileTopbar){const mobileTitle=document.createElement("h2");mobileTitle.className="location";if(hasClass(document.querySelector(".rustdoc"),"crate")){mobileTitle.innerHTML=`Crate ${window.currentCrate}`}else if(locationTitle){mobileTitle.innerHTML=locationTitle.innerHTML}mobileTopbar.appendChild(mobileTitle)}}function getVirtualKey(ev){if("key"in ev&&typeof ev.key!=="undefined"){return ev.key}const c=ev.charCode||ev.keyCode;if(c===27){return"Escape"}return String.fromCharCode(c)}const MAIN_ID="main-content";const SETTINGS_BUTTON_ID="settings-menu";const ALTERNATIVE_DISPLAY_ID="alternative-display";const NOT_DISPLAYED_ID="not-displayed";const HELP_BUTTON_ID="help-button";function getSettingsButton(){return document.getElementById(SETTINGS_BUTTON_ID)}function getHelpButton(){return document.getElementById(HELP_BUTTON_ID)}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function insertAfter(newNode,referenceNode){referenceNode.parentNode.insertBefore(newNode,referenceNode.nextSibling)}function getOrCreateSection(id,classes){let el=document.getElementById(id);if(!el){el=document.createElement("section");el.id=id;el.className=classes;insertAfter(el,document.getElementById(MAIN_ID))}return el}function getAlternativeDisplayElem(){return getOrCreateSection(ALTERNATIVE_DISPLAY_ID,"content hidden")}function getNotDisplayedElem(){return getOrCreateSection(NOT_DISPLAYED_ID,"hidden")}function switchDisplayedElement(elemToDisplay){const el=getAlternativeDisplayElem();if(el.children.length>0){getNotDisplayedElem().appendChild(el.firstElementChild)}if(elemToDisplay===null){addClass(el,"hidden");showMain();return}el.appendChild(elemToDisplay);hideMain();removeClass(el,"hidden");const mainHeading=elemToDisplay.querySelector(".main-heading");if(mainHeading&&searchState.rustdocToolbar){if(searchState.rustdocToolbar.parentElement){searchState.rustdocToolbar.parentElement.removeChild(searchState.rustdocToolbar)}mainHeading.appendChild(searchState.rustdocToolbar)}}function browserSupportsHistoryApi(){return window.history&&typeof window.history.pushState==="function"}function preLoadCss(cssUrl){const link=document.createElement("link");link.href=cssUrl;link.rel="preload";link.as="style";document.getElementsByTagName("head")[0].appendChild(link)}(function(){const isHelpPage=window.location.pathname.endsWith("/help.html");function loadScript(url,errorCallback){const script=document.createElement("script");script.src=url;if(errorCallback!==undefined){script.onerror=errorCallback}document.head.append(script)}if(getSettingsButton()){getSettingsButton().onclick=event=>{if(event.ctrlKey||event.altKey||event.metaKey){return}window.hideAllModals(false);addClass(getSettingsButton(),"rotate");event.preventDefault();loadScript(getVar("static-root-path")+getVar("settings-js"));setTimeout(()=>{const themes=getVar("themes").split(",");for(const theme of themes){if(theme!==""){preLoadCss(getVar("root-path")+theme+".css")}}},0)}}window.searchState={rustdocToolbar:document.querySelector("rustdoc-toolbar"),loadingText:"Loading search results...",input:document.getElementsByClassName("search-input")[0],outputElement:()=>{let el=document.getElementById("search");if(!el){el=document.createElement("section");el.id="search";getNotDisplayedElem().appendChild(el)}return el},title:document.title,titleBeforeSearch:document.title,timeout:null,currentTab:0,focusedByTab:[null,null,null],clearInputTimeout:()=>{if(searchState.timeout!==null){clearTimeout(searchState.timeout);searchState.timeout=null}},isDisplayed:()=>searchState.outputElement().parentElement.id===ALTERNATIVE_DISPLAY_ID,focus:()=>{searchState.input.focus()},defocus:()=>{searchState.input.blur()},showResults:search=>{if(search===null||typeof search==="undefined"){search=searchState.outputElement()}switchDisplayedElement(search);searchState.mouseMovedAfterSearch=false;document.title=searchState.title},removeQueryParameters:()=>{document.title=searchState.titleBeforeSearch;if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.hash)}},hideResults:()=>{switchDisplayedElement(null);searchState.removeQueryParameters()},getQueryStringParams:()=>{const params={};window.location.search.substring(1).split("&").map(s=>{const pair=s.split("=").map(x=>x.replace(/\+/g," "));params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params},setup:()=>{const search_input=searchState.input;if(!searchState.input){return}let searchLoaded=false;function sendSearchForm(){document.getElementsByClassName("search-form")[0].submit()}function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(getVar("static-root-path")+getVar("search-js"),sendSearchForm);loadScript(resourcePath("search-index",".js"),sendSearchForm)}}search_input.addEventListener("focus",()=>{search_input.origPlaceholder=search_input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});if(search_input.value!==""){loadSearch()}const params=searchState.getQueryStringParams();if(params.search!==undefined){searchState.setLoadingSearch();loadSearch()}},setLoadingSearch:()=>{const search=searchState.outputElement();search.innerHTML="
"+searchState.loadingText+"
";searchState.showResults(search)},descShards:new Map(),loadDesc:async function({descShard,descIndex}){if(descShard.promise===null){descShard.promise=new Promise((resolve,reject)=>{descShard.resolve=resolve;const ds=descShard;const fname=`${ds.crate}-desc-${ds.shard}-`;const url=resourcePath(`search.desc/${descShard.crate}/${fname}`,".js",);loadScript(url,reject)})}const list=await descShard.promise;return list[descIndex]},loadedDescShard:function(crate,shard,data){this.descShards.get(crate)[shard].resolve(data.split("\n"))},};const toggleAllDocsId="toggle-all-docs";let savedHash="";function handleHashes(ev){if(ev!==null&&searchState.isDisplayed()&&ev.newURL){switchDisplayedElement(null);const hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(browserSupportsHistoryApi()){history.replaceState(null,"",getNakedUrl()+window.location.search+"#"+hash)}const elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}const pageId=window.location.hash.replace(/^#/,"");if(savedHash!==pageId){savedHash=pageId;if(pageId!==""){expandSection(pageId)}}if(savedHash.startsWith("impl-")){const splitAt=savedHash.indexOf("/");if(splitAt!==-1){const implId=savedHash.slice(0,splitAt);const assocId=savedHash.slice(splitAt+1);const implElems=document.querySelectorAll(`details > summary > section[id^="${implId}"]`,);onEachLazy(implElems,implElem=>{const numbered=/^(.+?)-([0-9]+)$/.exec(implElem.id);if(implElem.id!==implId&&(!numbered||numbered[1]!==implId)){return false}return onEachLazy(implElem.parentElement.parentElement.querySelectorAll(`[id^="${assocId}"]`),item=>{const numbered=/^(.+?)-([0-9]+)$/.exec(item.id);if(item.id===assocId||(numbered&&numbered[1]===assocId)){openParentDetails(item);item.scrollIntoView();setTimeout(()=>{window.location.replace("#"+item.id)},0);return true}},)})}}}function onHashChange(ev){hideSidebar();handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function handleEscape(ev){searchState.clearInputTimeout();searchState.hideResults();ev.preventDefault();searchState.defocus();window.hideAllModals(true)}function handleShortcut(ev){const disableShortcuts=getSettingValue("disable-shortcuts")==="true";if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"&&document.activeElement.type!=="checkbox"&&document.activeElement.type!=="radio"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":case"/":ev.preventDefault();searchState.focus();break;case"+":ev.preventDefault();expandAllDocs();break;case"-":ev.preventDefault();collapseAllDocs();break;case"?":showHelp();break;default:break}}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);function addSidebarItems(){if(!window.SIDEBAR_ITEMS){return}const sidebar=document.getElementById("rustdoc-modnav");function block(shortty,id,longty){const filtered=window.SIDEBAR_ITEMS[shortty];if(!filtered){return}const modpath=hasClass(document.querySelector(".rustdoc"),"mod")?"../":"";const h3=document.createElement("h3");h3.innerHTML=`${longty}`;const ul=document.createElement("ul");ul.className="block "+shortty;for(const name of filtered){let path;if(shortty==="mod"){path=`${modpath}${name}/index.html`}else{path=`${modpath}${shortty}.${name}.html`}let current_page=document.location.href.toString();if(current_page.endsWith("/")){current_page+="index.html"}const link=document.createElement("a");link.href=path;link.textContent=name;const li=document.createElement("li");if(link.href===current_page){li.classList.add("current")}li.appendChild(link);ul.appendChild(li)}sidebar.appendChild(h3);sidebar.appendChild(ul)}if(sidebar){block("primitive","primitives","Primitive Types");block("mod","modules","Modules");block("macro","macros","Macros");block("struct","structs","Structs");block("enum","enums","Enums");block("constant","constants","Constants");block("static","static","Statics");block("trait","traits","Traits");block("fn","functions","Functions");block("type","types","Type Aliases");block("union","unions","Unions");block("foreigntype","foreign-types","Foreign Types");block("keyword","keywords","Keywords");block("attr","attributes","Attribute Macros");block("derive","derives","Derive Macros");block("traitalias","trait-aliases","Trait Aliases")}}window.register_implementors=imp=>{const implementors=document.getElementById("implementors-list");const synthetic_implementors=document.getElementById("synthetic-implementors-list");const inlined_types=new Set();const TEXT_IDX=0;const SYNTHETIC_IDX=1;const TYPES_IDX=2;if(synthetic_implementors){onEachLazy(synthetic_implementors.getElementsByClassName("impl"),el=>{const aliases=el.getAttribute("data-aliases");if(!aliases){return}aliases.split(",").forEach(alias=>{inlined_types.add(alias)})})}let currentNbImpls=implementors.getElementsByClassName("impl").length;const traitName=document.querySelector(".main-heading h1 > .trait").textContent;const baseIdName="impl-"+traitName+"-";const libs=Object.getOwnPropertyNames(imp);const script=document.querySelector("script[data-ignore-extern-crates]");const ignoreExternCrates=new Set((script?script.getAttribute("data-ignore-extern-crates"):"").split(","),);for(const lib of libs){if(lib===window.currentCrate||ignoreExternCrates.has(lib)){continue}const structs=imp[lib];struct_loop:for(const struct of structs){const list=struct[SYNTHETIC_IDX]?synthetic_implementors:implementors;if(struct[SYNTHETIC_IDX]){for(const struct_type of struct[TYPES_IDX]){if(inlined_types.has(struct_type)){continue struct_loop}inlined_types.add(struct_type)}}const code=document.createElement("h3");code.innerHTML=struct[TEXT_IDX];addClass(code,"code-header");onEachLazy(code.getElementsByTagName("a"),elem=>{const href=elem.getAttribute("href");if(href&&!href.startsWith("#")&&!/^(?:[a-z+]+:)?\/\//.test(href)){elem.setAttribute("href",window.rootPath+href)}});const currentId=baseIdName+currentNbImpls;const anchor=document.createElement("a");anchor.href="#"+currentId;addClass(anchor,"anchor");const display=document.createElement("div");display.id=currentId;addClass(display,"impl");display.appendChild(anchor);display.appendChild(code);list.appendChild(display);currentNbImpls+=1}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}window.register_type_impls=imp=>{if(!imp||!imp[window.currentCrate]){return}window.pending_type_impls=null;const idMap=new Map();let implementations=document.getElementById("implementations-list");let trait_implementations=document.getElementById("trait-implementations-list");let trait_implementations_header=document.getElementById("trait-implementations");const script=document.querySelector("script[data-self-path]");const selfPath=script?script.getAttribute("data-self-path"):null;const mainContent=document.querySelector("#main-content");const sidebarSection=document.querySelector(".sidebar section");let methods=document.querySelector(".sidebar .block.method");let associatedTypes=document.querySelector(".sidebar .block.associatedtype");let associatedConstants=document.querySelector(".sidebar .block.associatedconstant");let sidebarTraitList=document.querySelector(".sidebar .block.trait-implementation");for(const impList of imp[window.currentCrate]){const types=impList.slice(2);const text=impList[0];const isTrait=impList[1]!==0;const traitName=impList[1];if(types.indexOf(selfPath)===-1){continue}let outputList=isTrait?trait_implementations:implementations;if(outputList===null){const outputListName=isTrait?"Trait Implementations":"Implementations";const outputListId=isTrait?"trait-implementations-list":"implementations-list";const outputListHeaderId=isTrait?"trait-implementations":"implementations";const outputListHeader=document.createElement("h2");outputListHeader.id=outputListHeaderId;outputListHeader.innerText=outputListName;outputList=document.createElement("div");outputList.id=outputListId;if(isTrait){const link=document.createElement("a");link.href=`#${outputListHeaderId}`;link.innerText="Trait Implementations";const h=document.createElement("h3");h.appendChild(link);trait_implementations=outputList;trait_implementations_header=outputListHeader;sidebarSection.appendChild(h);sidebarTraitList=document.createElement("ul");sidebarTraitList.className="block trait-implementation";sidebarSection.appendChild(sidebarTraitList);mainContent.appendChild(outputListHeader);mainContent.appendChild(outputList)}else{implementations=outputList;if(trait_implementations){mainContent.insertBefore(outputListHeader,trait_implementations_header);mainContent.insertBefore(outputList,trait_implementations_header)}else{const mainContent=document.querySelector("#main-content");mainContent.appendChild(outputListHeader);mainContent.appendChild(outputList)}}}const template=document.createElement("template");template.innerHTML=text;onEachLazy(template.content.querySelectorAll("a"),elem=>{const href=elem.getAttribute("href");if(href&&!href.startsWith("#")&&!/^(?:[a-z+]+:)?\/\//.test(href)){elem.setAttribute("href",window.rootPath+href)}});onEachLazy(template.content.querySelectorAll("[id]"),el=>{let i=0;if(idMap.has(el.id)){i=idMap.get(el.id)}else if(document.getElementById(el.id)){i=1;while(document.getElementById(`${el.id}-${2 * i}`)){i=2*i}while(document.getElementById(`${el.id}-${i}`)){i+=1}}if(i!==0){const oldHref=`#${el.id}`;const newHref=`#${el.id}-${i}`;el.id=`${el.id}-${i}`;onEachLazy(template.content.querySelectorAll("a[href]"),link=>{if(link.getAttribute("href")===oldHref){link.href=newHref}})}idMap.set(el.id,i+1)});const templateAssocItems=template.content.querySelectorAll("section.tymethod, "+"section.method, section.associatedtype, section.associatedconstant");if(isTrait){const li=document.createElement("li");const a=document.createElement("a");a.href=`#${template.content.querySelector(".impl").id}`;a.textContent=traitName;li.appendChild(a);sidebarTraitList.append(li)}else{onEachLazy(templateAssocItems,item=>{let block=hasClass(item,"associatedtype")?associatedTypes:(hasClass(item,"associatedconstant")?associatedConstants:(methods));if(!block){const blockTitle=hasClass(item,"associatedtype")?"Associated Types":(hasClass(item,"associatedconstant")?"Associated Constants":("Methods"));const blockClass=hasClass(item,"associatedtype")?"associatedtype":(hasClass(item,"associatedconstant")?"associatedconstant":("method"));const blockHeader=document.createElement("h3");const blockLink=document.createElement("a");blockLink.href="#implementations";blockLink.innerText=blockTitle;blockHeader.appendChild(blockLink);block=document.createElement("ul");block.className=`block ${blockClass}`;const insertionReference=methods||sidebarTraitList;if(insertionReference){const insertionReferenceH=insertionReference.previousElementSibling;sidebarSection.insertBefore(blockHeader,insertionReferenceH);sidebarSection.insertBefore(block,insertionReferenceH)}else{sidebarSection.appendChild(blockHeader);sidebarSection.appendChild(block)}if(hasClass(item,"associatedtype")){associatedTypes=block}else if(hasClass(item,"associatedconstant")){associatedConstants=block}else{methods=block}}const li=document.createElement("li");const a=document.createElement("a");a.innerText=item.id.split("-")[0].split(".")[1];a.href=`#${item.id}`;li.appendChild(a);block.appendChild(li)})}outputList.appendChild(template.content)}for(const list of[methods,associatedTypes,associatedConstants,sidebarTraitList]){if(!list){continue}const newChildren=Array.prototype.slice.call(list.children);newChildren.sort((a,b)=>{const aI=a.innerText;const bI=b.innerText;return aIbI?1:0});list.replaceChildren(...newChildren)}};if(window.pending_type_impls){window.register_type_impls(window.pending_type_impls)}function addSidebarCrates(){if(!window.ALL_CRATES){return}const sidebarElems=document.getElementById("rustdoc-modnav");if(!sidebarElems){return}const h3=document.createElement("h3");h3.innerHTML="Crates";const ul=document.createElement("ul");ul.className="block crate";for(const crate of window.ALL_CRATES){const link=document.createElement("a");link.href=window.rootPath+crate+"/index.html";link.textContent=crate;const li=document.createElement("li");if(window.rootPath!=="./"&&crate===window.currentCrate){li.className="current"}li.appendChild(link);ul.appendChild(li)}sidebarElems.appendChild(h3);sidebarElems.appendChild(ul)}function expandAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);removeClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("toggle"),e=>{if(!hasClass(e,"type-contents-toggle")&&!hasClass(e,"more-examples-toggle")){e.open=true}});innerToggle.children[0].innerText="Summary"}function collapseAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);addClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("toggle"),e=>{if(e.parentNode.id!=="implementations-list"||(!hasClass(e,"implementors-toggle")&&!hasClass(e,"type-contents-toggle"))){e.open=false}});innerToggle.children[0].innerText="Show all"}function toggleAllDocs(){const innerToggle=document.getElementById(toggleAllDocsId);if(!innerToggle){return}if(hasClass(innerToggle,"will-expand")){expandAllDocs()}else{collapseAllDocs()}}(function(){const toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}const hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";const hideImplementations=getSettingValue("auto-hide-trait-implementations")==="true";const hideLargeItemContents=getSettingValue("auto-hide-large-items")!=="false";function setImplementorsTogglesOpen(id,open){const list=document.getElementById(id);if(list!==null){onEachLazy(list.getElementsByClassName("implementors-toggle"),e=>{e.open=open})}}if(hideImplementations){setImplementorsTogglesOpen("trait-implementations-list",false);setImplementorsTogglesOpen("blanket-implementations-list",false)}onEachLazy(document.getElementsByClassName("toggle"),e=>{if(!hideLargeItemContents&&hasClass(e,"type-contents-toggle")){e.open=true}if(hideMethodDocs&&hasClass(e,"method-toggle")){e.open=false}})}());window.rustdoc_add_line_numbers_to_examples=()=>{if(document.querySelector(".rustdoc.src")){return}onEachLazy(document.querySelectorAll(":not(.scraped-example) > .example-wrap > pre:not(.example-line-numbers)",),x=>{const parent=x.parentNode;const line_numbers=parent.querySelectorAll(".example-line-numbers");if(line_numbers.length>0){return}const count=x.textContent.split("\n").length;const elems=[];for(let i=0;i{onEachLazy(document.querySelectorAll(".example-wrap > .example-line-numbers"),x=>{x.parentNode.removeChild(x)})};if(getSettingValue("line-numbers")==="true"){window.rustdoc_add_line_numbers_to_examples()}function showSidebar(){window.hideAllModals(false);const sidebar=document.getElementsByClassName("sidebar")[0];addClass(sidebar,"shown")}function hideSidebar(){const sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"shown")}window.addEventListener("resize",()=>{if(window.CURRENT_TOOLTIP_ELEMENT){const base=window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE;const force_visible=base.TOOLTIP_FORCE_VISIBLE;hideTooltip(false);if(force_visible){showTooltip(base);base.TOOLTIP_FORCE_VISIBLE=true}}});const mainElem=document.getElementById(MAIN_ID);if(mainElem){mainElem.addEventListener("click",hideSidebar)}onEachLazy(document.querySelectorAll("a[href^='#']"),el=>{el.addEventListener("click",()=>{expandSection(el.hash.slice(1));hideSidebar()})});onEachLazy(document.querySelectorAll(".toggle > summary:not(.hideme)"),el=>{el.addEventListener("click",e=>{if(e.target.tagName!=="SUMMARY"&&e.target.tagName!=="A"){e.preventDefault()}})});function showTooltip(e){const notable_ty=e.getAttribute("data-notable-ty");if(!window.NOTABLE_TRAITS&¬able_ty){const data=document.getElementById("notable-traits-data");if(data){window.NOTABLE_TRAITS=JSON.parse(data.innerText)}else{throw new Error("showTooltip() called with notable without any notable traits!")}}if(window.CURRENT_TOOLTIP_ELEMENT&&window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE===e){clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);return}window.hideAllModals(false);const wrapper=document.createElement("div");if(notable_ty){wrapper.innerHTML="
"+window.NOTABLE_TRAITS[notable_ty]+"
"}else{if(e.getAttribute("title")!==null){e.setAttribute("data-title",e.getAttribute("title"));e.removeAttribute("title")}if(e.getAttribute("data-title")!==null){const titleContent=document.createElement("div");titleContent.className="content";titleContent.appendChild(document.createTextNode(e.getAttribute("data-title")));wrapper.appendChild(titleContent)}}wrapper.className="tooltip popover";const focusCatcher=document.createElement("div");focusCatcher.setAttribute("tabindex","0");focusCatcher.onfocus=hideTooltip;wrapper.appendChild(focusCatcher);const pos=e.getBoundingClientRect();wrapper.style.top=(pos.top+window.scrollY+pos.height)+"px";wrapper.style.left=0;wrapper.style.right="auto";wrapper.style.visibility="hidden";document.body.appendChild(wrapper);const wrapperPos=wrapper.getBoundingClientRect();const finalPos=pos.left+window.scrollX-wrapperPos.width+24;if(finalPos>0){wrapper.style.left=finalPos+"px"}else{wrapper.style.setProperty("--popover-arrow-offset",(wrapperPos.right-pos.right+4)+"px",)}wrapper.style.visibility="";window.CURRENT_TOOLTIP_ELEMENT=wrapper;window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE=e;clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);wrapper.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}clearTooltipHoverTimeout(e)};wrapper.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&!e.contains(ev.relatedTarget)){setTooltipHoverTimeout(e,false);addClass(wrapper,"fade-out")}}}function setTooltipHoverTimeout(element,show){clearTooltipHoverTimeout(element);if(!show&&!window.CURRENT_TOOLTIP_ELEMENT){return}if(show&&window.CURRENT_TOOLTIP_ELEMENT){return}if(window.CURRENT_TOOLTIP_ELEMENT&&window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE!==element){return}element.TOOLTIP_HOVER_TIMEOUT=setTimeout(()=>{if(show){showTooltip(element)}else if(!element.TOOLTIP_FORCE_VISIBLE){hideTooltip(false)}},show?window.RUSTDOC_TOOLTIP_HOVER_MS:window.RUSTDOC_TOOLTIP_HOVER_EXIT_MS)}function clearTooltipHoverTimeout(element){if(element.TOOLTIP_HOVER_TIMEOUT!==undefined){removeClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out");clearTimeout(element.TOOLTIP_HOVER_TIMEOUT);delete element.TOOLTIP_HOVER_TIMEOUT}}function tooltipBlurHandler(event){if(window.CURRENT_TOOLTIP_ELEMENT&&!window.CURRENT_TOOLTIP_ELEMENT.contains(document.activeElement)&&!window.CURRENT_TOOLTIP_ELEMENT.contains(event.relatedTarget)&&!window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.contains(document.activeElement)&&!window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.contains(event.relatedTarget)){setTimeout(()=>hideTooltip(false),0)}}function hideTooltip(focus){if(window.CURRENT_TOOLTIP_ELEMENT){if(window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE){if(focus){window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.focus()}window.CURRENT_TOOLTIP_ELEMENT.TOOLTIP_BASE.TOOLTIP_FORCE_VISIBLE=false}document.body.removeChild(window.CURRENT_TOOLTIP_ELEMENT);clearTooltipHoverTimeout(window.CURRENT_TOOLTIP_ELEMENT);window.CURRENT_TOOLTIP_ELEMENT=null}}onEachLazy(document.getElementsByClassName("tooltip"),e=>{e.onclick=()=>{e.TOOLTIP_FORCE_VISIBLE=e.TOOLTIP_FORCE_VISIBLE?false:true;if(window.CURRENT_TOOLTIP_ELEMENT&&!e.TOOLTIP_FORCE_VISIBLE){hideTooltip(true)}else{showTooltip(e);window.CURRENT_TOOLTIP_ELEMENT.setAttribute("tabindex","0");window.CURRENT_TOOLTIP_ELEMENT.focus();window.CURRENT_TOOLTIP_ELEMENT.onblur=tooltipBlurHandler}return false};e.onpointerenter=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointermove=ev=>{if(ev.pointerType!=="mouse"){return}setTooltipHoverTimeout(e,true)};e.onpointerleave=ev=>{if(ev.pointerType!=="mouse"){return}if(!e.TOOLTIP_FORCE_VISIBLE&&window.CURRENT_TOOLTIP_ELEMENT&&!window.CURRENT_TOOLTIP_ELEMENT.contains(ev.relatedTarget)){setTooltipHoverTimeout(e,false);addClass(window.CURRENT_TOOLTIP_ELEMENT,"fade-out")}}});const sidebar_menu_toggle=document.getElementsByClassName("sidebar-menu-toggle")[0];if(sidebar_menu_toggle){sidebar_menu_toggle.addEventListener("click",()=>{const sidebar=document.getElementsByClassName("sidebar")[0];if(!hasClass(sidebar,"shown")){showSidebar()}else{hideSidebar()}})}function helpBlurHandler(event){if(!getHelpButton().contains(document.activeElement)&&!getHelpButton().contains(event.relatedTarget)&&!getSettingsButton().contains(document.activeElement)&&!getSettingsButton().contains(event.relatedTarget)){window.hidePopoverMenus()}}function buildHelpMenu(){const book_info=document.createElement("span");const channel=getVar("channel");book_info.className="top";book_info.innerHTML=`You can find more information in \
+the rustdoc book.`;const shortcuts=[["?","Show this help dialog"],["S / /","Focus the search field"],["↑","Move up in search results"],["↓","Move down in search results"],["← / →","Switch result tab (when results focused)"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(x=>"
"+x[0].split(" ").map((y,index)=>((index&1)===0?""+y+"":" "+y+" ")).join("")+"
"+x[1]+"
").join("");const div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="
Keyboard Shortcuts
"+shortcuts+"
";const infos=[`For a full list of all search features, take a look here.`,"Prefix searches with a type followed by a colon (e.g., fn:) to \
+             restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
+             enum, trait, type, macro, \
+             and const.","Search functions by type signature (e.g., vec -> usize or \
+             -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \
+             your request: \"string\"","Look for functions that accept or return \
+              slices and \
+              arrays by writing \
+              square brackets (e.g., -> [u8] or [] -> Option)","Look for items inside another one by searching for a path: vec::Vec",].map(x=>"
"+x+"
").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="
Search Tricks
"+infos;const rustdoc_version=document.createElement("span");rustdoc_version.className="bottom";const rustdoc_version_code=document.createElement("code");rustdoc_version_code.innerText="rustdoc "+getVar("rustdoc-version");rustdoc_version.appendChild(rustdoc_version_code);const container=document.createElement("div");if(!isHelpPage){container.className="popover"}container.id="help";container.style.display="none";const side_by_side=document.createElement("div");side_by_side.className="side-by-side";side_by_side.appendChild(div_shortcuts);side_by_side.appendChild(div_infos);container.appendChild(book_info);container.appendChild(side_by_side);container.appendChild(rustdoc_version);if(isHelpPage){const help_section=document.createElement("section");help_section.appendChild(container);document.getElementById("main-content").appendChild(help_section);container.style.display="block"}else{const help_button=getHelpButton();help_button.appendChild(container);container.onblur=helpBlurHandler;help_button.onblur=helpBlurHandler;help_button.children[0].onblur=helpBlurHandler}return container}window.hideAllModals=switchFocus=>{hideSidebar();window.hidePopoverMenus();hideTooltip(switchFocus)};window.hidePopoverMenus=()=>{onEachLazy(document.querySelectorAll("rustdoc-toolbar .popover"),elem=>{elem.style.display="none"});const button=getHelpButton();if(button){removeClass(button,"help-open")}};function getHelpMenu(buildNeeded){let menu=getHelpButton().querySelector(".popover");if(!menu&&buildNeeded){menu=buildHelpMenu()}return menu}function showHelp(){const button=getHelpButton();addClass(button,"help-open");button.querySelector("a").focus();const menu=getHelpMenu(true);if(menu.style.display==="none"){window.hideAllModals();menu.style.display=""}}const helpLink=document.querySelector(`#${HELP_BUTTON_ID} > a`);if(isHelpPage){buildHelpMenu()}else if(helpLink){helpLink.addEventListener("click",event=>{if(!helpLink.contains(helpLink)||event.ctrlKey||event.altKey||event.metaKey){return}event.preventDefault();const menu=getHelpMenu(true);const shouldShowHelp=menu.style.display==="none";if(shouldShowHelp){showHelp()}else{window.hidePopoverMenus()}})}setMobileTopbar();addSidebarItems();addSidebarCrates();onHashChange(null);window.addEventListener("hashchange",onHashChange);searchState.setup()}());(function(){const SIDEBAR_MIN=100;const SIDEBAR_MAX=500;const RUSTDOC_MOBILE_BREAKPOINT=700;const BODY_MIN=400;const SIDEBAR_VANISH_THRESHOLD=SIDEBAR_MIN/2;const sidebarButton=document.getElementById("sidebar-button");if(sidebarButton){sidebarButton.addEventListener("click",e=>{removeClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","false");if(document.querySelector(".rustdoc.src")){window.rustdocToggleSrcSidebar()}e.preventDefault()})}let currentPointerId=null;let desiredSidebarSize=null;let pendingSidebarResizingFrame=false;const resizer=document.querySelector(".sidebar-resizer");const sidebar=document.querySelector(".sidebar");if(!resizer||!sidebar){return}const isSrcPage=hasClass(document.body,"src");function hideSidebar(){if(isSrcPage){window.rustdocCloseSourceSidebar();updateLocalStorage("src-sidebar-width",null);document.documentElement.style.removeProperty("--src-sidebar-width");sidebar.style.removeProperty("--src-sidebar-width");resizer.style.removeProperty("--src-sidebar-width")}else{addClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","true");updateLocalStorage("desktop-sidebar-width",null);document.documentElement.style.removeProperty("--desktop-sidebar-width");sidebar.style.removeProperty("--desktop-sidebar-width");resizer.style.removeProperty("--desktop-sidebar-width")}}function showSidebar(){if(isSrcPage){window.rustdocShowSourceSidebar()}else{removeClass(document.documentElement,"hide-sidebar");updateLocalStorage("hide-sidebar","false")}}function changeSidebarSize(size){if(isSrcPage){updateLocalStorage("src-sidebar-width",size);sidebar.style.setProperty("--src-sidebar-width",size+"px");resizer.style.setProperty("--src-sidebar-width",size+"px")}else{updateLocalStorage("desktop-sidebar-width",size);sidebar.style.setProperty("--desktop-sidebar-width",size+"px");resizer.style.setProperty("--desktop-sidebar-width",size+"px")}}function isSidebarHidden(){return isSrcPage?!hasClass(document.documentElement,"src-sidebar-expanded"):hasClass(document.documentElement,"hide-sidebar")}function resize(e){if(currentPointerId===null||currentPointerId!==e.pointerId){return}e.preventDefault();const pos=e.clientX-3;if(pos=SIDEBAR_MIN){if(isSidebarHidden()){showSidebar()}const constrainedPos=Math.min(pos,window.innerWidth-BODY_MIN,SIDEBAR_MAX);changeSidebarSize(constrainedPos);desiredSidebarSize=constrainedPos;if(pendingSidebarResizingFrame!==false){clearTimeout(pendingSidebarResizingFrame)}pendingSidebarResizingFrame=setTimeout(()=>{if(currentPointerId===null||pendingSidebarResizingFrame===false){return}pendingSidebarResizingFrame=false;document.documentElement.style.setProperty("--resizing-sidebar-width",desiredSidebarSize+"px",)},100)}}window.addEventListener("resize",()=>{if(window.innerWidth=(window.innerWidth-BODY_MIN)){changeSidebarSize(window.innerWidth-BODY_MIN)}else if(desiredSidebarSize!==null&&desiredSidebarSize>SIDEBAR_MIN){changeSidebarSize(desiredSidebarSize)}});function stopResize(e){if(currentPointerId===null){return}if(e){e.preventDefault()}desiredSidebarSize=sidebar.getBoundingClientRect().width;removeClass(resizer,"active");window.removeEventListener("pointermove",resize,false);window.removeEventListener("pointerup",stopResize,false);removeClass(document.documentElement,"sidebar-resizing");document.documentElement.style.removeProperty("--resizing-sidebar-width");if(resizer.releasePointerCapture){resizer.releasePointerCapture(currentPointerId);currentPointerId=null}}function initResize(e){if(currentPointerId!==null||e.altKey||e.ctrlKey||e.metaKey||e.button!==0){return}if(resizer.setPointerCapture){resizer.setPointerCapture(e.pointerId);if(!resizer.hasPointerCapture(e.pointerId)){resizer.releasePointerCapture(e.pointerId);return}currentPointerId=e.pointerId}window.hideAllModals(false);e.preventDefault();window.addEventListener("pointermove",resize,false);window.addEventListener("pointercancel",stopResize,false);window.addEventListener("pointerup",stopResize,false);addClass(resizer,"active");addClass(document.documentElement,"sidebar-resizing");const pos=e.clientX-sidebar.offsetLeft-3;document.documentElement.style.setProperty("--resizing-sidebar-width",pos+"px");desiredSidebarSize=null}resizer.addEventListener("pointerdown",initResize,false)}());(function(){function copyContentToClipboard(content){const el=document.createElement("textarea");el.value=content;el.setAttribute("readonly","");el.style.position="absolute";el.style.left="-9999px";document.body.appendChild(el);el.select();document.execCommand("copy");document.body.removeChild(el)}function copyButtonAnimation(button){button.classList.add("clicked");if(button.reset_button_timeout!==undefined){window.clearTimeout(button.reset_button_timeout)}button.reset_button_timeout=window.setTimeout(()=>{button.reset_button_timeout=undefined;button.classList.remove("clicked")},1000)}const but=document.getElementById("copy-path");if(!but){return}but.onclick=()=>{const title=document.querySelector("title").textContent.replace(" - Rust","");const[item,module]=title.split(" in ");const path=[item];if(module!==undefined){path.unshift(module)}copyContentToClipboard(path.join("::"));copyButtonAnimation(but)};function copyCode(codeElem){if(!codeElem){return}copyContentToClipboard(codeElem.textContent)}function getExampleWrap(event){let elem=event.target;while(!hasClass(elem,"example-wrap")){if(elem===document.body||elem.tagName==="A"||elem.tagName==="BUTTON"||hasClass(elem,"docblock")){return null}elem=elem.parentElement}return elem}function addCopyButton(event){const elem=getExampleWrap(event);if(elem===null){return}elem.removeEventListener("mouseover",addCopyButton);const parent=document.createElement("div");parent.className="button-holder";const runButton=elem.querySelector(".test-arrow");if(runButton!==null){parent.appendChild(runButton)}elem.appendChild(parent);const copyButton=document.createElement("button");copyButton.className="copy-button";copyButton.title="Copy code to clipboard";copyButton.addEventListener("click",()=>{copyCode(elem.querySelector("pre > code"));copyButtonAnimation(copyButton)});parent.appendChild(copyButton);if(!elem.parentElement.classList.contains("scraped-example")){return}const scrapedWrapped=elem.parentElement;window.updateScrapedExample(scrapedWrapped,parent)}function showHideCodeExampleButtons(event){const elem=getExampleWrap(event);if(elem===null){return}let buttons=elem.querySelector(".button-holder");if(buttons===null){addCopyButton(event);buttons=elem.querySelector(".button-holder");if(buttons===null){return}}buttons.classList.toggle("keep-visible")}onEachLazy(document.querySelectorAll(".docblock .example-wrap"),elem=>{elem.addEventListener("mouseover",addCopyButton);elem.addEventListener("click",showHideCodeExampleButtons)})}())
\ No newline at end of file
diff --git a/static.files/noscript-0111fcff984fae8f.css b/static.files/noscript-0111fcff984fae8f.css
new file mode 100644
index 00000000..a6c18eca
--- /dev/null
+++ b/static.files/noscript-0111fcff984fae8f.css
@@ -0,0 +1 @@
+ #main-content .attributes{margin-left:0 !important;}#copy-path,#sidebar-button,.sidebar-resizer{display:none !important;}nav.sub{display:none;}.src .sidebar{display:none;}.notable-traits{display:none;}:root,:root:not([data-theme]){--main-background-color:white;--main-color:black;--settings-input-color:#2196f3;--settings-input-border-color:#717171;--settings-button-color:#000;--settings-button-border-focus:#717171;--sidebar-background-color:#f5f5f5;--sidebar-background-color-hover:#e0e0e0;--code-block-background-color:#f5f5f5;--scrollbar-track-background-color:#dcdcdc;--scrollbar-thumb-background-color:rgba(36,37,39,0.6);--scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;--headings-border-bottom-color:#ddd;--border-color:#e0e0e0;--button-background-color:#fff;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:none;--mobile-sidebar-menu-filter:none;--search-input-focused-border-color:#66afe9;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(35%);--code-example-button-color:#7f7f7f;--code-example-button-hover-color:#595959;--settings-menu-filter:invert(50%);--settings-menu-hover-filter:invert(35%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ad378a;--trait-link-color:#6e4fc9;--assoc-item-link-color:#3873ad;--function-link-color:#ad7c37;--macro-link-color:#068000;--keyword-link-color:#3873ad;--mod-link-color:#3873ad;--link-color:#3873ad;--sidebar-link-color:#356da4;--sidebar-current-link-background-color:#fff;--search-result-link-focus-background-color:#ccc;--search-result-border-color:#aaa3;--search-color:#000;--search-error-code-background-color:#d0cccc;--search-results-alias-color:#000;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#e6e6e6;--search-tab-button-not-selected-background:#e6e6e6;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#fff;--stab-background-color:#fff5d6;--stab-code-color:#000;--code-highlight-kw-color:#8959a8;--code-highlight-kw-2-color:#4271ae;--code-highlight-lifetime-color:#b76514;--code-highlight-prelude-color:#4271ae;--code-highlight-prelude-val-color:#c82829;--code-highlight-number-color:#718c00;--code-highlight-string-color:#718c00;--code-highlight-literal-color:#c82829;--code-highlight-attribute-color:#c82829;--code-highlight-self-color:#c82829;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8e908c;--code-highlight-doc-comment-color:#4d4d4c;--src-line-numbers-span-color:#c67e2d;--src-line-number-highlighted-background-color:#fdffd3;--target-background-color:#fdffd3;--target-border-color:#ad7c37;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:initial;--crate-search-div-filter:invert(100%) sepia(0%) saturate(4223%) hue-rotate(289deg) brightness(114%) contrast(76%);--crate-search-div-hover-filter:invert(44%) sepia(18%) saturate(23%) hue-rotate(317deg) brightness(96%) contrast(93%);--crate-search-hover-border:#717171;--src-sidebar-background-selected:#fff;--src-sidebar-background-hover:#e0e0e0;--table-alt-row-background-color:#f5f5f5;--codeblock-link-background:#eee;--scrape-example-toggle-line-background:#ccc;--scrape-example-toggle-line-hover-background:#999;--scrape-example-code-line-highlight:#fcffd6;--scrape-example-code-line-highlight-focus:#f6fdb0;--scrape-example-help-border-color:#555;--scrape-example-help-color:#333;--scrape-example-help-hover-border-color:#000;--scrape-example-help-hover-color:#000;--scrape-example-code-wrapper-background-start:rgba(255,255,255,1);--scrape-example-code-wrapper-background-end:rgba(255,255,255,0);--sidebar-resizer-hover:hsl(207,90%,66%);--sidebar-resizer-active:hsl(207,90%,54%);}@media (prefers-color-scheme:dark){:root,:root:not([data-theme]){--main-background-color:#353535;--main-color:#ddd;--settings-input-color:#2196f3;--settings-input-border-color:#999;--settings-button-color:#000;--settings-button-border-focus:#ffb900;--sidebar-background-color:#505050;--sidebar-background-color-hover:#676767;--code-block-background-color:#2A2A2A;--scrollbar-track-background-color:#717171;--scrollbar-thumb-background-color:rgba(32,34,37,.6);--scrollbar-color:rgba(32,34,37,.6) #5a5a5a;--headings-border-bottom-color:#d2d2d2;--border-color:#e0e0e0;--button-background-color:#f0f0f0;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--mobile-sidebar-menu-filter:invert(100%);--search-input-focused-border-color:#008dfd;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(65%);--code-example-button-color:#7f7f7f;--code-example-button-hover-color:#a5a5a5;--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#2dbfb8;--trait-link-color:#b78cf2;--assoc-item-link-color:#d2991d;--function-link-color:#2bab63;--macro-link-color:#09bd00;--keyword-link-color:#d2991d;--mod-link-color:#d2991d;--link-color:#d2991d;--sidebar-link-color:#fdbf35;--sidebar-current-link-background-color:#444;--search-result-link-focus-background-color:#616161;--search-result-border-color:#aaa3;--search-color:#111;--search-error-code-background-color:#484848;--search-results-alias-color:#fff;--search-results-grey-color:#ccc;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#252525;--search-tab-button-not-selected-background:#252525;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#353535;--settings-menu-filter:invert(50%);--settings-menu-hover-filter:invert(65%);--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ab8ac1;--code-highlight-kw-2-color:#769acb;--code-highlight-lifetime-color:#d97f26;--code-highlight-prelude-color:#769acb;--code-highlight-prelude-val-color:#ee6868;--code-highlight-number-color:#83a300;--code-highlight-string-color:#83a300;--code-highlight-literal-color:#ee6868;--code-highlight-attribute-color:#ee6868;--code-highlight-self-color:#ee6868;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8d8d8b;--code-highlight-doc-comment-color:#8ca375;--src-line-numbers-span-color:#3b91e2;--src-line-number-highlighted-background-color:#0a042f;--target-background-color:#494a3d;--target-border-color:#bb7410;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(94%) sepia(0%) saturate(721%) hue-rotate(255deg) brightness(90%) contrast(90%);--crate-search-div-hover-filter:invert(69%) sepia(60%) saturate(6613%) hue-rotate(184deg) brightness(100%) contrast(91%);--crate-search-hover-border:#2196f3;--src-sidebar-background-selected:#333;--src-sidebar-background-hover:#444;--table-alt-row-background-color:#2a2a2a;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(53,53,53,1);--scrape-example-code-wrapper-background-end:rgba(53,53,53,0);--sidebar-resizer-hover:hsl(207,30%,54%);--sidebar-resizer-active:hsl(207,90%,54%);}}
\ No newline at end of file
diff --git a/static.files/rustdoc-b0742ba02757f159.css b/static.files/rustdoc-b0742ba02757f159.css
new file mode 100644
index 00000000..9fef311d
--- /dev/null
+++ b/static.files/rustdoc-b0742ba02757f159.css
@@ -0,0 +1,53 @@
+ :root{--nav-sub-mobile-padding:8px;--search-typename-width:6.75rem;--desktop-sidebar-width:200px;--src-sidebar-width:300px;--desktop-sidebar-z-index:100;--sidebar-elems-left-padding:24px;--clipboard-image:url('data:image/svg+xml,\
+\
+\
+');--copy-path-height:34px;--copy-path-width:33px;--checkmark-image:url('data:image/svg+xml,\
+\
+');--button-left-margin:4px;--button-border-radius:2px;--toolbar-button-border-radius:6px;--code-block-border-radius:6px;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular-018c141bf0843ffd.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium-8f9a781e4970d388.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:400;src:local('Source Serif 4'),url("SourceSerif4-Regular-46f98efaafac5295.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:italic;font-weight:400;src:local('Source Serif 4 Italic'),url("SourceSerif4-It-acdfaf1a8af734b1.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:700;src:local('Source Serif 4 Bold'),url("SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:italic;font-weight:400;src:url("SourceCodePro-It-1cc31594bf4f1f79.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2") format("woff2");font-display:swap;}@font-face {font-family:'NanumBarunGothic';src:url("NanumBarunGothic-0f09457c7a19b7c6.ttf.woff2") format("woff2");font-display:swap;unicode-range:U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF;}*{box-sizing:border-box;}body{font:1rem/1.5 "Source Serif 4",NanumBarunGothic,serif;margin:0;position:relative;overflow-wrap:break-word;overflow-wrap:anywhere;font-feature-settings:"kern","liga";background-color:var(--main-background-color);color:var(--main-color);}h1{font-size:1.5rem;}h2{font-size:1.375rem;}h3{font-size:1.25rem;}h1,h2,h3,h4,h5,h6{font-weight:500;}h1,h2,h3,h4{margin:25px 0 15px 0;padding-bottom:6px;}.docblock h3,.docblock h4,h5,h6{margin:15px 0 5px 0;}.docblock>h2:first-child,.docblock>h3:first-child,.docblock>h4:first-child,.docblock>h5:first-child,.docblock>h6:first-child{margin-top:0;}.main-heading h1{margin:0;padding:0;grid-area:main-heading-h1;overflow-wrap:break-word;overflow-wrap:anywhere;}.main-heading{position:relative;display:grid;grid-template-areas:"main-heading-breadcrumbs main-heading-breadcrumbs" "main-heading-h1 main-heading-toolbar" "main-heading-sub-heading main-heading-toolbar";grid-template-columns:minmax(105px,1fr) minmax(0,max-content);grid-template-rows:minmax(25px,min-content) min-content min-content;padding-bottom:6px;margin-bottom:11px;}.rustdoc-breadcrumbs{grid-area:main-heading-breadcrumbs;line-height:1.25;display:flex;flex-wrap:wrap;align-items:end;padding-top:5px;}.rustdoc-breadcrumbs a{padding:4px 0;margin:-4px 0;z-index:1;}.content h2,.top-doc .docblock>h3,.top-doc .docblock>h4{border-bottom:1px solid var(--headings-border-bottom-color);}h1,h2{line-height:1.25;padding-top:3px;padding-bottom:9px;}h3.code-header{font-size:1.125rem;}h4.code-header{font-size:1rem;}.code-header{font-weight:600;margin:0;padding:0;white-space:pre-wrap;}.structfield{margin:0.6em 0;}#crate-search,h1,h2,h3,h4,h5,h6,.sidebar,.mobile-topbar,.search-input,.search-results .result-name,.item-name>a,.out-of-band,.sub-heading,span.since,a.src,rustdoc-toolbar,summary.hideme,.scraped-example-list,.rustdoc-breadcrumbs,ul.all-items{font-family:"Fira Sans",Arial,NanumBarunGothic,sans-serif;}#toggle-all-docs,a.anchor,.section-header a,#src-sidebar a,.rust a,.sidebar h2 a,.sidebar h3 a,.mobile-topbar h2 a,h1 a,.search-results a,.stab,.result-name i{color:var(--main-color);}span.enum,a.enum,span.struct,a.struct,span.union,a.union,span.primitive,a.primitive,span.type,a.type,span.foreigntype,a.foreigntype{color:var(--type-link-color);}span.trait,a.trait,span.traitalias,a.traitalias{color:var(--trait-link-color);}span.associatedtype,a.associatedtype,span.constant,a.constant,span.static,a.static{color:var(--assoc-item-link-color);}span.fn,a.fn,span.method,a.method,span.tymethod,a.tymethod{color:var(--function-link-color);}span.attr,a.attr,span.derive,a.derive,span.macro,a.macro{color:var(--macro-link-color);}span.mod,a.mod{color:var(--mod-link-color);}span.keyword,a.keyword{color:var(--keyword-link-color);}a{color:var(--link-color);text-decoration:none;}ol,ul{padding-left:24px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.625em;}p,.docblock>.warning{margin:0 0 .75em 0;}p:last-child,.docblock>.warning:last-child{margin:0;}button{padding:1px 6px;cursor:pointer;}button#toggle-all-docs{padding:0;background:none;border:none;-webkit-appearance:none;opacity:1;}.rustdoc{display:flex;flex-direction:row;flex-wrap:nowrap;}main{position:relative;flex-grow:1;padding:10px 15px 40px 45px;min-width:0;}.src main{padding:15px;}.width-limiter{max-width:960px;margin-right:auto;}details:not(.toggle) summary{margin-bottom:.6em;}code,pre,.code-header{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.125em;}.docblock pre code,.docblock-short pre code{padding:0;}pre{padding:14px;line-height:1.5;}pre.item-decl{overflow-x:auto;}.item-decl .type-contents-toggle{contain:initial;}.src .content pre{padding:20px;}.rustdoc.src .example-wrap .src-line-numbers{padding:20px 0 20px 4px;}img{max-width:100%;}.logo-container{line-height:0;display:block;}.rust-logo{filter:var(--rust-logo-filter);}.sidebar{font-size:0.875rem;flex:0 0 var(--desktop-sidebar-width);width:var(--desktop-sidebar-width);overflow-y:scroll;overscroll-behavior:contain;position:sticky;height:100vh;top:0;left:0;z-index:var(--desktop-sidebar-z-index);}.rustdoc.src .sidebar{flex-basis:50px;width:50px;border-right:1px solid;overflow-x:hidden;overflow-y:hidden;}.hide-sidebar .sidebar,.hide-sidebar .sidebar-resizer{display:none;}.sidebar-resizer{touch-action:none;width:9px;cursor:col-resize;z-index:calc(var(--desktop-sidebar-z-index) + 1);position:fixed;height:100%;left:calc(var(--desktop-sidebar-width) + 1px);}.rustdoc.src .sidebar-resizer{left:49px;}.src-sidebar-expanded .src .sidebar-resizer{left:var(--src-sidebar-width);}.sidebar-resizing{-moz-user-select:none;-webkit-user-select:none;-ms-user-select:none;user-select:none;}.sidebar-resizing*{cursor:col-resize !important;}.sidebar-resizing .sidebar{position:fixed;}.sidebar-resizing>body{padding-left:var(--resizing-sidebar-width);}.sidebar-resizer:hover,.sidebar-resizer:active,.sidebar-resizer:focus,.sidebar-resizer.active{width:10px;margin:0;left:var(--desktop-sidebar-width);border-left:solid 1px var(--sidebar-resizer-hover);}.src-sidebar-expanded .rustdoc.src .sidebar-resizer:hover,.src-sidebar-expanded .rustdoc.src .sidebar-resizer:active,.src-sidebar-expanded .rustdoc.src .sidebar-resizer:focus,.src-sidebar-expanded .rustdoc.src .sidebar-resizer.active{left:calc(var(--src-sidebar-width) - 1px);}@media (pointer:coarse){.sidebar-resizer{display:none !important;}}.sidebar-resizer.active{padding:0 140px;width:2px;margin-left:-140px;border-left:none;}.sidebar-resizer.active:before{border-left:solid 2px var(--sidebar-resizer-active);display:block;height:100%;content:"";}.sidebar,.mobile-topbar,.sidebar-menu-toggle,#src-sidebar{background-color:var(--sidebar-background-color);}.src .sidebar>*{visibility:hidden;}.src-sidebar-expanded .src .sidebar{overflow-y:auto;flex-basis:var(--src-sidebar-width);width:var(--src-sidebar-width);}.src-sidebar-expanded .src .sidebar>*{visibility:visible;}#all-types{margin-top:1em;}*{scrollbar-width:initial;scrollbar-color:var(--scrollbar-color);}.sidebar{scrollbar-width:thin;scrollbar-color:var(--scrollbar-color);}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;background-color:var(--scrollbar-track-background-color);}.sidebar::-webkit-scrollbar-track{background-color:var(--scrollbar-track-background-color);}::-webkit-scrollbar-thumb,.sidebar::-webkit-scrollbar-thumb{background-color:var(--scrollbar-thumb-background-color);}.hidden{display:none !important;}.logo-container>img{height:48px;width:48px;}ul.block,.block li,.block ul{padding:0;margin:0;list-style:none;}.block ul a{padding-left:1rem;}.sidebar-elems a,.sidebar>h2 a{display:block;padding:0.25rem;margin-right:0.25rem;border-left:solid var(--sidebar-elems-left-padding) transparent;margin-left:calc(-0.25rem - var(--sidebar-elems-left-padding));background-clip:border-box;}.hide-toc #rustdoc-toc,.hide-toc .in-crate{display:none;}.hide-modnav #rustdoc-modnav{display:none;}.sidebar h2{text-wrap:balance;overflow-wrap:anywhere;padding:0;margin:0.7rem 0;}.sidebar h3{text-wrap:balance;overflow-wrap:anywhere;font-size:1.125rem;padding:0;margin:0;}.sidebar-elems,.sidebar>.version,.sidebar>h2{padding-left:var(--sidebar-elems-left-padding);}.sidebar a{color:var(--sidebar-link-color);}.sidebar .current,.sidebar .current a,.sidebar-crate a.logo-container:hover+h2 a,.sidebar a:hover:not(.logo-container){background-color:var(--sidebar-current-link-background-color);}.sidebar-elems .block{margin-bottom:2em;}.sidebar-elems .block li a{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;}.sidebar-crate{display:flex;align-items:center;justify-content:center;margin:14px 32px 1rem;row-gap:10px;column-gap:32px;flex-wrap:wrap;}.sidebar-crate h2{flex-grow:1;margin:0 -8px;align-self:start;}.sidebar-crate .logo-container{margin:0 calc(-16px - var(--sidebar-elems-left-padding));padding:0 var(--sidebar-elems-left-padding);text-align:center;}.sidebar-crate .logo-container img{margin-top:-16px;border-top:solid 16px transparent;box-sizing:content-box;position:relative;background-clip:border-box;z-index:1;}.sidebar-crate h2 a{display:block;border-left:solid var(--sidebar-elems-left-padding) transparent;background-clip:border-box;margin:0 calc(-24px + 0.25rem) 0 calc(-0.2rem - var(--sidebar-elems-left-padding));padding:calc((16px - 0.57rem ) / 2 ) 0.25rem;padding-left:0.2rem;}.sidebar-crate h2 .version{display:block;font-weight:normal;font-size:1rem;overflow-wrap:break-word;}.sidebar-crate+.version{margin-top:-1rem;margin-bottom:1rem;}.mobile-topbar{display:none;}.rustdoc .example-wrap{display:flex;position:relative;margin-bottom:10px;}.rustdoc .example-wrap>pre,.rustdoc .scraped-example .src-line-numbers,.rustdoc .scraped-example .src-line-numbers>pre{border-radius:6px;}.rustdoc .example-wrap>.example-line-numbers,.rustdoc .scraped-example .src-line-numbers,.rustdoc .scraped-example .src-line-numbers>pre{border-top-right-radius:0;border-bottom-right-radius:0;}.rustdoc .example-wrap>.example-line-numbers+pre,.rustdoc .scraped-example .rust{border-top-left-radius:0;border-bottom-left-radius:0;}.rustdoc .scraped-example{position:relative;}.rustdoc .example-wrap:last-child{margin-bottom:0px;}.rustdoc .example-wrap pre{margin:0;flex-grow:1;}.scraped-example:not(.expanded) .example-wrap{max-height:calc(1.5em * 5 + 10px);}.more-scraped-examples .scraped-example:not(.expanded) .example-wrap{max-height:calc(1.5em * 10 + 10px);}.rustdoc:not(.src) .scraped-example:not(.expanded) .src-line-numbers,.rustdoc:not(.src) .scraped-example:not(.expanded) .src-line-numbers>pre,.rustdoc:not(.src) .scraped-example:not(.expanded) pre.rust{padding-bottom:0;overflow:auto hidden;}.rustdoc:not(.src) .scraped-example .src-line-numbers{padding-top:0;}.rustdoc:not(.src) .scraped-example.expanded .src-line-numbers{padding-bottom:0;}.rustdoc:not(.src) .example-wrap pre{overflow:auto;}.rustdoc .example-wrap pre.example-line-numbers,.rustdoc .example-wrap .src-line-numbers{min-width:fit-content;flex-grow:0;text-align:right;-webkit-user-select:none;user-select:none;padding:14px 8px;padding-right:2px;color:var(--src-line-numbers-span-color);}.rustdoc .scraped-example .example-wrap .src-line-numbers{padding:0;}.rustdoc .src-line-numbers pre{padding:14px 0;}.src-line-numbers a,.src-line-numbers span{color:var(--src-line-numbers-span-color);padding:0 8px;}.src-line-numbers :target{background-color:transparent;border-right:none;padding:0 8px;}.src-line-numbers .line-highlighted{background-color:var(--src-line-number-highlighted-background-color);}.search-loading{text-align:center;}.docblock-short{overflow-wrap:break-word;overflow-wrap:anywhere;}.docblock :not(pre)>code,.docblock-short code{white-space:pre-wrap;}.top-doc .docblock h2{font-size:1.375rem;}.top-doc .docblock h3{font-size:1.25rem;}.top-doc .docblock h4,.top-doc .docblock h5{font-size:1.125rem;}.top-doc .docblock h6{font-size:1rem;}.docblock h5{font-size:1rem;}.docblock h6{font-size:0.875rem;}.docblock{margin-left:24px;position:relative;}.docblock>:not(.more-examples-toggle):not(.example-wrap){max-width:100%;overflow-x:auto;}.sub-heading{font-size:1rem;flex-grow:0;grid-area:main-heading-sub-heading;line-height:1.25;padding-bottom:4px;}.main-heading rustdoc-toolbar,.main-heading .out-of-band{grid-area:main-heading-toolbar;}rustdoc-toolbar{display:flex;flex-direction:row;flex-wrap:nowrap;min-height:60px;}.docblock code,.docblock-short code,pre,.rustdoc.src .example-wrap,.example-wrap .src-line-numbers{background-color:var(--code-block-background-color);border-radius:var(--code-block-border-radius);}#main-content{position:relative;}.docblock table{margin:.5em 0;border-collapse:collapse;}.docblock table td,.docblock table th{padding:.5em;border:1px solid var(--border-color);}.docblock table tbody tr:nth-child(2n){background:var(--table-alt-row-background-color);}.docblock .stab,.docblock-short .stab{display:inline-block;}.docblock li{margin-bottom:.4em;}.docblock li p:not(:last-child){margin-bottom:.3em;}div.where{white-space:pre-wrap;font-size:0.875rem;}.item-info{display:block;margin-left:24px;}.item-info code{font-size:0.875rem;}#main-content>.item-info{margin-left:0;}nav.sub{flex-grow:1;flex-flow:row nowrap;margin:4px 0 0 0;display:flex;align-items:center;}.search-form{position:relative;display:flex;height:34px;flex-grow:1;}.src nav.sub{margin:0 0 -10px 0;}.section-header{display:block;position:relative;}.section-header:hover>.anchor,.impl:hover>.anchor,.trait-impl:hover>.anchor,.variant:hover>.anchor{display:initial;}.anchor{display:none;position:absolute;left:-0.5em;background:none !important;}.anchor.field{left:-5px;}.section-header>.anchor{left:-15px;padding-right:8px;}h2.section-header>.anchor{padding-right:6px;}a.doc-anchor{color:var(--main-color);display:none;position:absolute;left:-17px;padding-right:10px;padding-left:3px;}*:hover>.doc-anchor{display:block;}.top-doc>.docblock>*:first-child>.doc-anchor{display:none !important;}.main-heading a:hover,.example-wrap .rust a:hover,.all-items a:hover,.docblock a:not(.scrape-help):not(.tooltip):hover:not(.doc-anchor),.docblock-short a:not(.scrape-help):not(.tooltip):hover,.item-info a{text-decoration:underline;}.crate.block li.current a{font-weight:500;}table,.item-table{overflow-wrap:break-word;}.item-table{display:table;padding:0;margin:0;width:100%;}.item-table>li{display:table-row;}.item-table>li>div{display:table-cell;}.item-table>li>.item-name{padding-right:1.25rem;}.search-results-title{margin-top:0;white-space:nowrap;display:flex;align-items:baseline;}.search-results-title+.sub-heading{color:var(--main-color);display:flex;align-items:baseline;white-space:nowrap;}#crate-search-div{position:relative;min-width:0;}#crate-search{padding:0 23px 0 4px;max-width:100%;text-overflow:ellipsis;border:1px solid var(--border-color);border-radius:4px;outline:none;cursor:pointer;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;background-color:var(--main-background-color);color:inherit;line-height:1.5;font-weight:500;}#crate-search:hover,#crate-search:focus{border-color:var(--crate-search-hover-border);}#crate-search-div::after{pointer-events:none;width:100%;height:100%;position:absolute;top:0;left:0;content:"";background-repeat:no-repeat;background-size:20px;background-position:calc(100% - 2px) 56%;background-image:url('data:image/svg+xml, \
+	');filter:var(--crate-search-div-filter);}#crate-search-div:hover::after,#crate-search-div:focus-within::after{filter:var(--crate-search-div-hover-filter);}#crate-search>option{font-size:1rem;}.search-input{-webkit-appearance:none;outline:none;border:1px solid var(--border-color);border-radius:2px;padding:8px;font-size:1rem;flex-grow:1;background-color:var(--button-background-color);color:var(--search-color);}.search-input:focus{border-color:var(--search-input-focused-border-color);}.search-results{display:none;}.search-results.active{display:block;}.search-results>a{display:flex;margin-left:2px;margin-right:2px;border-bottom:1px solid var(--search-result-border-color);gap:1em;}.search-results>a>div.desc{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;flex:2;}.search-results a:hover,.search-results a:focus{background-color:var(--search-result-link-focus-background-color);}.search-results .result-name{display:flex;align-items:center;justify-content:start;flex:3;}.search-results .result-name .alias{color:var(--search-results-alias-color);}.search-results .result-name .grey{color:var(--search-results-grey-color);}.search-results .result-name .typename{color:var(--search-results-grey-color);font-size:0.875rem;width:var(--search-typename-width);}.search-results .result-name .path{word-break:break-all;max-width:calc(100% - var(--search-typename-width));display:inline-block;}.search-results .result-name .path>*{display:inline;}.popover{position:absolute;top:100%;right:0;z-index:calc(var(--desktop-sidebar-z-index) + 1);margin-top:7px;border-radius:3px;border:1px solid var(--border-color);background-color:var(--main-background-color);color:var(--main-color);--popover-arrow-offset:11px;}.popover::before{content:'';position:absolute;right:var(--popover-arrow-offset);border:solid var(--border-color);border-width:1px 1px 0 0;background-color:var(--main-background-color);padding:4px;transform:rotate(-45deg);top:-5px;}.setting-line{margin:1.2em 0.6em;}.setting-radio input,.setting-check input{margin-right:0.3em;height:1.2rem;width:1.2rem;border:2px solid var(--settings-input-border-color);outline:none;-webkit-appearance:none;cursor:pointer;}.setting-radio input{border-radius:50%;}.setting-radio span,.setting-check span{padding-bottom:1px;}.setting-radio{margin-top:0.1em;margin-bottom:0.1em;min-width:3.8em;padding:0.3em;display:inline-flex;align-items:center;cursor:pointer;}.setting-radio+.setting-radio{margin-left:0.5em;}.setting-check{margin-right:20px;display:flex;align-items:center;cursor:pointer;}.setting-radio input:checked{box-shadow:inset 0 0 0 3px var(--main-background-color);background-color:var(--settings-input-color);}.setting-check input:checked{background-color:var(--settings-input-color);border-width:1px;content:url('data:image/svg+xml,\
+		\
+		');}.setting-radio input:focus,.setting-check input:focus{box-shadow:0 0 1px 1px var(--settings-input-color);}.setting-radio input:checked:focus{box-shadow:inset 0 0 0 3px var(--main-background-color),0 0 2px 2px var(--settings-input-color);}.setting-radio input:hover,.setting-check input:hover{border-color:var(--settings-input-color) !important;}#settings.popover{--popover-arrow-offset:202px;top:calc(100% - 16px);}#help.popover{max-width:600px;--popover-arrow-offset:118px;top:calc(100% - 16px);}#help dt{float:left;clear:left;margin-right:0.5rem;}#help dd{margin-bottom:0.5rem;}#help span.top,#help span.bottom{text-align:center;display:block;font-size:1.125rem;padding:0 0.5rem;text-wrap-style:balance;}#help span.top{margin:10px 0;border-bottom:1px solid var(--border-color);padding-bottom:4px;margin-bottom:6px;}#help span.bottom{clear:both;border-top:1px solid var(--border-color);}.side-by-side{display:flex;margin-bottom:20px;}.side-by-side>div{width:50%;padding:0 20px 0 17px;}.item-info .stab{display:block;padding:3px;margin-bottom:5px;}.item-name .stab{margin-left:0.3125em;}.stab{padding:0 2px;font-size:0.875rem;font-weight:normal;color:var(--main-color);background-color:var(--stab-background-color);width:fit-content;white-space:pre-wrap;border-radius:3px;display:inline;vertical-align:baseline;}.stab.portability>code{background:none;color:var(--stab-code-color);}.stab .emoji,.item-info .stab::before{font-size:1.25rem;}.stab .emoji{margin-right:0.3rem;}.item-info .stab::before{content:"\0";width:0;display:inline-block;color:transparent;}.emoji{text-shadow:1px 0 0 black,-1px 0 0 black,0 1px 0 black,0 -1px 0 black;}.since{font-weight:normal;font-size:initial;}.rightside{padding-left:12px;float:right;}.rightside:not(a),.out-of-band,.sub-heading,rustdoc-toolbar{color:var(--right-side-color);}pre.rust{tab-size:4;-moz-tab-size:4;}pre.rust .kw{color:var(--code-highlight-kw-color);}pre.rust .kw-2{color:var(--code-highlight-kw-2-color);}pre.rust .lifetime{color:var(--code-highlight-lifetime-color);}pre.rust .prelude-ty{color:var(--code-highlight-prelude-color);}pre.rust .prelude-val{color:var(--code-highlight-prelude-val-color);}pre.rust .string{color:var(--code-highlight-string-color);}pre.rust .number{color:var(--code-highlight-number-color);}pre.rust .bool-val{color:var(--code-highlight-literal-color);}pre.rust .self{color:var(--code-highlight-self-color);}pre.rust .attr{color:var(--code-highlight-attribute-color);}pre.rust .macro,pre.rust .macro-nonterminal{color:var(--code-highlight-macro-color);}pre.rust .question-mark{font-weight:bold;color:var(--code-highlight-question-mark-color);}pre.rust .comment{color:var(--code-highlight-comment-color);}pre.rust .doccomment{color:var(--code-highlight-doc-comment-color);}.rustdoc.src .example-wrap pre.rust a{background:var(--codeblock-link-background);}.example-wrap.compile_fail,.example-wrap.should_panic{border-left:2px solid var(--codeblock-error-color);}.ignore.example-wrap{border-left:2px solid var(--codeblock-ignore-color);}.example-wrap.compile_fail:hover,.example-wrap.should_panic:hover{border-left:2px solid var(--codeblock-error-hover-color);}.example-wrap.ignore:hover{border-left:2px solid var(--codeblock-ignore-hover-color);}.example-wrap.compile_fail .tooltip,.example-wrap.should_panic .tooltip{color:var(--codeblock-error-color);}.example-wrap.ignore .tooltip{color:var(--codeblock-ignore-color);}.example-wrap.compile_fail:hover .tooltip,.example-wrap.should_panic:hover .tooltip{color:var(--codeblock-error-hover-color);}.example-wrap.ignore:hover .tooltip{color:var(--codeblock-ignore-hover-color);}.example-wrap .tooltip{position:absolute;display:block;left:-25px;top:5px;margin:0;line-height:1;}.example-wrap.compile_fail .tooltip,.example-wrap.should_panic .tooltip,.example-wrap.ignore .tooltip{font-weight:bold;font-size:1.25rem;}.content .docblock .warning{border-left:2px solid var(--warning-border-color);padding:14px;position:relative;overflow-x:visible !important;}.content .docblock .warning::before{color:var(--warning-border-color);content:"ⓘ";position:absolute;left:-25px;top:5px;font-weight:bold;font-size:1.25rem;}.top-doc>.docblock>.warning:first-child::before{top:20px;}.example-wrap>a.test-arrow,.example-wrap .button-holder{visibility:hidden;position:absolute;top:4px;right:4px;z-index:1;}a.test-arrow{height:var(--copy-path-height);padding:6px 4px 0 11px;}a.test-arrow::before{content:url('data:image/svg+xml,');}.example-wrap .button-holder{display:flex;}@media not (pointer:coarse){.example-wrap:hover>a.test-arrow,.example-wrap:hover>.button-holder{visibility:visible;}}.example-wrap .button-holder.keep-visible{visibility:visible;}.example-wrap .button-holder>*{background:var(--main-background-color);cursor:pointer;border-radius:var(--button-border-radius);height:var(--copy-path-height);width:var(--copy-path-width);border:0;color:var(--code-example-button-color);}.example-wrap .button-holder>*:hover{color:var(--code-example-button-hover-color);}.example-wrap .button-holder>*:not(:first-child){margin-left:var(--button-left-margin);}.example-wrap .button-holder .copy-button{padding:2px 0 0 4px;}.example-wrap .button-holder .copy-button::before,.example-wrap .test-arrow::before{filter:var(--copy-path-img-filter);}.example-wrap .button-holder .copy-button::before{content:var(--clipboard-image);}.example-wrap .button-holder .copy-button:hover::before,.example-wrap .test-arrow:hover::before{filter:var(--copy-path-img-hover-filter);}.example-wrap .button-holder .copy-button.clicked::before{content:var(--checkmark-image);padding-right:5px;}.code-attribute{font-weight:300;color:var(--code-attribute-color);}.item-spacer{width:100%;height:12px;display:block;}.main-heading span.since::before{content:"Since ";}.sub-variant h4{font-size:1rem;font-weight:400;margin-top:0;margin-bottom:0;}.sub-variant{margin-left:24px;margin-bottom:40px;}.sub-variant>.sub-variant-field{margin-left:24px;}@keyframes targetfadein{from{background-color:var(--main-background-color);}10%{background-color:var(--target-border-color);}to{background-color:var(--target-background-color);}}:target{padding-right:3px;background-color:var(--target-background-color);border-right:3px solid var(--target-border-color);}.code-header a.tooltip{color:inherit;margin-right:15px;position:relative;}.code-header a.tooltip:hover{color:var(--link-color);}a.tooltip:hover::after{position:absolute;top:calc(100% - 10px);left:-15px;right:-15px;height:20px;content:"\00a0";}@media not (prefers-reduced-motion){:target{animation:0.65s cubic-bezier(0,0,0.1,1.0) 0.1s targetfadein;}.fade-out{opacity:0;transition:opacity 0.45s cubic-bezier(0,0,0.1,1.0);}}.popover.tooltip .content{margin:0.25em 0.5em;}.popover.tooltip .content pre,.popover.tooltip .content code{background:transparent;margin:0;padding:0;font-size:1.25rem;white-space:pre-wrap;}.popover.tooltip .content>h3:first-child{margin:0 0 5px 0;}.search-failed{text-align:center;margin-top:20px;display:none;}.search-failed.active{display:block;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#search-tabs{margin-top:0.25rem;display:flex;flex-direction:row;gap:1px;margin-bottom:4px;}#search-tabs button{text-align:center;font-size:1.125rem;border:0;border-top:2px solid;flex:1;line-height:1.5;color:inherit;}#search-tabs button:not(.selected){background-color:var(--search-tab-button-not-selected-background);border-top-color:var(--search-tab-button-not-selected-border-top-color);}#search-tabs button:hover,#search-tabs button.selected{background-color:var(--search-tab-button-selected-background);border-top-color:var(--search-tab-button-selected-border-top-color);}#search-tabs .count{font-size:1rem;font-variant-numeric:tabular-nums;color:var(--search-tab-title-count-color);}#search .error code{border-radius:3px;background-color:var(--search-error-code-background-color);}.search-corrections{font-weight:normal;}#src-sidebar{width:100%;overflow:auto;}#src-sidebar div.files>a:hover,details.dir-entry summary:hover,#src-sidebar div.files>a:focus,details.dir-entry summary:focus{background-color:var(--src-sidebar-background-hover);}#src-sidebar div.files>a.selected{background-color:var(--src-sidebar-background-selected);}.src-sidebar-title{position:sticky;top:0;display:flex;padding:8px 8px 0 48px;margin-bottom:7px;background:var(--sidebar-background-color);border-bottom:1px solid var(--border-color);}#settings-menu,#help-button,button#toggle-all-docs{margin-left:var(--button-left-margin);display:flex;line-height:1.25;min-width:14px;}#sidebar-button{display:none;line-height:0;}.hide-sidebar #sidebar-button,.src #sidebar-button{display:flex;margin-right:4px;position:fixed;left:6px;height:34px;width:34px;background-color:var(--main-background-color);z-index:1;}.src #sidebar-button{left:8px;z-index:calc(var(--desktop-sidebar-z-index) + 1);}.hide-sidebar .src #sidebar-button{position:static;}#settings-menu>a,#help-button>a,#sidebar-button>a,button#toggle-all-docs{display:flex;align-items:center;justify-content:center;flex-direction:column;border:1px solid transparent;border-radius:var(--button-border-radius);color:var(--main-color);}#settings-menu>a,#help-button>a,button#toggle-all-docs{width:80px;border-radius:var(--toolbar-button-border-radius);}#settings-menu>a,#help-button>a{min-width:0;}#sidebar-button>a{background-color:var(--button-background-color);border-color:var(--border-color);width:33px;}#settings-menu>a:hover,#settings-menu>a:focus-visible,#help-button>a:hover,#help-button>a:focus-visible,#sidebar-button>a:hover,#sidebar-button>a:focus-visible,button#toggle-all-docs:hover,button#toggle-all-docs:focus-visible{border-color:var(--settings-button-border-focus);text-decoration:none;}#settings-menu>a:before{content:url('data:image/svg+xml,\
+	');width:18px;height:18px;filter:var(--settings-menu-filter);}button#toggle-all-docs:before{content:url('data:image/svg+xml,\
+	');width:18px;height:18px;filter:var(--settings-menu-filter);}#help-button>a:before{content:url('data:image/svg+xml,\
+	\
+	?');width:18px;height:18px;filter:var(--settings-menu-filter);}button#toggle-all-docs:before,#help-button>a:before,#settings-menu>a:before{filter:var(--settings-menu-filter);margin:8px;}@media not (pointer:coarse){button#toggle-all-docs:hover:before,#help-button>a:hover:before,#settings-menu>a:hover:before{filter:var(--settings-menu-hover-filter);}}button[disabled]#toggle-all-docs{opacity:0.25;border:solid 1px var(--main-background-color);background-size:cover;}button[disabled]#toggle-all-docs:hover{border:solid 1px var(--main-background-color);cursor:not-allowed;}rustdoc-toolbar span.label{font-size:1rem;flex-grow:1;padding-bottom:4px;}#sidebar-button>a:before{content:url('data:image/svg+xml,\
+		\
+		\
+		');width:22px;height:22px;}#copy-path{color:var(--copy-path-button-color);background:var(--main-background-color);height:var(--copy-path-height);width:var(--copy-path-width);margin-left:10px;padding:0;padding-left:2px;border:0;font-size:0;}#copy-path::before{filter:var(--copy-path-img-filter);content:var(--clipboard-image);}#copy-path:hover::before{filter:var(--copy-path-img-hover-filter);}#copy-path.clicked::before{content:var(--checkmark-image);}@keyframes rotating{from{transform:rotate(0deg);}to{transform:rotate(360deg);}}#settings-menu.rotate>a img{animation:rotating 2s linear infinite;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px var(--border-color);border-radius:3px;color:var(--kbd-color);background-color:var(--kbd-background);box-shadow:inset 0 -1px 0 var(--kbd-box-shadow-color);}ul.all-items>li{list-style:none;}details.dir-entry{padding-left:4px;}details.dir-entry>summary{margin:0 0 0 -4px;padding:0 0 0 4px;cursor:pointer;}details.dir-entry div.folders,details.dir-entry div.files{padding-left:23px;}details.dir-entry a{display:block;}details.toggle{contain:layout;position:relative;}details.big-toggle{contain:inline-size;}details.toggle>summary.hideme{cursor:pointer;font-size:1rem;}details.toggle>summary{list-style:none;outline:none;}details.toggle>summary::-webkit-details-marker,details.toggle>summary::marker{display:none;}details.toggle>summary.hideme>span{margin-left:9px;}details.toggle>summary::before{background:url('data:image/svg+xml,\
+	');content:"";cursor:pointer;width:16px;height:16px;display:inline-block;vertical-align:middle;opacity:.5;filter:var(--toggle-filter);}details.toggle>summary.hideme>span,.more-examples-toggle summary,.more-examples-toggle .hide-more{color:var(--toggles-color);}details.toggle>summary::after{content:"Expand";overflow:hidden;width:0;height:0;position:absolute;}details.toggle>summary.hideme::after{content:"";}details.toggle>summary:focus::before,details.toggle>summary:hover::before{opacity:1;}details.toggle>summary:focus-visible::before{outline:1px dotted #000;outline-offset:1px;}details.non-exhaustive{margin-bottom:8px;}details.toggle>summary.hideme::before{position:relative;}details.toggle>summary:not(.hideme)::before{position:absolute;left:-24px;top:4px;}.impl-items>details.toggle>summary:not(.hideme)::before{position:absolute;left:-24px;}details.big-toggle>summary:not(.hideme)::before{left:-34px;top:9px;}details.toggle[open] >summary.hideme{position:absolute;}details.toggle[open] >summary.hideme>span{display:none;}details.toggle[open] >summary::before{background:url('data:image/svg+xml,\
+	');}details.toggle[open] >summary::after{content:"Collapse";}.docblock summary>*{display:inline-block;}.docblock>.example-wrap:first-child .tooltip{margin-top:16px;}.src #sidebar-button>a:before,.sidebar-menu-toggle:before{content:url('data:image/svg+xml,\
+		');opacity:0.75;}.sidebar-menu-toggle:hover:before,.sidebar-menu-toggle:active:before,.sidebar-menu-toggle:focus:before{opacity:1;}.src #sidebar-button>a:before{content:url('data:image/svg+xml,\
+		\
+		\
+		');opacity:0.75;}@media (max-width:850px){#search-tabs .count{display:block;}.side-by-side{flex-direction:column-reverse;}.side-by-side>div{width:auto;}}@media (max-width:700px){*[id]{scroll-margin-top:45px;}#copy-path{display:none;}rustdoc-toolbar span.label{display:none;}#settings-menu>a,#help-button>a,button#toggle-all-docs{width:33px;}#settings.popover{--popover-arrow-offset:86px;}#help.popover{--popover-arrow-offset:48px;}.rustdoc{display:block;}main{padding-left:15px;padding-top:0px;}.sidebar .logo-container,.sidebar .location,.sidebar-resizer{display:none;}.sidebar{position:fixed;top:45px;left:-1000px;z-index:11;height:calc(100vh - 45px);width:200px;}.src main,.rustdoc.src .sidebar{top:0;padding:0;height:100vh;border:0;}.src .search-form{margin-left:40px;}.src .main-heading{margin-left:8px;}.hide-sidebar .search-form{margin-left:32px;}.hide-sidebar .src .search-form{margin-left:0;}.sidebar.shown,.src-sidebar-expanded .src .sidebar,.rustdoc:not(.src) .sidebar:focus-within{left:0;}.mobile-topbar h2{padding-bottom:0;margin:auto 0.5em auto auto;overflow:hidden;font-size:24px;white-space:nowrap;text-overflow:ellipsis;}.mobile-topbar .logo-container>img{max-width:35px;max-height:35px;margin:5px 0 5px 20px;}.mobile-topbar{display:flex;flex-direction:row;position:sticky;z-index:10;font-size:2rem;height:45px;width:100%;left:0;top:0;}.hide-sidebar .mobile-topbar{display:none;}.sidebar-menu-toggle{width:45px;border:none;line-height:0;}.hide-sidebar .sidebar-menu-toggle{display:none;}.sidebar-elems{margin-top:1em;}.anchor{display:none !important;}#main-content>details.toggle>summary::before,#main-content>div>details.toggle>summary::before{left:-11px;}#sidebar-button>a:before{content:url('data:image/svg+xml,\
+			\
+			\
+			');width:22px;height:22px;}.sidebar-menu-toggle:before{filter:var(--mobile-sidebar-menu-filter);}.sidebar-menu-toggle:hover{background:var(--main-background-color);}.item-table,.item-row,.item-table>li,.item-table>li>div,.search-results>a,.search-results>a>div{display:block;}.search-results>a{padding:5px 0px;}.search-results>a>div.desc,.item-table>li>div.desc{padding-left:2em;}.search-results .result-name{display:block;}.search-results .result-name .typename{width:initial;margin-right:0;}.search-results .result-name .typename,.search-results .result-name .path{display:inline;}.src-sidebar-expanded .src .sidebar{position:fixed;max-width:100vw;width:100vw;}.src .src-sidebar-title{padding-top:0;}details.toggle:not(.top-doc)>summary,.impl-items>section{margin-left:10px;}.impl-items>details.toggle>summary:not(.hideme)::before,#main-content>details.toggle:not(.top-doc)>summary::before,#main-content>div>details.toggle>summary::before{left:-11px;}.impl-items>.item-info{margin-left:34px;}.src nav.sub{margin:0 0 -25px 0;padding:var(--nav-sub-mobile-padding);}}@media (min-width:701px){.scraped-example-title{position:absolute;z-index:10;background:var(--main-background-color);bottom:8px;right:5px;padding:2px 4px;box-shadow:0 0 4px var(--main-background-color);}.item-table>li>.item-name{width:33%;}.item-table>li>div{overflow-wrap:anywhere;}}@media print{nav.sidebar,nav.sub,.out-of-band,a.src,#copy-path,details.toggle[open] >summary::before,details.toggle>summary::before,details.toggle.top-doc>summary{display:none;}.docblock{margin-left:0;}main{padding:10px;}}@media (max-width:464px){.docblock{margin-left:12px;}.docblock code{overflow-wrap:break-word;overflow-wrap:anywhere;}nav.sub{flex-direction:column;}.search-form{align-self:stretch;}}.variant,.implementors-toggle>summary,.impl,#implementors-list>.docblock,.impl-items>section,.impl-items>.toggle>summary,.methods>section,.methods>.toggle>summary{margin-bottom:0.75em;}.variants>.docblock,.implementors-toggle>.docblock,.impl-items>.toggle[open]:not(:last-child),.methods>.toggle[open]:not(:last-child),.implementors-toggle[open]:not(:last-child){margin-bottom:2em;}#trait-implementations-list .impl-items>.toggle:not(:last-child),#synthetic-implementations-list .impl-items>.toggle:not(:last-child),#blanket-implementations-list .impl-items>.toggle:not(:last-child){margin-bottom:1em;}.scraped-example-list .scrape-help{margin-left:10px;padding:0 4px;font-weight:normal;font-size:12px;position:relative;bottom:1px;border:1px solid var(--scrape-example-help-border-color);border-radius:50px;color:var(--scrape-example-help-color);}.scraped-example-list .scrape-help:hover{border-color:var(--scrape-example-help-hover-border-color);color:var(--scrape-example-help-hover-color);}.scraped-example:not(.expanded) .example-wrap::before,.scraped-example:not(.expanded) .example-wrap::after{content:" ";width:100%;height:5px;position:absolute;z-index:1;}.scraped-example:not(.expanded) .example-wrap::before{top:0;background:linear-gradient(to bottom,var(--scrape-example-code-wrapper-background-start),var(--scrape-example-code-wrapper-background-end));}.scraped-example:not(.expanded) .example-wrap::after{bottom:0;background:linear-gradient(to top,var(--scrape-example-code-wrapper-background-start),var(--scrape-example-code-wrapper-background-end));}.scraped-example:not(.expanded){width:100%;overflow-y:hidden;margin-bottom:0;}.scraped-example:not(.expanded){overflow-x:hidden;}.scraped-example .rust span.highlight{background:var(--scrape-example-code-line-highlight);}.scraped-example .rust span.highlight.focus{background:var(--scrape-example-code-line-highlight-focus);}.more-examples-toggle{max-width:calc(100% + 25px);margin-top:10px;margin-left:-25px;}.more-examples-toggle .hide-more{margin-left:25px;cursor:pointer;}.more-scraped-examples{margin-left:25px;position:relative;}.toggle-line{position:absolute;top:5px;bottom:0;right:calc(100% + 10px);padding:0 4px;cursor:pointer;}.toggle-line-inner{min-width:2px;height:100%;background:var(--scrape-example-toggle-line-background);}.toggle-line:hover .toggle-line-inner{background:var(--scrape-example-toggle-line-hover-background);}.more-scraped-examples .scraped-example,.example-links{margin-top:20px;}.more-scraped-examples .scraped-example:first-child{margin-top:5px;}.example-links ul{margin-bottom:0;}:root[data-theme="light"],:root:not([data-theme]){--main-background-color:white;--main-color:black;--settings-input-color:#2196f3;--settings-input-border-color:#717171;--settings-button-color:#000;--settings-button-border-focus:#717171;--sidebar-background-color:#f5f5f5;--sidebar-background-color-hover:#e0e0e0;--code-block-background-color:#f5f5f5;--scrollbar-track-background-color:#dcdcdc;--scrollbar-thumb-background-color:rgba(36,37,39,0.6);--scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;--headings-border-bottom-color:#ddd;--border-color:#e0e0e0;--button-background-color:#fff;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:none;--mobile-sidebar-menu-filter:none;--search-input-focused-border-color:#66afe9;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(35%);--code-example-button-color:#7f7f7f;--code-example-button-hover-color:#595959;--settings-menu-filter:invert(50%);--settings-menu-hover-filter:invert(35%);--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ad378a;--trait-link-color:#6e4fc9;--assoc-item-link-color:#3873ad;--function-link-color:#ad7c37;--macro-link-color:#068000;--keyword-link-color:#3873ad;--mod-link-color:#3873ad;--link-color:#3873ad;--sidebar-link-color:#356da4;--sidebar-current-link-background-color:#fff;--search-result-link-focus-background-color:#ccc;--search-result-border-color:#aaa3;--search-color:#000;--search-error-code-background-color:#d0cccc;--search-results-alias-color:#000;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#e6e6e6;--search-tab-button-not-selected-background:#e6e6e6;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#fff;--stab-background-color:#fff5d6;--stab-code-color:#000;--code-highlight-kw-color:#8959a8;--code-highlight-kw-2-color:#4271ae;--code-highlight-lifetime-color:#b76514;--code-highlight-prelude-color:#4271ae;--code-highlight-prelude-val-color:#c82829;--code-highlight-number-color:#718c00;--code-highlight-string-color:#718c00;--code-highlight-literal-color:#c82829;--code-highlight-attribute-color:#c82829;--code-highlight-self-color:#c82829;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8e908c;--code-highlight-doc-comment-color:#4d4d4c;--src-line-numbers-span-color:#c67e2d;--src-line-number-highlighted-background-color:#fdffd3;--target-background-color:#fdffd3;--target-border-color:#ad7c37;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:initial;--crate-search-div-filter:invert(100%) sepia(0%) saturate(4223%) hue-rotate(289deg) brightness(114%) contrast(76%);--crate-search-div-hover-filter:invert(44%) sepia(18%) saturate(23%) hue-rotate(317deg) brightness(96%) contrast(93%);--crate-search-hover-border:#717171;--src-sidebar-background-selected:#fff;--src-sidebar-background-hover:#e0e0e0;--table-alt-row-background-color:#f5f5f5;--codeblock-link-background:#eee;--scrape-example-toggle-line-background:#ccc;--scrape-example-toggle-line-hover-background:#999;--scrape-example-code-line-highlight:#fcffd6;--scrape-example-code-line-highlight-focus:#f6fdb0;--scrape-example-help-border-color:#555;--scrape-example-help-color:#333;--scrape-example-help-hover-border-color:#000;--scrape-example-help-hover-color:#000;--scrape-example-code-wrapper-background-start:rgba(255,255,255,1);--scrape-example-code-wrapper-background-end:rgba(255,255,255,0);--sidebar-resizer-hover:hsl(207,90%,66%);--sidebar-resizer-active:hsl(207,90%,54%);}:root[data-theme="dark"]{--main-background-color:#353535;--main-color:#ddd;--settings-input-color:#2196f3;--settings-input-border-color:#999;--settings-button-color:#000;--settings-button-border-focus:#ffb900;--sidebar-background-color:#505050;--sidebar-background-color-hover:#676767;--code-block-background-color:#2A2A2A;--scrollbar-track-background-color:#717171;--scrollbar-thumb-background-color:rgba(32,34,37,.6);--scrollbar-color:rgba(32,34,37,.6) #5a5a5a;--headings-border-bottom-color:#d2d2d2;--border-color:#e0e0e0;--button-background-color:#f0f0f0;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--mobile-sidebar-menu-filter:invert(100%);--search-input-focused-border-color:#008dfd;--copy-path-button-color:#999;--copy-path-img-filter:invert(50%);--copy-path-img-hover-filter:invert(65%);--code-example-button-color:#7f7f7f;--code-example-button-hover-color:#a5a5a5;--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#2dbfb8;--trait-link-color:#b78cf2;--assoc-item-link-color:#d2991d;--function-link-color:#2bab63;--macro-link-color:#09bd00;--keyword-link-color:#d2991d;--mod-link-color:#d2991d;--link-color:#d2991d;--sidebar-link-color:#fdbf35;--sidebar-current-link-background-color:#444;--search-result-link-focus-background-color:#616161;--search-result-border-color:#aaa3;--search-color:#111;--search-error-code-background-color:#484848;--search-results-alias-color:#fff;--search-results-grey-color:#ccc;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:#252525;--search-tab-button-not-selected-background:#252525;--search-tab-button-selected-border-top-color:#0089ff;--search-tab-button-selected-background:#353535;--settings-menu-filter:invert(50%);--settings-menu-hover-filter:invert(65%);--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ab8ac1;--code-highlight-kw-2-color:#769acb;--code-highlight-lifetime-color:#d97f26;--code-highlight-prelude-color:#769acb;--code-highlight-prelude-val-color:#ee6868;--code-highlight-number-color:#83a300;--code-highlight-string-color:#83a300;--code-highlight-literal-color:#ee6868;--code-highlight-attribute-color:#ee6868;--code-highlight-self-color:#ee6868;--code-highlight-macro-color:#3e999f;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#8d8d8b;--code-highlight-doc-comment-color:#8ca375;--src-line-numbers-span-color:#3b91e2;--src-line-number-highlighted-background-color:#0a042f;--target-background-color:#494a3d;--target-border-color:#bb7410;--kbd-color:#000;--kbd-background:#fafbfc;--kbd-box-shadow-color:#c6cbd1;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(94%) sepia(0%) saturate(721%) hue-rotate(255deg) brightness(90%) contrast(90%);--crate-search-div-hover-filter:invert(69%) sepia(60%) saturate(6613%) hue-rotate(184deg) brightness(100%) contrast(91%);--crate-search-hover-border:#2196f3;--src-sidebar-background-selected:#333;--src-sidebar-background-hover:#444;--table-alt-row-background-color:#2a2a2a;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(53,53,53,1);--scrape-example-code-wrapper-background-end:rgba(53,53,53,0);--sidebar-resizer-hover:hsl(207,30%,54%);--sidebar-resizer-active:hsl(207,90%,54%);}:root[data-theme="ayu"]{--main-background-color:#0f1419;--main-color:#c5c5c5;--settings-input-color:#ffb454;--settings-input-border-color:#999;--settings-button-color:#fff;--settings-button-border-focus:#e0e0e0;--sidebar-background-color:#14191f;--sidebar-background-color-hover:rgba(70,70,70,0.33);--code-block-background-color:#191f26;--scrollbar-track-background-color:transparent;--scrollbar-thumb-background-color:#5c6773;--scrollbar-color:#5c6773 #24292f;--headings-border-bottom-color:#5c6773;--border-color:#5c6773;--button-background-color:#141920;--right-side-color:grey;--code-attribute-color:#999;--toggles-color:#999;--toggle-filter:invert(100%);--mobile-sidebar-menu-filter:invert(100%);--search-input-focused-border-color:#5c6773;--copy-path-button-color:#fff;--copy-path-img-filter:invert(70%);--copy-path-img-hover-filter:invert(100%);--code-example-button-color:#b2b2b2;--code-example-button-hover-color:#fff;--codeblock-error-hover-color:rgb(255,0,0);--codeblock-error-color:rgba(255,0,0,.5);--codeblock-ignore-hover-color:rgb(255,142,0);--codeblock-ignore-color:rgba(255,142,0,.6);--warning-border-color:#ff8e00;--type-link-color:#ffa0a5;--trait-link-color:#39afd7;--assoc-item-link-color:#39afd7;--function-link-color:#fdd687;--macro-link-color:#a37acc;--keyword-link-color:#39afd7;--mod-link-color:#39afd7;--link-color:#39afd7;--sidebar-link-color:#53b1db;--sidebar-current-link-background-color:transparent;--search-result-link-focus-background-color:#3c3c3c;--search-result-border-color:#aaa3;--search-color:#fff;--search-error-code-background-color:#4f4c4c;--search-results-alias-color:#c5c5c5;--search-results-grey-color:#999;--search-tab-title-count-color:#888;--search-tab-button-not-selected-border-top-color:none;--search-tab-button-not-selected-background:transparent !important;--search-tab-button-selected-border-top-color:none;--search-tab-button-selected-background:#141920 !important;--settings-menu-filter:invert(70%);--settings-menu-hover-filter:invert(100%);--stab-background-color:#314559;--stab-code-color:#e6e1cf;--code-highlight-kw-color:#ff7733;--code-highlight-kw-2-color:#ff7733;--code-highlight-lifetime-color:#ff7733;--code-highlight-prelude-color:#69f2df;--code-highlight-prelude-val-color:#ff7733;--code-highlight-number-color:#b8cc52;--code-highlight-string-color:#b8cc52;--code-highlight-literal-color:#ff7733;--code-highlight-attribute-color:#e6e1cf;--code-highlight-self-color:#36a3d9;--code-highlight-macro-color:#a37acc;--code-highlight-question-mark-color:#ff9011;--code-highlight-comment-color:#788797;--code-highlight-doc-comment-color:#a1ac88;--src-line-numbers-span-color:#5c6773;--src-line-number-highlighted-background-color:rgba(255,236,164,0.06);--target-background-color:rgba(255,236,164,0.06);--target-border-color:rgba(255,180,76,0.85);--kbd-color:#c5c5c5;--kbd-background:#314559;--kbd-box-shadow-color:#5c6773;--rust-logo-filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);--crate-search-div-filter:invert(41%) sepia(12%) saturate(487%) hue-rotate(171deg) brightness(94%) contrast(94%);--crate-search-div-hover-filter:invert(98%) sepia(12%) saturate(81%) hue-rotate(343deg) brightness(113%) contrast(76%);--crate-search-hover-border:#e0e0e0;--src-sidebar-background-selected:#14191f;--src-sidebar-background-hover:#14191f;--table-alt-row-background-color:#191f26;--codeblock-link-background:#333;--scrape-example-toggle-line-background:#999;--scrape-example-toggle-line-hover-background:#c5c5c5;--scrape-example-code-line-highlight:#5b3b01;--scrape-example-code-line-highlight-focus:#7c4b0f;--scrape-example-help-border-color:#aaa;--scrape-example-help-color:#eee;--scrape-example-help-hover-border-color:#fff;--scrape-example-help-hover-color:#fff;--scrape-example-code-wrapper-background-start:rgba(15,20,25,1);--scrape-example-code-wrapper-background-end:rgba(15,20,25,0);--sidebar-resizer-hover:hsl(34,50%,33%);--sidebar-resizer-active:hsl(34,100%,66%);}:root[data-theme="ayu"] h1,:root[data-theme="ayu"] h2,:root[data-theme="ayu"] h3,:root[data-theme="ayu"] h4,:where(:root[data-theme="ayu"]) h1 a,:root[data-theme="ayu"] .sidebar h2 a,:root[data-theme="ayu"] .sidebar h3 a{color:#fff;}:root[data-theme="ayu"] .docblock code{color:#ffb454;}:root[data-theme="ayu"] .docblock a>code{color:#39AFD7 !important;}:root[data-theme="ayu"] .code-header,:root[data-theme="ayu"] .docblock pre>code,:root[data-theme="ayu"] pre,:root[data-theme="ayu"] pre>code,:root[data-theme="ayu"] .item-info code,:root[data-theme="ayu"] .rustdoc.source .example-wrap{color:#e6e1cf;}:root[data-theme="ayu"] .sidebar .current,:root[data-theme="ayu"] .sidebar .current a,:root[data-theme="ayu"] .sidebar a:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:hover,:root[data-theme="ayu"] details.dir-entry summary:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:focus,:root[data-theme="ayu"] details.dir-entry summary:focus,:root[data-theme="ayu"] #src-sidebar div.files>a.selected{color:#ffb44c;}:root[data-theme="ayu"] .sidebar-elems .location{color:#ff7733;}:root[data-theme="ayu"] .src-line-numbers .line-highlighted{color:#708090;padding-right:7px;border-right:1px solid #ffb44c;}:root[data-theme="ayu"] .search-results a:hover,:root[data-theme="ayu"] .search-results a:focus{color:#fff !important;background-color:#3c3c3c;}:root[data-theme="ayu"] .search-results a{color:#0096cf;}:root[data-theme="ayu"] .search-results a div.desc{color:#c5c5c5;}:root[data-theme="ayu"] .result-name .primitive>i,:root[data-theme="ayu"] .result-name .keyword>i{color:#788797;}:root[data-theme="ayu"] #search-tabs>button.selected{border-bottom:1px solid #ffb44c !important;border-top:none;}:root[data-theme="ayu"] #search-tabs>button:not(.selected){border:none;background-color:transparent !important;}:root[data-theme="ayu"] #search-tabs>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}:root[data-theme="ayu"] #settings-menu>a img,:root[data-theme="ayu"] #sidebar-button>a:before{filter:invert(100);}
\ No newline at end of file
diff --git a/static.files/scrape-examples-46fc985aa763a438.js b/static.files/scrape-examples-46fc985aa763a438.js
new file mode 100644
index 00000000..87b6065d
--- /dev/null
+++ b/static.files/scrape-examples-46fc985aa763a438.js
@@ -0,0 +1 @@
+"use strict";(function(){const DEFAULT_MAX_LINES=5;const HIDDEN_MAX_LINES=10;function scrollToLoc(elt,loc,isHidden){const lines=elt.querySelector(".src-line-numbers > pre");let scrollOffset;const maxLines=isHidden?HIDDEN_MAX_LINES:DEFAULT_MAX_LINES;if(loc[1]-loc[0]>maxLines){const line=Math.max(0,loc[0]-1);scrollOffset=lines.children[line].offsetTop}else{const halfHeight=elt.offsetHeight/2;const offsetTop=lines.children[loc[0]].offsetTop;const lastLine=lines.children[loc[1]];const offsetBot=lastLine.offsetTop+lastLine.offsetHeight;const offsetMid=(offsetTop+offsetBot)/2;scrollOffset=offsetMid-halfHeight}lines.parentElement.scrollTo(0,scrollOffset);elt.querySelector(".rust").scrollTo(0,scrollOffset)}function createScrapeButton(parent,className,content){const button=document.createElement("button");button.className=className;button.innerText=content;parent.insertBefore(button,parent.firstChild);return button}window.updateScrapedExample=(example,buttonHolder)=>{let locIndex=0;const highlights=Array.prototype.slice.call(example.querySelectorAll(".highlight"));const link=example.querySelector(".scraped-example-title a");let expandButton=null;if(!example.classList.contains("expanded")){expandButton=createScrapeButton(buttonHolder,"expand","↕")}const isHidden=example.parentElement.classList.contains("more-scraped-examples");const locs=example.locs;if(locs.length>1){const next=createScrapeButton(buttonHolder,"next","≻");const prev=createScrapeButton(buttonHolder,"prev","≺");const onChangeLoc=changeIndex=>{removeClass(highlights[locIndex],"focus");changeIndex();scrollToLoc(example,locs[locIndex][0],isHidden);addClass(highlights[locIndex],"focus");const url=locs[locIndex][1];const title=locs[locIndex][2];link.href=url;link.innerHTML=title};prev.addEventListener("click",()=>{onChangeLoc(()=>{locIndex=(locIndex-1+locs.length)%locs.length})});next.addEventListener("click",()=>{onChangeLoc(()=>{locIndex=(locIndex+1)%locs.length})})}if(expandButton){expandButton.addEventListener("click",()=>{if(hasClass(example,"expanded")){removeClass(example,"expanded");scrollToLoc(example,locs[0][0],isHidden)}else{addClass(example,"expanded")}})}};function setupLoc(example,isHidden){example.locs=JSON.parse(example.attributes.getNamedItem("data-locs").textContent);scrollToLoc(example,example.locs[0][0],isHidden)}const firstExamples=document.querySelectorAll(".scraped-example-list > .scraped-example");onEachLazy(firstExamples,el=>setupLoc(el,false));onEachLazy(document.querySelectorAll(".more-examples-toggle"),toggle=>{onEachLazy(toggle.querySelectorAll(".toggle-line, .hide-more"),button=>{button.addEventListener("click",()=>{toggle.open=false})});const moreExamples=toggle.querySelectorAll(".scraped-example");toggle.querySelector("summary").addEventListener("click",()=>{setTimeout(()=>{onEachLazy(moreExamples,el=>setupLoc(el,true))})},{once:true})})})()
\ No newline at end of file
diff --git a/static.files/search-f0d225181b97f9a4.js b/static.files/search-f0d225181b97f9a4.js
new file mode 100644
index 00000000..d34fb34c
--- /dev/null
+++ b/static.files/search-f0d225181b97f9a4.js
@@ -0,0 +1,6 @@
+"use strict";if(!Array.prototype.toSpliced){Array.prototype.toSpliced=function(){const me=this.slice();Array.prototype.splice.apply(me,arguments);return me}}(function(){const itemTypes=["keyword","primitive","mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","associatedtype","constant","associatedconstant","union","foreigntype","existential","attr","derive","traitalias","generic",];const TY_GENERIC=itemTypes.indexOf("generic");const TY_IMPORT=itemTypes.indexOf("import");const ROOT_PATH=typeof window!=="undefined"?window.rootPath:"../";const UNBOXING_LIMIT=5;const REGEX_IDENT=/\p{ID_Start}\p{ID_Continue}*|_\p{ID_Continue}+/uy;const REGEX_INVALID_TYPE_FILTER=/[^a-z]/ui;const MAX_RESULTS=200;const NO_TYPE_FILTER=-1;const editDistanceState={current:[],prev:[],prevPrev:[],calculate:function calculate(a,b,limit){if(a.lengthlimit){return limit+1}while(b.length>0&&b[0]===a[0]){a=a.substring(1);b=b.substring(1)}while(b.length>0&&b[b.length-1]===a[a.length-1]){a=a.substring(0,a.length-1);b=b.substring(0,b.length-1)}if(b.length===0){return minDist}const aLength=a.length;const bLength=b.length;for(let i=0;i<=bLength;++i){this.current[i]=0;this.prev[i]=i;this.prevPrev[i]=Number.MAX_VALUE}for(let i=1;i<=aLength;++i){this.current[0]=i;const aIdx=i-1;for(let j=1;j<=bLength;++j){const bIdx=j-1;const substitutionCost=a[aIdx]===b[bIdx]?0:1;this.current[j]=Math.min(this.prev[j]+1,this.current[j-1]+1,this.prev[j-1]+substitutionCost,);if((i>1)&&(j>1)&&(a[aIdx]===b[bIdx-1])&&(a[aIdx-1]===b[bIdx])){this.current[j]=Math.min(this.current[j],this.prevPrev[j-2]+1,)}}const prevPrevTmp=this.prevPrev;this.prevPrev=this.prev;this.prev=this.current;this.current=prevPrevTmp}const distance=this.prev[bLength];return distance<=limit?distance:(limit+1)},};function editDistance(a,b,limit){return editDistanceState.calculate(a,b,limit)}function isEndCharacter(c){return"=,>-])".indexOf(c)!==-1}function isSeparatorCharacter(c){return c===","||c==="="}function isReturnArrow(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="->"}function skipWhitespace(parserState){while(parserState.pos0){const c=parserState.userQuery[pos-1];if(c===lookingFor){return true}else if(c!==" "){break}pos-=1}return false}function isLastElemGeneric(elems,parserState){return(elems.length>0&&elems[elems.length-1].generics.length>0)||prevIs(parserState,">")}function getFilteredNextElem(query,parserState,elems,isInGenerics){const start=parserState.pos;if(parserState.userQuery[parserState.pos]===":"&&!isPathStart(parserState)){throw["Expected type filter before ",":"]}getNextElem(query,parserState,elems,isInGenerics);if(parserState.userQuery[parserState.pos]===":"&&!isPathStart(parserState)){if(parserState.typeFilter!==null){throw["Unexpected ",":"," (expected path after type filter ",parserState.typeFilter+":",")",]}if(elems.length===0){throw["Expected type filter before ",":"]}else if(query.literalSearch){throw["Cannot use quotes on type filter"]}const typeFilterElem=elems.pop();checkExtraTypeFilterCharacters(start,parserState);parserState.typeFilter=typeFilterElem.name;parserState.pos+=1;parserState.totalElems-=1;query.literalSearch=false;getNextElem(query,parserState,elems,isInGenerics)}}function getItemsBefore(query,parserState,elems,endChar){let foundStopChar=true;let foundSeparator=false;const oldTypeFilter=parserState.typeFilter;parserState.typeFilter=null;const oldIsInBinding=parserState.isInBinding;parserState.isInBinding=null;let hofParameters=null;let extra="";if(endChar===">"){extra="<"}else if(endChar==="]"){extra="["}else if(endChar===")"){extra="("}else if(endChar===""){extra="->"}else{extra=endChar}while(parserState.pos"," after ","="]}hofParameters=[...elems];elems.length=0;parserState.pos+=2;foundStopChar=true;foundSeparator=false;continue}else if(c===" "){parserState.pos+=1;continue}else if(isSeparatorCharacter(c)){parserState.pos+=1;foundStopChar=true;foundSeparator=true;continue}else if(c===":"&&isPathStart(parserState)){throw["Unexpected ","::",": paths cannot start with ","::"]}else if(isEndCharacter(c)){throw["Unexpected ",c," after ",extra]}if(!foundStopChar){let extra=[];if(isLastElemGeneric(query.elems,parserState)){extra=[" after ",">"]}else if(prevIs(parserState,"\"")){throw["Cannot have more than one element if you use quotes"]}if(endChar!==""){throw["Expected ",",",", ","=",", or ",endChar,...extra,", found ",c,]}throw["Expected ",","," or ","=",...extra,", found ",c,]}const posBefore=parserState.pos;getFilteredNextElem(query,parserState,elems,endChar!=="");if(endChar!==""&&parserState.pos>=parserState.length){throw["Unclosed ",extra]}if(posBefore===parserState.pos){parserState.pos+=1}foundStopChar=false}if(parserState.pos>=parserState.length&&endChar!==""){throw["Unclosed ",extra]}parserState.pos+=1;if(hofParameters){foundSeparator=false;if([...elems,...hofParameters].some(x=>x.bindingName)||parserState.isInBinding){throw["Unexpected ","="," within ","->"]}const hofElem=makePrimitiveElement("->",{generics:hofParameters,bindings:new Map([["output",[...elems]]]),typeFilter:null,});elems.length=0;elems[0]=hofElem}parserState.typeFilter=oldTypeFilter;parserState.isInBinding=oldIsInBinding;return{foundSeparator}}function getNextElem(query,parserState,elems,isInGenerics){const generics=[];skipWhitespace(parserState);let start=parserState.pos;let end;if("[(".indexOf(parserState.userQuery[parserState.pos])!==-1){let endChar=")";let name="()";let friendlyName="tuple";if(parserState.userQuery[parserState.pos]==="["){endChar="]";name="[]";friendlyName="slice"}parserState.pos+=1;const{foundSeparator}=getItemsBefore(query,parserState,generics,endChar);const typeFilter=parserState.typeFilter;const bindingName=parserState.isInBinding;parserState.typeFilter=null;parserState.isInBinding=null;for(const gen of generics){if(gen.bindingName!==null){throw["Type parameter ","=",` cannot be within ${friendlyName} `,name]}}if(name==="()"&&!foundSeparator&&generics.length===1&&typeFilter===null){elems.push(generics[0])}else if(name==="()"&&generics.length===1&&generics[0].name==="->"){generics[0].typeFilter=typeFilter;elems.push(generics[0])}else{if(typeFilter!==null&&typeFilter!=="primitive"){throw["Invalid search type: primitive ",name," and ",typeFilter," both specified",]}parserState.totalElems+=1;if(isInGenerics){parserState.genericsElems+=1}elems.push(makePrimitiveElement(name,{bindingName,generics}))}}else if(parserState.userQuery[parserState.pos]==="&"){if(parserState.typeFilter!==null&&parserState.typeFilter!=="primitive"){throw["Invalid search type: primitive ","&"," and ",parserState.typeFilter," both specified",]}parserState.typeFilter=null;parserState.pos+=1;let c=parserState.userQuery[parserState.pos];while(c===" "&&parserState.pos=end){throw["Found generics without a path"]}parserState.pos+=1;getItemsBefore(query,parserState,generics,">")}else if(parserState.pos=end){throw["Found generics without a path"]}if(parserState.isInBinding){throw["Unexpected ","("," after ","="]}parserState.pos+=1;const typeFilter=parserState.typeFilter;parserState.typeFilter=null;getItemsBefore(query,parserState,generics,")");skipWhitespace(parserState);if(isReturnArrow(parserState)){parserState.pos+=2;skipWhitespace(parserState);getFilteredNextElem(query,parserState,generics,isInGenerics);generics[generics.length-1].bindingName=makePrimitiveElement("output")}else{generics.push(makePrimitiveElement(null,{bindingName:makePrimitiveElement("output"),typeFilter:null,}))}parserState.typeFilter=typeFilter}if(isStringElem){skipWhitespace(parserState)}if(start>=end&&generics.length===0){return}if(parserState.userQuery[parserState.pos]==="="){if(parserState.isInBinding){throw["Cannot write ","="," twice in a binding"]}if(!isInGenerics){throw["Type parameter ","="," must be within generics list"]}const name=parserState.userQuery.slice(start,end).trim();if(name==="!"){throw["Type parameter ","="," key cannot be ","!"," never type"]}if(name.includes("!")){throw["Type parameter ","="," key cannot be ","!"," macro"]}if(name.includes("::")){throw["Type parameter ","="," key cannot contain ","::"," path"]}if(name.includes(":")){throw["Type parameter ","="," key cannot contain ",":"," type"]}parserState.isInBinding={name,generics}}else{elems.push(createQueryElement(query,parserState,parserState.userQuery.slice(start,end),generics,isInGenerics,),)}}}function checkExtraTypeFilterCharacters(start,parserState){const query=parserState.userQuery.slice(start,parserState.pos).trim();const match=query.match(REGEX_INVALID_TYPE_FILTER);if(match){throw["Unexpected ",match[0]," in type filter (before ",":",")",]}}function createQueryElement(query,parserState,name,generics,isInGenerics){const path=name.trim();if(path.length===0&&generics.length===0){throw["Unexpected ",parserState.userQuery[parserState.pos]]}if(query.literalSearch&&parserState.totalElems-parserState.genericsElems>0){throw["Cannot have more than one element if you use quotes"]}const typeFilter=parserState.typeFilter;parserState.typeFilter=null;if(name.trim()==="!"){if(typeFilter!==null&&typeFilter!=="primitive"){throw["Invalid search type: primitive never type ","!"," and ",typeFilter," both specified",]}if(generics.length!==0){throw["Never type ","!"," does not accept generic parameters",]}const bindingName=parserState.isInBinding;parserState.isInBinding=null;return makePrimitiveElement("never",{bindingName})}const quadcolon=/::\s*::/.exec(path);if(path.startsWith("::")){throw["Paths cannot start with ","::"]}else if(path.endsWith("::")){throw["Paths cannot end with ","::"]}else if(quadcolon!==null){throw["Unexpected ",quadcolon[0]]}const pathSegments=path.split(/(?:::\s*)|(?:\s+(?:::\s*)?)/);if(pathSegments.length===0||(pathSegments.length===1&&pathSegments[0]==="")){if(generics.length>0||prevIs(parserState,">")){throw["Found generics without a path"]}else{throw["Unexpected ",parserState.userQuery[parserState.pos]]}}for(const[i,pathSegment]of pathSegments.entries()){if(pathSegment==="!"){if(i!==0){throw["Never type ","!"," is not associated item"]}pathSegments[i]="never"}}parserState.totalElems+=1;if(isInGenerics){parserState.genericsElems+=1}const bindingName=parserState.isInBinding;parserState.isInBinding=null;const bindings=new Map();const pathLast=pathSegments[pathSegments.length-1];return{name:name.trim(),id:null,fullPath:pathSegments,pathWithoutLast:pathSegments.slice(0,pathSegments.length-1),pathLast,normalizedPathLast:pathLast.replace(/_/g,""),generics:generics.filter(gen=>{if(gen.bindingName!==null){if(gen.name!==null){gen.bindingName.generics.unshift(gen)}bindings.set(gen.bindingName.name,gen.bindingName.generics);return false}return true}),bindings,typeFilter,bindingName,}}function makePrimitiveElement(name,extra){return Object.assign({name,id:null,fullPath:[name],pathWithoutLast:[],pathLast:name,normalizedPathLast:name,generics:[],bindings:new Map(),typeFilter:"primitive",bindingName:null,},extra)}function getStringElem(query,parserState,isInGenerics){if(isInGenerics){throw["Unexpected ","\""," in generics"]}else if(query.literalSearch){throw["Cannot have more than one literal search element"]}else if(parserState.totalElems-parserState.genericsElems>0){throw["Cannot use literal search when there is more than one element"]}parserState.pos+=1;const start=parserState.pos;const end=getIdentEndPosition(parserState);if(parserState.pos>=parserState.length){throw["Unclosed ","\""]}else if(parserState.userQuery[end]!=="\""){throw["Unexpected ",parserState.userQuery[end]," in a string element"]}else if(start===end){throw["Cannot have empty string element"]}parserState.pos+=1;query.literalSearch=true}function getIdentEndPosition(parserState){let afterIdent=consumeIdent(parserState);let end=parserState.pos;let macroExclamation=-1;while(parserState.pos0){throw["Unexpected ",c," after ",parserState.userQuery[parserState.pos-1]," (not a valid identifier)"]}else{throw["Unexpected ",c," (not a valid identifier)"]}parserState.pos+=1;afterIdent=consumeIdent(parserState);end=parserState.pos}if(macroExclamation!==-1){if(parserState.typeFilter===null){parserState.typeFilter="macro"}else if(parserState.typeFilter!=="macro"){throw["Invalid search type: macro ","!"," and ",parserState.typeFilter," both specified",]}end=macroExclamation}return end}function isSpecialStartCharacter(c){return"<\"".indexOf(c)!==-1}function isPathStart(parserState){return parserState.userQuery.slice(parserState.pos,parserState.pos+2)==="::"}function consumeIdent(parserState){REGEX_IDENT.lastIndex=parserState.pos;const match=parserState.userQuery.match(REGEX_IDENT);if(match){parserState.pos+=match[0].length;return true}return false}function isPathSeparator(c){return c===":"||c===" "}class VlqHexDecoder{constructor(string,cons){this.string=string;this.cons=cons;this.offset=0;this.backrefQueue=[]}decodeList(){let c=this.string.charCodeAt(this.offset);const ret=[];while(c!==125){ret.push(this.decode());c=this.string.charCodeAt(this.offset)}this.offset+=1;return ret}decode(){let n=0;let c=this.string.charCodeAt(this.offset);if(c===123){this.offset+=1;return this.decodeList()}while(c<96){n=(n<<4)|(c&0xF);this.offset+=1;c=this.string.charCodeAt(this.offset)}n=(n<<4)|(c&0xF);const[sign,value]=[n&1,n>>1];this.offset+=1;return sign?-value:value}next(){const c=this.string.charCodeAt(this.offset);if(c>=48&&c<64){this.offset+=1;return this.backrefQueue[c-48]}if(c===96){this.offset+=1;return this.cons(0)}const result=this.cons(this.decode());this.backrefQueue.unshift(result);if(this.backrefQueue.length>16){this.backrefQueue.pop()}return result}}class RoaringBitmap{constructor(str){const strdecoded=atob(str);const u8array=new Uint8Array(strdecoded.length);for(let j=0;j=4){offsets=[];for(let j=0;j>3]&(1<<(j&0x7))){const runcount=(u8array[i]|(u8array[i+1]<<8));i+=2;this.containers.push(new RoaringBitmapRun(runcount,u8array.slice(i,i+(runcount*4)),));i+=runcount*4}else if(this.cardinalities[j]>=4096){this.containers.push(new RoaringBitmapBits(u8array.slice(i,i+8192)));i+=8192}else{const end=this.cardinalities[j]*2;this.containers.push(new RoaringBitmapArray(this.cardinalities[j],u8array.slice(i,i+end),));i+=end}}}contains(keyvalue){const key=keyvalue>>16;const value=keyvalue&0xFFFF;for(let i=0;i=start&&value<=(start+lenm1)){return true}}return false}}class RoaringBitmapArray{constructor(cardinality,array){this.cardinality=cardinality;this.array=array}contains(value){const l=this.cardinality*2;for(let i=0;i>3]&(1<<(value&7)))}}class DocSearch{constructor(rawSearchIndex,rootPath,searchState){this.searchIndexDeprecated=new Map();this.searchIndexEmptyDesc=new Map();this.functionTypeFingerprint=null;this.typeNameIdMap=new Map();this.ALIASES=new Map();this.rootPath=rootPath;this.searchState=searchState;this.typeNameIdOfArray=this.buildTypeMapIndex("array");this.typeNameIdOfSlice=this.buildTypeMapIndex("slice");this.typeNameIdOfArrayOrSlice=this.buildTypeMapIndex("[]");this.typeNameIdOfTuple=this.buildTypeMapIndex("tuple");this.typeNameIdOfUnit=this.buildTypeMapIndex("unit");this.typeNameIdOfTupleOrUnit=this.buildTypeMapIndex("()");this.typeNameIdOfFn=this.buildTypeMapIndex("fn");this.typeNameIdOfFnMut=this.buildTypeMapIndex("fnmut");this.typeNameIdOfFnOnce=this.buildTypeMapIndex("fnonce");this.typeNameIdOfHof=this.buildTypeMapIndex("->");this.EMPTY_BINDINGS_MAP=new Map();this.EMPTY_GENERICS_ARRAY=[];this.TYPES_POOL=new Map();this.searchIndex=this.buildIndex(rawSearchIndex)}buildTypeMapIndex(name,isAssocType){if(name===""||name===null){return null}if(this.typeNameIdMap.has(name)){const obj=this.typeNameIdMap.get(name);obj.assocOnly=isAssocType&&obj.assocOnly;return obj.id}else{const id=this.typeNameIdMap.size;this.typeNameIdMap.set(name,{id,assocOnly:isAssocType});return id}}buildItemSearchTypeAll(types,lowercasePaths){return types.length>0?types.map(type=>this.buildItemSearchType(type,lowercasePaths)):this.EMPTY_GENERICS_ARRAY}buildItemSearchType(type,lowercasePaths,isAssocType){const PATH_INDEX_DATA=0;const GENERICS_DATA=1;const BINDINGS_DATA=2;let pathIndex,generics,bindings;if(typeof type==="number"){pathIndex=type;generics=this.EMPTY_GENERICS_ARRAY;bindings=this.EMPTY_BINDINGS_MAP}else{pathIndex=type[PATH_INDEX_DATA];generics=this.buildItemSearchTypeAll(type[GENERICS_DATA],lowercasePaths,);if(type.length>BINDINGS_DATA&&type[BINDINGS_DATA].length>0){bindings=new Map(type[BINDINGS_DATA].map(binding=>{const[assocType,constraints]=binding;return[this.buildItemSearchType(assocType,lowercasePaths,true).id,this.buildItemSearchTypeAll(constraints,lowercasePaths),]}))}else{bindings=this.EMPTY_BINDINGS_MAP}}let result;if(pathIndex<0){result={id:pathIndex,ty:TY_GENERIC,path:null,exactPath:null,generics,bindings,}}else if(pathIndex===0){result={id:null,ty:null,path:null,exactPath:null,generics,bindings,}}else{const item=lowercasePaths[pathIndex-1];result={id:this.buildTypeMapIndex(item.name,isAssocType),ty:item.ty,path:item.path,exactPath:item.exactPath,generics,bindings,}}const cr=this.TYPES_POOL.get(result.id);if(cr){if(cr.generics.length===result.generics.length&&cr.generics!==result.generics&&cr.generics.every((x,i)=>result.generics[i]===x)){result.generics=cr.generics}if(cr.bindings.size===result.bindings.size&&cr.bindings!==result.bindings){let ok=true;for(const[k,v]of cr.bindings.entries()){const v2=result.bindings.get(v);if(!v2){ok=false;break}if(v!==v2&&v.length===v2.length&&v.every((x,i)=>v2[i]===x)){result.bindings.set(k,v)}else if(v!==v2){ok=false;break}}if(ok){result.bindings=cr.bindings}}if(cr.ty===result.ty&&cr.path===result.path&&cr.bindings===result.bindings&&cr.generics===result.generics&&cr.ty===result.ty){return cr}}this.TYPES_POOL.set(result.id,result);return result}buildFunctionTypeFingerprint(type,output,fps){let input=type.id;if(input===this.typeNameIdOfArray||input===this.typeNameIdOfSlice){input=this.typeNameIdOfArrayOrSlice}if(input===this.typeNameIdOfTuple||input===this.typeNameIdOfUnit){input=this.typeNameIdOfTupleOrUnit}if(input===this.typeNameIdOfFn||input===this.typeNameIdOfFnMut||input===this.typeNameIdOfFnOnce){input=this.typeNameIdOfHof}const hashint1=k=>{k=(~~k+0x7ed55d16)+(k<<12);k=(k ^ 0xc761c23c)^(k>>>19);k=(~~k+0x165667b1)+(k<<5);k=(~~k+0xd3a2646c)^(k<<9);k=(~~k+0xfd7046c5)+(k<<3);return(k ^ 0xb55a4f09)^(k>>>16)};const hashint2=k=>{k=~k+(k<<15);k ^=k>>>12;k+=k<<2;k ^=k>>>4;k=Math.imul(k,2057);return k ^(k>>16)};if(input!==null){const h0a=hashint1(input);const h0b=hashint2(input);const h1a=~~(h0a+Math.imul(h0b,2));const h1b=~~(h0a+Math.imul(h0b,3));const h2a=~~(h0a+Math.imul(h0b,4));const h2b=~~(h0a+Math.imul(h0b,5));output[0]|=(1<<(h0a%32))|(1<<(h1b%32));output[1]|=(1<<(h1a%32))|(1<<(h2b%32));output[2]|=(1<<(h2a%32))|(1<<(h0b%32));fps.add(input)}for(const g of type.generics){this.buildFunctionTypeFingerprint(g,output,fps)}const fb={id:null,ty:0,generics:this.EMPTY_GENERICS_ARRAY,bindings:this.EMPTY_BINDINGS_MAP,};for(const[k,v]of type.bindings.entries()){fb.id=k;fb.generics=v;this.buildFunctionTypeFingerprint(fb,output,fps)}output[3]=fps.size}buildIndex(rawSearchIndex){const buildFunctionSearchTypeCallback=lowercasePaths=>{return functionSearchType=>{if(functionSearchType===0){return null}const INPUTS_DATA=0;const OUTPUT_DATA=1;let inputs,output;if(typeof functionSearchType[INPUTS_DATA]==="number"){inputs=[this.buildItemSearchType(functionSearchType[INPUTS_DATA],lowercasePaths),]}else{inputs=this.buildItemSearchTypeAll(functionSearchType[INPUTS_DATA],lowercasePaths,)}if(functionSearchType.length>1){if(typeof functionSearchType[OUTPUT_DATA]==="number"){output=[this.buildItemSearchType(functionSearchType[OUTPUT_DATA],lowercasePaths,),]}else{output=this.buildItemSearchTypeAll(functionSearchType[OUTPUT_DATA],lowercasePaths,)}}else{output=[]}const where_clause=[];const l=functionSearchType.length;for(let i=2;inoop);let descShard={crate,shard:0,start:0,len:itemDescShardDecoder.next(),promise:null,resolve:null,};const descShardList=[descShard];this.searchIndexDeprecated.set(crate,new RoaringBitmap(crateCorpus.c));this.searchIndexEmptyDesc.set(crate,new RoaringBitmap(crateCorpus.e));let descIndex=0;const crateRow={crate,ty:3,name:crate,path:"",descShard,descIndex,exactPath:"",desc:crateCorpus.doc,parent:undefined,type:null,id,word:crate,normalizedName:crate.indexOf("_")===-1?crate:crate.replace(/_/g,""),bitIndex:0,implDisambiguator:null,};id+=1;searchIndex.push(crateRow);currentIndex+=1;if(!this.searchIndexEmptyDesc.get(crate).contains(0)){descIndex+=1}const itemTypes=crateCorpus.t;const itemNames=crateCorpus.n;const itemPaths=new Map(crateCorpus.q);const itemReexports=new Map(crateCorpus.r);const itemParentIdxDecoder=new VlqHexDecoder(crateCorpus.i,noop=>noop);const implDisambiguator=new Map(crateCorpus.b);const paths=crateCorpus.p;const aliases=crateCorpus.a;const lowercasePaths=[];const itemFunctionDecoder=new VlqHexDecoder(crateCorpus.f,buildFunctionSearchTypeCallback(lowercasePaths),);let len=paths.length;let lastPath=itemPaths.get(0);for(let i=0;i2){path=itemPaths.has(elem[2])?itemPaths.get(elem[2]):lastPath;lastPath=path}const exactPath=elem.length>3?itemPaths.get(elem[3]):path;lowercasePaths.push({ty,name:name.toLowerCase(),path,exactPath});paths[i]={ty,name,path,exactPath}}lastPath="";len=itemTypes.length;let lastName="";let lastWord="";for(let i=0;i=descShard.len&&!this.searchIndexEmptyDesc.get(crate).contains(bitIndex)){descShard={crate,shard:descShard.shard+1,start:descShard.start+descShard.len,len:itemDescShardDecoder.next(),promise:null,resolve:null,};descIndex=0;descShardList.push(descShard)}const name=itemNames[i]===""?lastName:itemNames[i];const word=itemNames[i]===""?lastWord:itemNames[i].toLowerCase();const path=itemPaths.has(i)?itemPaths.get(i):lastPath;const type=itemFunctionDecoder.next();if(type!==null){if(type){const fp=this.functionTypeFingerprint.subarray(id*4,(id+1)*4);const fps=new Set();for(const t of type.inputs){this.buildFunctionTypeFingerprint(t,fp,fps)}for(const t of type.output){this.buildFunctionTypeFingerprint(t,fp,fps)}for(const w of type.where_clause){for(const t of w){this.buildFunctionTypeFingerprint(t,fp,fps)}}}}const itemParentIdx=itemParentIdxDecoder.next();const row={crate,ty:itemTypes.charCodeAt(i)-65,name,path,descShard,descIndex,exactPath:itemReexports.has(i)?itemPaths.get(itemReexports.get(i)):path,parent:itemParentIdx>0?paths[itemParentIdx-1]:undefined,type,id,word,normalizedName:word.indexOf("_")===-1?word:word.replace(/_/g,""),bitIndex,implDisambiguator:implDisambiguator.has(i)?implDisambiguator.get(i):null,};id+=1;searchIndex.push(row);lastPath=row.path;if(!this.searchIndexEmptyDesc.get(crate).contains(bitIndex)){descIndex+=1}lastName=name;lastWord=word}if(aliases){const currentCrateAliases=new Map();this.ALIASES.set(crate,currentCrateAliases);for(const alias_name in aliases){if(!Object.prototype.hasOwnProperty.call(aliases,alias_name)){continue}let currentNameAliases;if(currentCrateAliases.has(alias_name)){currentNameAliases=currentCrateAliases.get(alias_name)}else{currentNameAliases=[];currentCrateAliases.set(alias_name,currentNameAliases)}for(const local_alias of aliases[alias_name]){currentNameAliases.push(local_alias+currentIndex)}}}currentIndex+=itemTypes.length;this.searchState.descShards.set(crate,descShardList)}this.TYPES_POOL=new Map();return searchIndex}static parseQuery(userQuery){function itemTypeFromName(typename){const index=itemTypes.findIndex(i=>i===typename);if(index<0){throw["Unknown type filter ",typename]}return index}function convertTypeFilterOnElem(elem){if(elem.typeFilter!==null){let typeFilter=elem.typeFilter;if(typeFilter==="const"){typeFilter="constant"}elem.typeFilter=itemTypeFromName(typeFilter)}else{elem.typeFilter=NO_TYPE_FILTER}for(const elem2 of elem.generics){convertTypeFilterOnElem(elem2)}for(const constraints of elem.bindings.values()){for(const constraint of constraints){convertTypeFilterOnElem(constraint)}}}function newParsedQuery(userQuery){return{original:userQuery,userQuery:userQuery.toLowerCase(),elems:[],returned:[],foundElems:0,totalElems:0,literalSearch:false,hasReturnArrow:false,error:null,correction:null,proposeCorrectionFrom:null,proposeCorrectionTo:null,typeFingerprint:new Uint32Array(4),}}function parseInput(query,parserState){let foundStopChar=true;while(parserState.pos"){if(isReturnArrow(parserState)){query.hasReturnArrow=true;break}throw["Unexpected ",c," (did you mean ","->","?)"]}else if(parserState.pos>0){throw["Unexpected ",c," after ",parserState.userQuery[parserState.pos-1]]}throw["Unexpected ",c]}else if(c===" "){skipWhitespace(parserState);continue}if(!foundStopChar){let extra="";if(isLastElemGeneric(query.elems,parserState)){extra=[" after ",">"]}else if(prevIs(parserState,"\"")){throw["Cannot have more than one element if you use quotes"]}if(parserState.typeFilter!==null){throw["Expected ",","," or ","->",...extra,", found ",c,]}throw["Expected ",",",", ",":"," or ","->",...extra,", found ",c,]}const before=query.elems.length;getFilteredNextElem(query,parserState,query.elems,false);if(query.elems.length===before){parserState.pos+=1}foundStopChar=false}if(parserState.typeFilter!==null){throw["Unexpected ",":"," (expected path after type filter ",parserState.typeFilter+":",")",]}while(parserState.pos1}query.foundElems=query.elems.length+query.returned.length;query.totalElems=parserState.totalElems;return query}async execQuery(parsedQuery,filterCrates,currentCrate){const results_others=new Map(),results_in_args=new Map(),results_returned=new Map();function createQueryResults(results_in_args,results_returned,results_others,parsedQuery){return{"in_args":results_in_args,"returned":results_returned,"others":results_others,"query":parsedQuery,}}const buildHrefAndPath=item=>{let displayPath;let href;const type=itemTypes[item.ty];const name=item.name;let path=item.path;let exactPath=item.exactPath;if(type==="mod"){displayPath=path+"::";href=this.rootPath+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="import"){displayPath=item.path+"::";href=this.rootPath+item.path.replace(/::/g,"/")+"/index.html#reexport."+name}else if(type==="primitive"||type==="keyword"){displayPath="";href=this.rootPath+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=this.rootPath+name+"/index.html"}else if(item.parent!==undefined){const myparent=item.parent;let anchor=type+"."+name;const parentType=itemTypes[myparent.ty];let pageType=parentType;let pageName=myparent.name;exactPath=`${myparent.exactPath}::${myparent.name}`;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){const enumNameIdx=item.path.lastIndexOf("::");const enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}if(item.implDisambiguator!==null){anchor=item.implDisambiguator+"/"+anchor}href=this.rootPath+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html#"+anchor}else{displayPath=item.path+"::";href=this.rootPath+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href,`${exactPath}::${name}`]};function pathSplitter(path){const tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}const transformResults=results=>{const duplicates=new Set();const out=[];for(const result of results){if(result.id!==-1){const obj=this.searchIndex[result.id];obj.dist=result.dist;const res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=res[2]+"|"+obj.ty;if(duplicates.has(obj.fullPath)){continue}if(obj.ty===TY_IMPORT&&duplicates.has(res[2])){continue}if(duplicates.has(res[2]+"|"+TY_IMPORT)){continue}duplicates.add(obj.fullPath);duplicates.add(res[2]);obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}return out};const sortResults=async(results,isType,preferredCrate)=>{const userQuery=parsedQuery.userQuery;const casedUserQuery=parsedQuery.original;const isMixedCase=casedUserQuery!==userQuery;const result_list=[];for(const result of results.values()){result.item=this.searchIndex[result.id];result.word=this.searchIndex[result.id].word;result_list.push(result)}result_list.sort((aaa,bbb)=>{let a,b;if(isMixedCase){a=(aaa.item.name!==casedUserQuery);b=(bbb.item.name!==casedUserQuery);if(a!==b){return a-b}}a=(aaa.word!==userQuery);b=(bbb.word!==userQuery);if(a!==b){return a-b}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.path_dist;b=bbb.path_dist;if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}a=(aaa.dist);b=(bbb.dist);if(a!==b){return a-b}a=this.searchIndexDeprecated.get(aaa.item.crate).contains(aaa.item.bitIndex);b=this.searchIndexDeprecated.get(bbb.item.crate).contains(bbb.item.bitIndex);if(a!==b){return a-b}a=(aaa.item.crate!==preferredCrate);b=(bbb.item.crate!==preferredCrate);if(a!==b){return a-b}a=aaa.word.length;b=bbb.word.length;if(a!==b){return a-b}a=aaa.word;b=bbb.word;if(a!==b){return(a>b?+1:-1)}a=this.searchIndexEmptyDesc.get(aaa.item.crate).contains(aaa.item.bitIndex);b=this.searchIndexEmptyDesc.get(bbb.item.crate).contains(bbb.item.bitIndex);if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});return transformResults(result_list)};function unifyFunctionTypes(fnTypesIn,queryElems,whereClause,mgensIn,solutionCb,unboxingDepth,){if(unboxingDepth>=UNBOXING_LIMIT){return false}const mgens=mgensIn===null?null:new Map(mgensIn);if(queryElems.length===0){return!solutionCb||solutionCb(mgens)}if(!fnTypesIn||fnTypesIn.length===0){return false}const ql=queryElems.length;const fl=fnTypesIn.length;if(ql===1&&queryElems[0].generics.length===0&&queryElems[0].bindings.size===0){const queryElem=queryElems[0];for(const fnType of fnTypesIn){if(!unifyFunctionTypeIsMatchCandidate(fnType,queryElem,mgens)){continue}if(fnType.id<0&&queryElem.id<0){if(mgens&&mgens.has(fnType.id)&&mgens.get(fnType.id)!==queryElem.id){continue}const mgensScratch=new Map(mgens);mgensScratch.set(fnType.id,queryElem.id);if(!solutionCb||solutionCb(mgensScratch)){return true}}else if(!solutionCb||solutionCb(mgens?new Map(mgens):null)){return true}}for(const fnType of fnTypesIn){if(!unifyFunctionTypeIsUnboxCandidate(fnType,queryElem,whereClause,mgens,unboxingDepth+1,)){continue}if(fnType.id<0){if(mgens&&mgens.has(fnType.id)&&mgens.get(fnType.id)!==0){continue}const mgensScratch=new Map(mgens);mgensScratch.set(fnType.id,0);if(unifyFunctionTypes(whereClause[(-fnType.id)-1],queryElems,whereClause,mgensScratch,solutionCb,unboxingDepth+1,)){return true}}else if(unifyFunctionTypes([...fnType.generics,...Array.from(fnType.bindings.values()).flat()],queryElems,whereClause,mgens?new Map(mgens):null,solutionCb,unboxingDepth+1,)){return true}}return false}const fnTypes=fnTypesIn.slice();const flast=fl-1;const qlast=ql-1;const queryElem=queryElems[qlast];let queryElemsTmp=null;for(let i=flast;i>=0;i-=1){const fnType=fnTypes[i];if(!unifyFunctionTypeIsMatchCandidate(fnType,queryElem,mgens)){continue}let mgensScratch;if(fnType.id<0){mgensScratch=new Map(mgens);if(mgensScratch.has(fnType.id)&&mgensScratch.get(fnType.id)!==queryElem.id){continue}mgensScratch.set(fnType.id,queryElem.id)}else{mgensScratch=mgens}fnTypes[i]=fnTypes[flast];fnTypes.length=flast;if(!queryElemsTmp){queryElemsTmp=queryElems.slice(0,qlast)}const passesUnification=unifyFunctionTypes(fnTypes,queryElemsTmp,whereClause,mgensScratch,mgensScratch=>{if(fnType.generics.length===0&&queryElem.generics.length===0&&fnType.bindings.size===0&&queryElem.bindings.size===0){return!solutionCb||solutionCb(mgensScratch)}const solution=unifyFunctionTypeCheckBindings(fnType,queryElem,whereClause,mgensScratch,unboxingDepth,);if(!solution){return false}const simplifiedGenerics=solution.simplifiedGenerics;for(const simplifiedMgens of solution.mgens){const passesUnification=unifyFunctionTypes(simplifiedGenerics,queryElem.generics,whereClause,simplifiedMgens,solutionCb,unboxingDepth,);if(passesUnification){return true}}return false},unboxingDepth,);if(passesUnification){return true}fnTypes[flast]=fnTypes[i];fnTypes[i]=fnType;fnTypes.length=fl}for(let i=flast;i>=0;i-=1){const fnType=fnTypes[i];if(!unifyFunctionTypeIsUnboxCandidate(fnType,queryElem,whereClause,mgens,unboxingDepth+1,)){continue}let mgensScratch;if(fnType.id<0){mgensScratch=new Map(mgens);if(mgensScratch.has(fnType.id)&&mgensScratch.get(fnType.id)!==0){continue}mgensScratch.set(fnType.id,0)}else{mgensScratch=mgens}const generics=fnType.id<0?whereClause[(-fnType.id)-1]:fnType.generics;const bindings=fnType.bindings?Array.from(fnType.bindings.values()).flat():[];const passesUnification=unifyFunctionTypes(fnTypes.toSpliced(i,1,...generics,...bindings),queryElems,whereClause,mgensScratch,solutionCb,unboxingDepth+1,);if(passesUnification){return true}}return false}const unifyFunctionTypeIsMatchCandidate=(fnType,queryElem,mgensIn)=>{if(!typePassesFilter(queryElem.typeFilter,fnType.ty)){return false}if(fnType.id<0&&queryElem.id<0){if(mgensIn){if(mgensIn.has(fnType.id)&&mgensIn.get(fnType.id)!==queryElem.id){return false}for(const[fid,qid]of mgensIn.entries()){if(fnType.id!==fid&&queryElem.id===qid){return false}if(fnType.id===fid&&queryElem.id!==qid){return false}}}return true}else{if(queryElem.id===this.typeNameIdOfArrayOrSlice&&(fnType.id===this.typeNameIdOfSlice||fnType.id===this.typeNameIdOfArray)){}else if(queryElem.id===this.typeNameIdOfTupleOrUnit&&(fnType.id===this.typeNameIdOfTuple||fnType.id===this.typeNameIdOfUnit)){}else if(queryElem.id===this.typeNameIdOfHof&&(fnType.id===this.typeNameIdOfFn||fnType.id===this.typeNameIdOfFnMut||fnType.id===this.typeNameIdOfFnOnce)){}else if(fnType.id!==queryElem.id||queryElem.id===null){return false}if((fnType.generics.length+fnType.bindings.size)===0&&queryElem.generics.length!==0){return false}if(fnType.bindings.size0){const fnTypePath=fnType.path!==undefined&&fnType.path!==null?fnType.path.split("::"):[];if(queryElemPathLength>fnTypePath.length){return false}let i=0;for(const path of fnTypePath){if(path===queryElem.pathWithoutLast[i]){i+=1;if(i>=queryElemPathLength){break}}}if(i0){let mgensSolutionSet=[mgensIn];for(const[name,constraints]of queryElem.bindings.entries()){if(mgensSolutionSet.length===0){return false}if(!fnType.bindings.has(name)){return false}const fnTypeBindings=fnType.bindings.get(name);mgensSolutionSet=mgensSolutionSet.flatMap(mgens=>{const newSolutions=[];unifyFunctionTypes(fnTypeBindings,constraints,whereClause,mgens,newMgens=>{newSolutions.push(newMgens);return false},unboxingDepth,);return newSolutions})}if(mgensSolutionSet.length===0){return false}const binds=Array.from(fnType.bindings.entries()).flatMap(entry=>{const[name,constraints]=entry;if(queryElem.bindings.has(name)){return[]}else{return constraints}});if(simplifiedGenerics.length>0){simplifiedGenerics=[...simplifiedGenerics,...binds]}else{simplifiedGenerics=binds}return{simplifiedGenerics,mgens:mgensSolutionSet}}return{simplifiedGenerics,mgens:[mgensIn]}}function unifyFunctionTypeIsUnboxCandidate(fnType,queryElem,whereClause,mgens,unboxingDepth,){if(unboxingDepth>=UNBOXING_LIMIT){return false}if(fnType.id<0&&queryElem.id>=0){if(!whereClause){return false}if(mgens&&mgens.has(fnType.id)&&mgens.get(fnType.id)!==0){return false}const mgensTmp=new Map(mgens);mgensTmp.set(fnType.id,null);return checkIfInList(whereClause[(-fnType.id)-1],queryElem,whereClause,mgensTmp,unboxingDepth,)}else if(fnType.generics.length>0||fnType.bindings.size>0){const simplifiedGenerics=[...fnType.generics,...Array.from(fnType.bindings.values()).flat(),];return checkIfInList(simplifiedGenerics,queryElem,whereClause,mgens,unboxingDepth,)}return false}function checkIfInList(list,elem,whereClause,mgens,unboxingDepth){for(const entry of list){if(checkType(entry,elem,whereClause,mgens,unboxingDepth)){return true}}return false}const checkType=(row,elem,whereClause,mgens,unboxingDepth)=>{if(unboxingDepth>=UNBOXING_LIMIT){return false}if(row.bindings.size===0&&elem.bindings.size===0){if(elem.id<0&&mgens===null){return row.id<0||checkIfInList(row.generics,elem,whereClause,mgens,unboxingDepth+1,)}if(row.id>0&&elem.id>0&&elem.pathWithoutLast.length===0&&typePassesFilter(elem.typeFilter,row.ty)&&elem.generics.length===0&&elem.id!==this.typeNameIdOfArrayOrSlice&&elem.id!==this.typeNameIdOfTupleOrUnit&&elem.id!==this.typeNameIdOfHof){return row.id===elem.id||checkIfInList(row.generics,elem,whereClause,mgens,unboxingDepth,)}}return unifyFunctionTypes([row],[elem],whereClause,mgens,null,unboxingDepth)};function checkPath(contains,ty){if(contains.length===0){return 0}const maxPathEditDistance=Math.floor(contains.reduce((acc,next)=>acc+next.length,0)/3,);let ret_dist=maxPathEditDistance+1;const path=ty.path.split("::");if(ty.parent&&ty.parent.name){path.push(ty.parent.name.toLowerCase())}const length=path.length;const clength=contains.length;pathiter:for(let i=length-clength;i>=0;i-=1){let dist_total=0;for(let x=0;xmaxPathEditDistance){continue pathiter}dist_total+=dist}}ret_dist=Math.min(ret_dist,Math.round(dist_total/clength))}return ret_dist>maxPathEditDistance?null:ret_dist}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER||filter===type)return true;const name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,descShard:item.descShard,descIndex:item.descIndex,exactPath:item.exactPath,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,bitIndex:item.bitIndex,implDisambiguator:item.implDisambiguator,}}const handleAliases=async(ret,query,filterCrates,currentCrate)=>{const lowerQuery=query.toLowerCase();const aliases=[];const crateAliases=[];if(filterCrates!==null){if(this.ALIASES.has(filterCrates)&&this.ALIASES.get(filterCrates).has(lowerQuery)){const query_aliases=this.ALIASES.get(filterCrates).get(lowerQuery);for(const alias of query_aliases){aliases.push(createAliasFromItem(this.searchIndex[alias]))}}}else{for(const[crate,crateAliasesIndex]of this.ALIASES){if(crateAliasesIndex.has(lowerQuery)){const pushTo=crate===currentCrate?crateAliases:aliases;const query_aliases=crateAliasesIndex.get(lowerQuery);for(const alias of query_aliases){pushTo.push(createAliasFromItem(this.searchIndex[alias]))}}}}const sortFunc=(aaa,bbb)=>{if(aaa.path{return this.searchIndexEmptyDesc.get(alias.crate).contains(alias.bitIndex)?"":this.searchState.loadDesc(alias)};const[crateDescs,descs]=await Promise.all([Promise.all(crateAliases.map(fetchDesc)),Promise.all(aliases.map(fetchDesc)),]);const pushFunc=alias=>{alias.alias=query;const res=buildHrefAndPath(alias);alias.displayPath=pathSplitter(res[0]);alias.fullPath=alias.displayPath+alias.name;alias.href=res[1];ret.others.unshift(alias);if(ret.others.length>MAX_RESULTS){ret.others.pop()}};aliases.forEach((alias,i)=>{alias.desc=descs[i]});aliases.forEach(pushFunc);crateAliases.forEach((alias,i)=>{alias.desc=crateDescs[i]});crateAliases.forEach(pushFunc)};function addIntoResults(results,fullId,id,index,dist,path_dist,maxEditDistance){if(dist<=maxEditDistance||index!==-1){if(results.has(fullId)){const result=results.get(fullId);if(result.dontValidate||result.dist<=dist){return}}results.set(fullId,{id:id,index:index,dontValidate:parsedQuery.literalSearch,dist:dist,path_dist:path_dist,})}}function handleSingleArg(row,pos,elem,results_others,results_in_args,results_returned,maxEditDistance,){if(!row||(filterCrates!==null&&row.crate!==filterCrates)){return}let path_dist=0;const fullId=row.id;const tfpDist=compareTypeFingerprints(fullId,parsedQuery.typeFingerprint,);if(tfpDist!==null){const in_args=row.type&&row.type.inputs&&checkIfInList(row.type.inputs,elem,row.type.where_clause,null,0);const returned=row.type&&row.type.output&&checkIfInList(row.type.output,elem,row.type.where_clause,null,0);if(in_args){results_in_args.max_dist=Math.max(results_in_args.max_dist||0,tfpDist);const maxDist=results_in_args.sizenormalizedIndex&&normalizedIndex!==-1)){index=normalizedIndex}if(elem.fullPath.length>1){path_dist=checkPath(elem.pathWithoutLast,row);if(path_dist===null){return}}if(parsedQuery.literalSearch){if(row.word===elem.pathLast){addIntoResults(results_others,fullId,pos,index,0,path_dist)}return}const dist=editDistance(row.normalizedName,elem.normalizedPathLast,maxEditDistance);if(index===-1&&dist>maxEditDistance){return}addIntoResults(results_others,fullId,pos,index,dist,path_dist,maxEditDistance)}function handleArgs(row,pos,results){if(!row||(filterCrates!==null&&row.crate!==filterCrates)||!row.type){return}const tfpDist=compareTypeFingerprints(row.id,parsedQuery.typeFingerprint,);if(tfpDist===null){return}if(results.size>=MAX_RESULTS&&tfpDist>results.max_dist){return}if(!unifyFunctionTypes(row.type.inputs,parsedQuery.elems,row.type.where_clause,null,mgens=>{return unifyFunctionTypes(row.type.output,parsedQuery.returned,row.type.where_clause,mgens,null,0,)},0,)){return}results.max_dist=Math.max(results.max_dist||0,tfpDist);addIntoResults(results,row.id,pos,0,tfpDist,0,Number.MAX_VALUE)}const compareTypeFingerprints=(fullId,queryFingerprint)=>{const fh0=this.functionTypeFingerprint[fullId*4];const fh1=this.functionTypeFingerprint[(fullId*4)+1];const fh2=this.functionTypeFingerprint[(fullId*4)+2];const[qh0,qh1,qh2]=queryFingerprint;const[in0,in1,in2]=[fh0&qh0,fh1&qh1,fh2&qh2];if((in0 ^ qh0)||(in1 ^ qh1)||(in2 ^ qh2)){return null}return this.functionTypeFingerprint[(fullId*4)+3]};const innerRunQuery=()=>{const queryLen=parsedQuery.elems.reduce((acc,next)=>acc+next.pathLast.length,0)+parsedQuery.returned.reduce((acc,next)=>acc+next.pathLast.length,0);const maxEditDistance=Math.floor(queryLen/3);const genericSymbols=new Map();const convertNameToId=(elem,isAssocType)=>{const loweredName=elem.pathLast.toLowerCase();if(this.typeNameIdMap.has(loweredName)&&(isAssocType||!this.typeNameIdMap.get(loweredName).assocOnly)){elem.id=this.typeNameIdMap.get(loweredName).id}else if(!parsedQuery.literalSearch){let match=null;let matchDist=maxEditDistance+1;let matchName="";for(const[name,{id,assocOnly}]of this.typeNameIdMap){const dist=Math.min(editDistance(name,loweredName,maxEditDistance),editDistance(name,elem.normalizedPathLast,maxEditDistance),);if(dist<=matchDist&&dist<=maxEditDistance&&(isAssocType||!assocOnly)){if(dist===matchDist&&matchName>name){continue}match=id;matchDist=dist;matchName=name}}if(match!==null){parsedQuery.correction=matchName}elem.id=match}if((elem.id===null&&parsedQuery.totalElems>1&&elem.typeFilter===-1&&elem.generics.length===0&&elem.bindings.size===0)||elem.typeFilter===TY_GENERIC){if(genericSymbols.has(elem.name)){elem.id=genericSymbols.get(elem.name)}else{elem.id=-(genericSymbols.size+1);genericSymbols.set(elem.name,elem.id)}if(elem.typeFilter===-1&&elem.name.length>=3){const maxPartDistance=Math.floor(elem.name.length/3);let matchDist=maxPartDistance+1;let matchName="";for(const name of this.typeNameIdMap.keys()){const dist=editDistance(name,elem.name,maxPartDistance);if(dist<=matchDist&&dist<=maxPartDistance){if(dist===matchDist&&matchName>name){continue}matchDist=dist;matchName=name}}if(matchName!==""){parsedQuery.proposeCorrectionFrom=elem.name;parsedQuery.proposeCorrectionTo=matchName}}elem.typeFilter=TY_GENERIC}if(elem.generics.length>0&&elem.typeFilter===TY_GENERIC){parsedQuery.error=["Generic type parameter ",elem.name," does not accept generic parameters",]}for(const elem2 of elem.generics){convertNameToId(elem2)}elem.bindings=new Map(Array.from(elem.bindings.entries()).map(entry=>{const[name,constraints]=entry;if(!this.typeNameIdMap.has(name)){parsedQuery.error=["Type parameter ",name," does not exist",];return[null,[]]}for(const elem2 of constraints){convertNameToId(elem2)}return[this.typeNameIdMap.get(name).id,constraints]}),)};const fps=new Set();for(const elem of parsedQuery.elems){convertNameToId(elem);this.buildFunctionTypeFingerprint(elem,parsedQuery.typeFingerprint,fps)}for(const elem of parsedQuery.returned){convertNameToId(elem);this.buildFunctionTypeFingerprint(elem,parsedQuery.typeFingerprint,fps)}if(parsedQuery.foundElems===1&&!parsedQuery.hasReturnArrow){if(parsedQuery.elems.length===1){const elem=parsedQuery.elems[0];const length=this.searchIndex.length;for(let i=0,nSearchIndex=length;i0){const sortQ=(a,b)=>{const ag=a.generics.length===0&&a.bindings.size===0;const bg=b.generics.length===0&&b.bindings.size===0;if(ag!==bg){return ag-bg}const ai=a.id>0;const bi=b.id>0;return ai-bi};parsedQuery.elems.sort(sortQ);parsedQuery.returned.sort(sortQ);for(let i=0,nSearchIndex=this.searchIndex.length;i{const descs=await Promise.all(list.map(result=>{return this.searchIndexEmptyDesc.get(result.crate).contains(result.bitIndex)?"":this.searchState.loadDesc(result)}));for(const[i,result]of list.entries()){result.desc=descs[i]}}));if(parsedQuery.error!==null&&ret.others.length!==0){ret.query.error=null}return ret}}let rawSearchIndex;let docSearch;const longItemTypes=["keyword","primitive type","module","extern crate","re-export","struct","enum","function","type alias","static","trait","","trait method","method","struct field","enum variant","macro","assoc type","constant","assoc const","union","foreign type","existential type","attribute macro","derive macro","trait alias",];let currentResults;function printTab(nb){let iter=0;let foundCurrentTab=false;let foundCurrentResultSet=false;onEachLazy(document.getElementById("search-tabs").childNodes,elem=>{if(nb===iter){addClass(elem,"selected");foundCurrentTab=true}else{removeClass(elem,"selected")}iter+=1});const isTypeSearch=(nb>0||iter===1);iter=0;onEachLazy(document.getElementById("results").childNodes,elem=>{if(nb===iter){addClass(elem,"active");foundCurrentResultSet=true}else{removeClass(elem,"active")}iter+=1});if(foundCurrentTab&&foundCurrentResultSet){searchState.currentTab=nb;const correctionsElem=document.getElementsByClassName("search-corrections");if(isTypeSearch){removeClass(correctionsElem[0],"hidden")}else{addClass(correctionsElem[0],"hidden")}}else if(nb!==0){printTab(0)}}function buildUrl(search,filterCrates){let extra="?search="+encodeURIComponent(search);if(filterCrates!==null){extra+="&filter-crate="+encodeURIComponent(filterCrates)}return getNakedUrl()+extra+window.location.hash}function getFilterCrates(){const elem=document.getElementById("crate-search");if(elem&&elem.value!=="all crates"&&window.searchIndex.has(elem.value)){return elem.value}return null}function nextTab(direction){const next=(searchState.currentTab+direction+3)%searchState.focusedByTab.length;searchState.focusedByTab[searchState.currentTab]=document.activeElement;printTab(next);focusSearchResult()}function focusSearchResult(){const target=searchState.focusedByTab[searchState.currentTab]||document.querySelectorAll(".search-results.active a").item(0)||document.querySelectorAll("#search-tabs button").item(searchState.currentTab);searchState.focusedByTab[searchState.currentTab]=null;if(target){target.focus()}}async function addTab(array,query,display){const extraClass=display?" active":"";const output=document.createElement("div");if(array.length>0){output.className="search-results "+extraClass;for(const item of array){const name=item.name;const type=itemTypes[item.ty];const longType=longItemTypes[item.ty];const typeName=longType.length!==0?`${longType}`:"?";const link=document.createElement("a");link.className="result-"+type;link.href=item.href;const resultName=document.createElement("div");resultName.className="result-name";resultName.insertAdjacentHTML("beforeend",`${typeName}`);link.appendChild(resultName);let alias=" ";if(item.is_alias){alias=` 
\
+${item.alias} - see \
+
`}resultName.insertAdjacentHTML("beforeend",`
${alias}\
+${item.displayPath}${name}\
+
`);const description=document.createElement("div");description.className="desc";description.insertAdjacentHTML("beforeend",item.desc);link.appendChild(description);output.appendChild(link)}}else if(query.error===null){output.className="search-failed"+extraClass;output.innerHTML="No results :(
"+"Try on DuckDuckGo?

"+"Or try looking in one of these:"}return[output,array.length]}function makeTabHeader(tabNb,text,nbElems){const fmtNbElems=nbElems<10?`\u{2007}(${nbElems})\u{2007}\u{2007}`:nbElems<100?`\u{2007}(${nbElems})\u{2007}`:`\u{2007}(${nbElems})`;if(searchState.currentTab===tabNb){return""}return""}async function showResults(results,go_to_first,filterCrates){const search=searchState.outputElement();if(go_to_first||(results.others.length===1&&getSettingValue("go-to-only-result")==="true")){window.onunload=()=>{};searchState.removeQueryParameters();const elem=document.createElement("a");elem.href=results.others[0].href;removeClass(elem,"active");document.body.appendChild(elem);elem.click();return}if(results.query===undefined){results.query=DocSearch.parseQuery(searchState.input.value)}currentResults=results.query.userQuery;const[ret_others,ret_in_args,ret_returned]=await Promise.all([addTab(results.others,results.query,true),addTab(results.in_args,results.query,false),addTab(results.returned,results.query,false),]);let currentTab=searchState.currentTab;if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}let crates="";if(rawSearchIndex.size>1){crates="
 in 
"+"
"}let output=`
\
+        
Results
${crates}
`;if(results.query.error!==null){const error=results.query.error;error.forEach((value,index)=>{value=value.split("<").join("<").split(">").join(">");if(index%2!==0){error[index]=`${value.replaceAll(" ", " ")}`}else{error[index]=value}});output+=`
Query parser error: "${error.join("")}".
`;output+="
"+makeTabHeader(0,"In Names",ret_others[1])+"
";currentTab=0}else if(results.query.foundElems<=1&&results.query.returned.length===0){output+="
"+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
"}else{const signatureTabTitle=results.query.elems.length===0?"In Function Return Types":results.query.returned.length===0?"In Function Parameters":"In Function Signatures";output+="
"+makeTabHeader(0,signatureTabTitle,ret_others[1])+"
";currentTab=0}if(results.query.correction!==null){const orig=results.query.returned.length>0?results.query.returned[0].name:results.query.elems[0].name;output+="
"+`Type "${orig}" not found. `+"Showing results for closest type name "+`"${results.query.correction}" instead.
`}if(results.query.proposeCorrectionFrom!==null){const orig=results.query.proposeCorrectionFrom;const targ=results.query.proposeCorrectionTo;output+="
"+`Type "${orig}" not found and used as generic parameter. `+`Consider searching for "${targ}" instead.
`}const resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;if(searchState.rustdocToolbar){search.querySelector(".main-heading").appendChild(searchState.rustdocToolbar)}const crateSearch=document.getElementById("crate-search");if(crateSearch){crateSearch.addEventListener("input",updateCrate)}search.appendChild(resultsElem);searchState.showResults(search);const elems=document.getElementById("search-tabs").childNodes;searchState.focusedByTab=[];let i=0;for(const elem of elems){const j=i;elem.onclick=()=>printTab(j);searchState.focusedByTab.push(null);i+=1}printTab(currentTab)}function updateSearchHistory(url){if(!browserSupportsHistoryApi()){return}const params=searchState.getQueryStringParams();if(!history.state&&!params.search){history.pushState(null,"",url)}else{history.replaceState(null,"",url)}}async function search(forced){const query=DocSearch.parseQuery(searchState.input.value.trim());let filterCrates=getFilterCrates();if(!forced&&query.userQuery===currentResults){if(query.userQuery.length>0){putBackSearch()}return}searchState.setLoadingSearch();const params=searchState.getQueryStringParams();if(filterCrates===null&¶ms["filter-crate"]!==undefined){filterCrates=params["filter-crate"]}searchState.title="\""+query.original+"\" Search - Rust";updateSearchHistory(buildUrl(query.original,filterCrates));await showResults(await docSearch.execQuery(query,filterCrates,window.currentCrate),params.go_to_first,filterCrates)}function onSearchSubmit(e){e.preventDefault();searchState.clearInputTimeout();search()}function putBackSearch(){const search_input=searchState.input;if(!searchState.input){return}if(search_input.value!==""&&!searchState.isDisplayed()){searchState.showResults();if(browserSupportsHistoryApi()){history.replaceState(null,"",buildUrl(search_input.value,getFilterCrates()))}document.title=searchState.title}}function registerSearchEvents(){const params=searchState.getQueryStringParams();if(searchState.input.value===""){searchState.input.value=params.search||""}const searchAfter500ms=()=>{searchState.clearInputTimeout();if(searchState.input.value.length===0){searchState.hideResults()}else{searchState.timeout=setTimeout(search,500)}};searchState.input.onkeyup=searchAfter500ms;searchState.input.oninput=searchAfter500ms;document.getElementsByClassName("search-form")[0].onsubmit=onSearchSubmit;searchState.input.onchange=e=>{if(e.target!==document.activeElement){return}searchState.clearInputTimeout();setTimeout(search,0)};searchState.input.onpaste=searchState.input.onchange;searchState.outputElement().addEventListener("keydown",e=>{if(e.altKey||e.ctrlKey||e.shiftKey||e.metaKey){return}if(e.which===38){const previous=document.activeElement.previousElementSibling;if(previous){previous.focus()}else{searchState.focus()}e.preventDefault()}else if(e.which===40){const next=document.activeElement.nextElementSibling;if(next){next.focus()}const rect=document.activeElement.getBoundingClientRect();if(window.innerHeight-rect.bottom{if(e.which===40){focusSearchResult();e.preventDefault()}});searchState.input.addEventListener("focus",()=>{putBackSearch()});searchState.input.addEventListener("blur",()=>{searchState.input.placeholder=searchState.input.origPlaceholder});if(browserSupportsHistoryApi()){const previousTitle=document.title;window.addEventListener("popstate",e=>{const params=searchState.getQueryStringParams();document.title=previousTitle;currentResults=null;if(params.search&¶ms.search.length>0){searchState.input.value=params.search;e.preventDefault();search()}else{searchState.input.value="";searchState.hideResults()}})}window.onpageshow=()=>{const qSearch=searchState.getQueryStringParams().search;if(searchState.input.value===""&&qSearch){searchState.input.value=qSearch}search()}}function updateCrate(ev){if(ev.target.value==="all crates"){const query=searchState.input.value.trim();updateSearchHistory(buildUrl(query,null))}currentResults=null;search(true)}function initSearch(searchIndx){rawSearchIndex=searchIndx;if(typeof window!=="undefined"){docSearch=new DocSearch(rawSearchIndex,ROOT_PATH,searchState);registerSearchEvents();if(window.searchState.getQueryStringParams().search){search()}}else if(typeof exports!=="undefined"){docSearch=new DocSearch(rawSearchIndex,ROOT_PATH,searchState);exports.docSearch=docSearch;exports.parseQuery=DocSearch.parseQuery}}if(typeof exports!=="undefined"){exports.initSearch=initSearch}if(typeof window!=="undefined"){window.initSearch=initSearch;if(window.searchIndex!==undefined){initSearch(window.searchIndex)}}else{initSearch(new Map())}})()
\ No newline at end of file
diff --git a/static.files/settings-805db61a62df4bd2.js b/static.files/settings-805db61a62df4bd2.js
new file mode 100644
index 00000000..4a30479d
--- /dev/null
+++ b/static.files/settings-805db61a62df4bd2.js
@@ -0,0 +1,17 @@
+"use strict";(function(){const isSettingsPage=window.location.pathname.endsWith("/settings.html");function changeSetting(settingName,value){if(settingName==="theme"){const useSystem=value==="system preference"?"true":"false";updateLocalStorage("use-system-theme",useSystem)}updateLocalStorage(settingName,value);switch(settingName){case"theme":case"preferred-dark-theme":case"preferred-light-theme":updateTheme();updateLightAndDark();break;case"line-numbers":if(value===true){window.rustdoc_add_line_numbers_to_examples()}else{window.rustdoc_remove_line_numbers_from_examples()}break;case"hide-sidebar":if(value===true){addClass(document.documentElement,"hide-sidebar")}else{removeClass(document.documentElement,"hide-sidebar")}break;case"hide-toc":if(value===true){addClass(document.documentElement,"hide-toc")}else{removeClass(document.documentElement,"hide-toc")}break;case"hide-modnav":if(value===true){addClass(document.documentElement,"hide-modnav")}else{removeClass(document.documentElement,"hide-modnav")}break}}function showLightAndDark(){removeClass(document.getElementById("preferred-light-theme"),"hidden");removeClass(document.getElementById("preferred-dark-theme"),"hidden")}function hideLightAndDark(){addClass(document.getElementById("preferred-light-theme"),"hidden");addClass(document.getElementById("preferred-dark-theme"),"hidden")}function updateLightAndDark(){const useSystem=getSettingValue("use-system-theme");if(useSystem==="true"||(useSystem===null&&getSettingValue("theme")===null)){showLightAndDark()}else{hideLightAndDark()}}function setEvents(settingsElement){updateLightAndDark();onEachLazy(settingsElement.querySelectorAll("input[type=\"checkbox\"]"),toggle=>{const settingId=toggle.id;const settingValue=getSettingValue(settingId);if(settingValue!==null){toggle.checked=settingValue==="true"}toggle.onchange=()=>{changeSetting(toggle.id,toggle.checked)}});onEachLazy(settingsElement.querySelectorAll("input[type=\"radio\"]"),elem=>{const settingId=elem.name;let settingValue=getSettingValue(settingId);if(settingId==="theme"){const useSystem=getSettingValue("use-system-theme");if(useSystem==="true"||settingValue===null){settingValue=useSystem==="false"?"light":"system preference"}}if(settingValue!==null&&settingValue!=="null"){elem.checked=settingValue===elem.value}elem.addEventListener("change",ev=>{changeSetting(ev.target.name,ev.target.value)})})}function buildSettingsPageSections(settings){let output="";for(const setting of settings){if(setting==="hr"){output+="
";continue}const js_data_name=setting["js_name"];const setting_name=setting["name"];if(setting["options"]!==undefined){output+=`\
+

+    
${setting_name}

+    
`;onEach(setting["options"],option=>{const checked=option===setting["default"]?" checked":"";const full=`${js_data_name}-${option.replace(/ /g,"-")}`;output+=`\
+        `});output+=`\
+    

+
`}else{const checked=setting["default"]===true?" checked":"";output+=`\
+
\
+    \
+
`}}return output}function buildSettingsPage(){const theme_names=getVar("themes").split(",").filter(t=>t);theme_names.push("light","dark","ayu");const settings=[{"name":"Theme","js_name":"theme","default":"system preference","options":theme_names.concat("system preference"),},{"name":"Preferred light theme","js_name":"preferred-light-theme","default":"light","options":theme_names,},{"name":"Preferred dark theme","js_name":"preferred-dark-theme","default":"dark","options":theme_names,},{"name":"Auto-hide item contents for large items","js_name":"auto-hide-large-items","default":true,},{"name":"Auto-hide item methods' documentation","js_name":"auto-hide-method-docs","default":false,},{"name":"Auto-hide trait implementation documentation","js_name":"auto-hide-trait-implementations","default":false,},{"name":"Directly go to item in search if there is only one result","js_name":"go-to-only-result","default":false,},{"name":"Show line numbers on code examples","js_name":"line-numbers","default":false,},{"name":"Hide persistent navigation bar","js_name":"hide-sidebar","default":false,},{"name":"Hide table of contents","js_name":"hide-toc","default":false,},{"name":"Hide module navigation","js_name":"hide-modnav","default":false,},{"name":"Disable keyboard shortcuts","js_name":"disable-shortcuts","default":false,},];const elementKind=isSettingsPage?"section":"div";const innerHTML=`
${buildSettingsPageSections(settings)}
`;const el=document.createElement(elementKind);el.id="settings";if(!isSettingsPage){el.className="popover"}el.innerHTML=innerHTML;if(isSettingsPage){document.getElementById(MAIN_ID).appendChild(el)}else{el.setAttribute("tabindex","-1");getSettingsButton().appendChild(el)}return el}const settingsMenu=buildSettingsPage();function displaySettings(){settingsMenu.style.display="";onEachLazy(settingsMenu.querySelectorAll("input[type='checkbox']"),el=>{const val=getSettingValue(el.id);const checked=val==="true";if(checked!==el.checked&&val!==null){el.checked=checked}})}function settingsBlurHandler(event){if(!getHelpButton().contains(document.activeElement)&&!getHelpButton().contains(event.relatedTarget)&&!getSettingsButton().contains(document.activeElement)&&!getSettingsButton().contains(event.relatedTarget)){window.hidePopoverMenus()}}if(!isSettingsPage){const settingsButton=getSettingsButton();const settingsMenu=document.getElementById("settings");settingsButton.onclick=event=>{if(settingsMenu.contains(event.target)){return}event.preventDefault();const shouldDisplaySettings=settingsMenu.style.display==="none";window.hideAllModals();if(shouldDisplaySettings){displaySettings()}};settingsButton.onblur=settingsBlurHandler;settingsButton.querySelector("a").onblur=settingsBlurHandler;onEachLazy(settingsMenu.querySelectorAll("input"),el=>{el.onblur=settingsBlurHandler});settingsMenu.onblur=settingsBlurHandler}setTimeout(()=>{setEvents(settingsMenu);if(!isSettingsPage){displaySettings()}removeClass(getSettingsButton(),"rotate")},0)})()
\ No newline at end of file
diff --git a/static.files/storage-1d39b6787ed640ff.js b/static.files/storage-1d39b6787ed640ff.js
new file mode 100644
index 00000000..5aac776b
--- /dev/null
+++ b/static.files/storage-1d39b6787ed640ff.js
@@ -0,0 +1,23 @@
+"use strict";const builtinThemes=["light","dark","ayu"];const darkThemes=["dark","ayu"];window.currentTheme=document.getElementById("themeStyle");const settingsDataset=(function(){const settingsElement=document.getElementById("default-settings");return settingsElement&&settingsElement.dataset?settingsElement.dataset:null})();function getSettingValue(settingName){const current=getCurrentValue(settingName);if(current===null&&settingsDataset!==null){const def=settingsDataset[settingName.replace(/-/g,"_")];if(def!==undefined){return def}}return current}const localStoredTheme=getSettingValue("theme");function hasClass(elem,className){return elem&&elem.classList&&elem.classList.contains(className)}function addClass(elem,className){if(elem&&elem.classList){elem.classList.add(className)}}function removeClass(elem,className){if(elem&&elem.classList){elem.classList.remove(className)}}function onEach(arr,func){for(const elem of arr){if(func(elem)){return true}}return false}function onEachLazy(lazyArray,func){return onEach(Array.prototype.slice.call(lazyArray),func)}function updateLocalStorage(name,value){try{window.localStorage.setItem("rustdoc-"+name,value)}catch(e){}}function getCurrentValue(name){try{return window.localStorage.getItem("rustdoc-"+name)}catch(e){return null}}const getVar=(function getVar(name){const el=document.querySelector("head > meta[name='rustdoc-vars']");return el?el.attributes["data-"+name].value:null});function switchTheme(newThemeName,saveTheme){const themeNames=getVar("themes").split(",").filter(t=>t);themeNames.push(...builtinThemes);if(themeNames.indexOf(newThemeName)===-1){return}if(saveTheme){updateLocalStorage("theme",newThemeName)}document.documentElement.setAttribute("data-theme",newThemeName);if(builtinThemes.indexOf(newThemeName)!==-1){if(window.currentTheme){window.currentTheme.parentNode.removeChild(window.currentTheme);window.currentTheme=null}}else{const newHref=getVar("root-path")+encodeURIComponent(newThemeName)+getVar("resource-suffix")+".css";if(!window.currentTheme){if(document.readyState==="loading"){document.write(``);window.currentTheme=document.getElementById("themeStyle")}else{window.currentTheme=document.createElement("link");window.currentTheme.rel="stylesheet";window.currentTheme.id="themeStyle";window.currentTheme.href=newHref;document.documentElement.appendChild(window.currentTheme)}}else if(newHref!==window.currentTheme.href){window.currentTheme.href=newHref}}}const updateTheme=(function(){const mql=window.matchMedia("(prefers-color-scheme: dark)");function updateTheme(){if(getSettingValue("use-system-theme")!=="false"){const lightTheme=getSettingValue("preferred-light-theme")||"light";const darkTheme=getSettingValue("preferred-dark-theme")||"dark";updateLocalStorage("use-system-theme","true");switchTheme(mql.matches?darkTheme:lightTheme,true)}else{switchTheme(getSettingValue("theme"),false)}}mql.addEventListener("change",updateTheme);return updateTheme})();if(getSettingValue("use-system-theme")!=="false"&&window.matchMedia){if(getSettingValue("use-system-theme")===null&&getSettingValue("preferred-dark-theme")===null&&darkThemes.indexOf(localStoredTheme)>=0){updateLocalStorage("preferred-dark-theme",localStoredTheme)}}updateTheme();if(getSettingValue("source-sidebar-show")==="true"){addClass(document.documentElement,"src-sidebar-expanded")}if(getSettingValue("hide-sidebar")==="true"){addClass(document.documentElement,"hide-sidebar")}if(getSettingValue("hide-toc")==="true"){addClass(document.documentElement,"hide-toc")}if(getSettingValue("hide-modnav")==="true"){addClass(document.documentElement,"hide-modnav")}function updateSidebarWidth(){const desktopSidebarWidth=getSettingValue("desktop-sidebar-width");if(desktopSidebarWidth&&desktopSidebarWidth!=="null"){document.documentElement.style.setProperty("--desktop-sidebar-width",desktopSidebarWidth+"px",)}const srcSidebarWidth=getSettingValue("src-sidebar-width");if(srcSidebarWidth&&srcSidebarWidth!=="null"){document.documentElement.style.setProperty("--src-sidebar-width",srcSidebarWidth+"px",)}}updateSidebarWidth();window.addEventListener("pageshow",ev=>{if(ev.persisted){setTimeout(updateTheme,0);setTimeout(updateSidebarWidth,0)}});class RustdocSearchElement extends HTMLElement{constructor(){super()}connectedCallback(){const rootPath=getVar("root-path");const currentCrate=getVar("current-crate");this.innerHTML=``}}window.customElements.define("rustdoc-search",RustdocSearchElement);class RustdocToolbarElement extends HTMLElement{constructor(){super()}connectedCallback(){if(this.firstElementChild){return}const rootPath=getVar("root-path");this.innerHTML=`
+        

+            Settings
+        

+        

+            Help
+        

+        `}}window.customElements.define("rustdoc-toolbar",RustdocToolbarElement)
\ No newline at end of file
diff --git a/trait.impl/bvh/aabb/trait.Bounded.js b/trait.impl/bvh/aabb/trait.Bounded.js
index ff28bc9d..70d5df64 100644
--- a/trait.impl/bvh/aabb/trait.Bounded.js
+++ b/trait.impl/bvh/aabb/trait.Bounded.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Bounded<f32, 3> for Triangle"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Bounded<f32, 3> for Triangle"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[284]}
\ No newline at end of file
diff --git a/trait.impl/bvh/bounding_hierarchy/trait.BHShape.js b/trait.impl/bvh/bounding_hierarchy/trait.BHShape.js
index 208ef901..77fcc007 100644
--- a/trait.impl/bvh/bounding_hierarchy/trait.BHShape.js
+++ b/trait.impl/bvh/bounding_hierarchy/trait.BHShape.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl BHShape<f32, 3> for Triangle"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl BHShape<f32, 3> for Triangle"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[284]}
\ No newline at end of file
diff --git a/trait.impl/bytemuck/pod/trait.Pod.js b/trait.impl/bytemuck/pod/trait.Pod.js
index 33df01bb..3d7504d5 100644
--- a/trait.impl/bytemuck/pod/trait.Pod.js
+++ b/trait.impl/bytemuck/pod/trait.Pod.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Pod for ShaderLight"],["impl Pod for ShaderUniforms"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Pod for ShaderLight"],["impl Pod for ShaderUniforms"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[362]}
\ No newline at end of file
diff --git a/trait.impl/bytemuck/zeroable/trait.Zeroable.js b/trait.impl/bytemuck/zeroable/trait.Zeroable.js
index 4cd2ae43..a9f61db8 100644
--- a/trait.impl/bytemuck/zeroable/trait.Zeroable.js
+++ b/trait.impl/bytemuck/zeroable/trait.Zeroable.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Zeroable for ShaderLight"],["impl Zeroable for ShaderUniforms"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Zeroable for ShaderLight"],["impl Zeroable for ShaderUniforms"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[372]}
\ No newline at end of file
diff --git a/trait.impl/core/clone/trait.Clone.js b/trait.impl/core/clone/trait.Clone.js
index 9ffeb9a4..ca9621c4 100644
--- a/trait.impl/core/clone/trait.Clone.js
+++ b/trait.impl/core/clone/trait.Clone.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Clone for Skybox"],["impl Clone for Ray"],["impl Clone for Camera"],["impl Clone for Light"],["impl Clone for IlluminationModel"],["impl Clone for Material"],["impl Clone for Object"],["impl Clone for Settings"],["impl Clone for Scene"],["impl Clone for Triangle"],["impl Clone for ShaderLight"],["impl Clone for ShaderUniforms"],["impl Clone for WgpuPainter"],["impl Clone for Preview"],["impl<'a> Clone for Hit<'a>"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Clone for Skybox"],["impl Clone for Ray"],["impl Clone for Camera"],["impl Clone for Light"],["impl Clone for IlluminationModel"],["impl Clone for Material"],["impl Clone for Object"],["impl Clone for Settings"],["impl Clone for Scene"],["impl Clone for Triangle"],["impl Clone for ShaderLight"],["impl Clone for ShaderUniforms"],["impl Clone for WgpuPainter"],["impl Clone for Preview"],["impl<'a> Clone for Hit<'a>"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[4294]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.Eq.js b/trait.impl/core/cmp/trait.Eq.js
index cbedaf38..9eeecc9c 100644
--- a/trait.impl/core/cmp/trait.Eq.js
+++ b/trait.impl/core/cmp/trait.Eq.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Eq for IlluminationModel"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Eq for IlluminationModel"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[318]}
\ No newline at end of file
diff --git a/trait.impl/core/cmp/trait.PartialEq.js b/trait.impl/core/cmp/trait.PartialEq.js
index ebd61c45..e9c4e31b 100644
--- a/trait.impl/core/cmp/trait.PartialEq.js
+++ b/trait.impl/core/cmp/trait.PartialEq.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl PartialEq for Skybox"],["impl PartialEq for Tab"],["impl PartialEq for Ray"],["impl PartialEq for Camera"],["impl PartialEq for Light"],["impl PartialEq for IlluminationModel"],["impl PartialEq for Settings"],["impl PartialEq for Triangle"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl PartialEq for Skybox"],["impl PartialEq for Tab"],["impl PartialEq for Ray"],["impl PartialEq for Camera"],["impl PartialEq for Light"],["impl PartialEq for IlluminationModel"],["impl PartialEq for Settings"],["impl PartialEq for Triangle"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[2305]}
\ No newline at end of file
diff --git a/trait.impl/core/default/trait.Default.js b/trait.impl/core/default/trait.Default.js
index 5a3e485f..57d97fb3 100644
--- a/trait.impl/core/default/trait.Default.js
+++ b/trait.impl/core/default/trait.Default.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Default for Skybox"],["impl Default for Camera"],["impl Default for Light"],["impl Default for IlluminationModel"],["impl Default for Settings"],["impl Default for ShaderLight"],["impl Default for ShaderUniforms"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Default for Skybox"],["impl Default for Camera"],["impl Default for Light"],["impl Default for IlluminationModel"],["impl Default for Settings"],["impl Default for ShaderLight"],["impl Default for ShaderUniforms"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[2123]}
\ No newline at end of file
diff --git a/trait.impl/core/fmt/trait.Debug.js b/trait.impl/core/fmt/trait.Debug.js
index 96fe113a..9fe38015 100644
--- a/trait.impl/core/fmt/trait.Debug.js
+++ b/trait.impl/core/fmt/trait.Debug.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Debug for Skybox"],["impl Debug for Ray"],["impl Debug for Camera"],["impl Debug for Light"],["impl Debug for IlluminationModel"],["impl Debug for Material"],["impl Debug for Object"],["impl Debug for Settings"],["impl Debug for Scene"],["impl Debug for Triangle"],["impl Debug for ShaderLight"],["impl Debug for ShaderUniforms"],["impl<'a> Debug for Hit<'a>"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Debug for Skybox"],["impl Debug for Ray"],["impl Debug for Camera"],["impl Debug for Light"],["impl Debug for IlluminationModel"],["impl Debug for Material"],["impl Debug for Object"],["impl Debug for Settings"],["impl Debug for Scene"],["impl Debug for Triangle"],["impl Debug for ShaderLight"],["impl Debug for ShaderUniforms"],["impl<'a> Debug for Hit<'a>"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[3665]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Copy.js b/trait.impl/core/marker/trait.Copy.js
index 5238c639..1aa9bfad 100644
--- a/trait.impl/core/marker/trait.Copy.js
+++ b/trait.impl/core/marker/trait.Copy.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Copy for Ray"],["impl Copy for Light"],["impl Copy for IlluminationModel"],["impl Copy for ShaderLight"],["impl Copy for ShaderUniforms"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Copy for Ray"],["impl Copy for Light"],["impl Copy for IlluminationModel"],["impl Copy for ShaderLight"],["impl Copy for ShaderUniforms"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[1470]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Freeze.js b/trait.impl/core/marker/trait.Freeze.js
index 18d0db91..93767e6d 100644
--- a/trait.impl/core/marker/trait.Freeze.js
+++ b/trait.impl/core/marker/trait.Freeze.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl !Freeze for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Freeze for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Freeze for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Freeze for Tab",1,["trayracer::ui::Tab"]],["impl Freeze for Render",1,["trayracer::raytracer::render::Render"]],["impl Freeze for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Freeze for Ray",1,["trayracer::raytracer::Ray"]],["impl Freeze for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Freeze for Camera",1,["trayracer::scene::camera::Camera"]],["impl Freeze for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Freeze for Light",1,["trayracer::scene::light::Light"]],["impl Freeze for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Freeze for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Freeze for Material",1,["trayracer::scene::material::Material"]],["impl Freeze for Object",1,["trayracer::scene::object::Object"]],["impl Freeze for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Freeze for Settings",1,["trayracer::scene::settings::Settings"]],["impl Freeze for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Freeze for Scene",1,["trayracer::scene::Scene"]],["impl Freeze for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Freeze for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Freeze for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Freeze for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Freeze for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Freeze for Preview",1,["trayracer::ui::preview::Preview"]],["impl Freeze for Properties",1,["trayracer::ui::properties::Properties"]],["impl Freeze for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Freeze for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Freeze for App",1,["trayracer::ui::App"]],["impl Freeze for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Freeze for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Freeze for WithRelativePath<P>
where\n    P: Freeze,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Freeze for WithRelativePath<P>
where\n    P: Freeze,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl !Freeze for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Freeze for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Freeze for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Freeze for Tab",1,["trayracer::ui::Tab"]],["impl Freeze for Render",1,["trayracer::raytracer::render::Render"]],["impl Freeze for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Freeze for Ray",1,["trayracer::raytracer::Ray"]],["impl Freeze for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Freeze for Camera",1,["trayracer::scene::camera::Camera"]],["impl Freeze for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Freeze for Light",1,["trayracer::scene::light::Light"]],["impl Freeze for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Freeze for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Freeze for Material",1,["trayracer::scene::material::Material"]],["impl Freeze for Object",1,["trayracer::scene::object::Object"]],["impl Freeze for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Freeze for Settings",1,["trayracer::scene::settings::Settings"]],["impl Freeze for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Freeze for Scene",1,["trayracer::scene::Scene"]],["impl Freeze for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Freeze for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Freeze for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Freeze for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Freeze for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Freeze for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Freeze for Preview",1,["trayracer::ui::preview::Preview"]],["impl Freeze for Properties",1,["trayracer::ui::properties::Properties"]],["impl Freeze for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Freeze for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Freeze for App",1,["trayracer::ui::App"]],["impl Freeze for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Freeze for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Freeze for WithRelativePath<P>
where\n    P: Freeze,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Freeze for WithRelativePath<P>
where\n    P: Freeze,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[12468]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Send.js b/trait.impl/core/marker/trait.Send.js
index c70a3299..75e1d6ac 100644
--- a/trait.impl/core/marker/trait.Send.js
+++ b/trait.impl/core/marker/trait.Send.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Send for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Send for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Send for Tab",1,["trayracer::ui::Tab"]],["impl Send for Render",1,["trayracer::raytracer::render::Render"]],["impl Send for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Send for Ray",1,["trayracer::raytracer::Ray"]],["impl Send for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Send for Camera",1,["trayracer::scene::camera::Camera"]],["impl Send for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Send for Light",1,["trayracer::scene::light::Light"]],["impl Send for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Send for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Send for Material",1,["trayracer::scene::material::Material"]],["impl Send for Object",1,["trayracer::scene::object::Object"]],["impl Send for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Send for Settings",1,["trayracer::scene::settings::Settings"]],["impl Send for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Send for Scene",1,["trayracer::scene::Scene"]],["impl Send for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Send for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Send for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Send for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Send for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Send for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Send for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Send for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Send for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Send for Preview",1,["trayracer::ui::preview::Preview"]],["impl Send for Properties",1,["trayracer::ui::properties::Properties"]],["impl Send for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Send for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Send for App",1,["trayracer::ui::App"]],["impl Send for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Send for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Send for WithRelativePath<P>
where\n    P: Send,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Send for WithRelativePath<P>
where\n    P: Send,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl !Send for Properties",1,["trayracer::ui::properties::Properties"]],["impl !Send for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !Send for App",1,["trayracer::ui::App"]],["impl !Send for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl Send for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Send for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Send for Tab",1,["trayracer::ui::Tab"]],["impl Send for Render",1,["trayracer::raytracer::render::Render"]],["impl Send for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Send for Ray",1,["trayracer::raytracer::Ray"]],["impl Send for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Send for Camera",1,["trayracer::scene::camera::Camera"]],["impl Send for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Send for Light",1,["trayracer::scene::light::Light"]],["impl Send for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Send for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Send for Material",1,["trayracer::scene::material::Material"]],["impl Send for Object",1,["trayracer::scene::object::Object"]],["impl Send for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Send for Settings",1,["trayracer::scene::settings::Settings"]],["impl Send for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Send for Scene",1,["trayracer::scene::Scene"]],["impl Send for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Send for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Send for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Send for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Send for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Send for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Send for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Send for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Send for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Send for Preview",1,["trayracer::ui::preview::Preview"]],["impl Send for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> Send for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Send for WithRelativePath<P>
where\n    P: Send,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Send for WithRelativePath<P>
where\n    P: Send,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[12243]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.StructuralPartialEq.js b/trait.impl/core/marker/trait.StructuralPartialEq.js
index a456a20c..4d3a02f4 100644
--- a/trait.impl/core/marker/trait.StructuralPartialEq.js
+++ b/trait.impl/core/marker/trait.StructuralPartialEq.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl StructuralPartialEq for Skybox"],["impl StructuralPartialEq for Tab"],["impl StructuralPartialEq for Ray"],["impl StructuralPartialEq for Camera"],["impl StructuralPartialEq for Light"],["impl StructuralPartialEq for IlluminationModel"],["impl StructuralPartialEq for Settings"],["impl StructuralPartialEq for Triangle"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl StructuralPartialEq for Skybox"],["impl StructuralPartialEq for Tab"],["impl StructuralPartialEq for Ray"],["impl StructuralPartialEq for Camera"],["impl StructuralPartialEq for Light"],["impl StructuralPartialEq for IlluminationModel"],["impl StructuralPartialEq for Settings"],["impl StructuralPartialEq for Triangle"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[2593]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Sync.js b/trait.impl/core/marker/trait.Sync.js
index b3d637d6..4c1194e9 100644
--- a/trait.impl/core/marker/trait.Sync.js
+++ b/trait.impl/core/marker/trait.Sync.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Sync for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Sync for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Sync for Tab",1,["trayracer::ui::Tab"]],["impl Sync for Render",1,["trayracer::raytracer::render::Render"]],["impl Sync for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Sync for Ray",1,["trayracer::raytracer::Ray"]],["impl Sync for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Sync for Camera",1,["trayracer::scene::camera::Camera"]],["impl Sync for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Sync for Light",1,["trayracer::scene::light::Light"]],["impl Sync for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Sync for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Sync for Material",1,["trayracer::scene::material::Material"]],["impl Sync for Object",1,["trayracer::scene::object::Object"]],["impl Sync for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Sync for Settings",1,["trayracer::scene::settings::Settings"]],["impl Sync for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Sync for Scene",1,["trayracer::scene::Scene"]],["impl Sync for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Sync for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Sync for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Sync for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Sync for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Sync for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Sync for Preview",1,["trayracer::ui::preview::Preview"]],["impl Sync for Properties",1,["trayracer::ui::properties::Properties"]],["impl Sync for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Sync for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Sync for App",1,["trayracer::ui::App"]],["impl Sync for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Sync for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Sync for WithRelativePath<P>
where\n    P: Sync,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Sync for WithRelativePath<P>
where\n    P: Sync,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl !Sync for Properties",1,["trayracer::ui::properties::Properties"]],["impl !Sync for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !Sync for App",1,["trayracer::ui::App"]],["impl !Sync for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl Sync for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Sync for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Sync for Tab",1,["trayracer::ui::Tab"]],["impl Sync for Render",1,["trayracer::raytracer::render::Render"]],["impl Sync for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Sync for Ray",1,["trayracer::raytracer::Ray"]],["impl Sync for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Sync for Camera",1,["trayracer::scene::camera::Camera"]],["impl Sync for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Sync for Light",1,["trayracer::scene::light::Light"]],["impl Sync for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Sync for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Sync for Material",1,["trayracer::scene::material::Material"]],["impl Sync for Object",1,["trayracer::scene::object::Object"]],["impl Sync for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Sync for Settings",1,["trayracer::scene::settings::Settings"]],["impl Sync for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Sync for Scene",1,["trayracer::scene::Scene"]],["impl Sync for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Sync for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Sync for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Sync for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Sync for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Sync for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Sync for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Sync for Preview",1,["trayracer::ui::preview::Preview"]],["impl Sync for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> Sync for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Sync for WithRelativePath<P>
where\n    P: Sync,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Sync for WithRelativePath<P>
where\n    P: Sync,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[12243]}
\ No newline at end of file
diff --git a/trait.impl/core/marker/trait.Unpin.js b/trait.impl/core/marker/trait.Unpin.js
index a1eeaad0..fb5c4f83 100644
--- a/trait.impl/core/marker/trait.Unpin.js
+++ b/trait.impl/core/marker/trait.Unpin.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Unpin for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Unpin for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Unpin for Tab",1,["trayracer::ui::Tab"]],["impl Unpin for Render",1,["trayracer::raytracer::render::Render"]],["impl Unpin for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Unpin for Ray",1,["trayracer::raytracer::Ray"]],["impl Unpin for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Unpin for Camera",1,["trayracer::scene::camera::Camera"]],["impl Unpin for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Unpin for Light",1,["trayracer::scene::light::Light"]],["impl Unpin for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Unpin for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Unpin for Material",1,["trayracer::scene::material::Material"]],["impl Unpin for Object",1,["trayracer::scene::object::Object"]],["impl Unpin for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Unpin for Settings",1,["trayracer::scene::settings::Settings"]],["impl Unpin for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Unpin for Scene",1,["trayracer::scene::Scene"]],["impl Unpin for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Unpin for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Unpin for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Unpin for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Unpin for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Unpin for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Unpin for Preview",1,["trayracer::ui::preview::Preview"]],["impl Unpin for Properties",1,["trayracer::ui::properties::Properties"]],["impl Unpin for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Unpin for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Unpin for App",1,["trayracer::ui::App"]],["impl Unpin for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Unpin for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Unpin for WithRelativePath<P>
where\n    P: Unpin,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Unpin for WithRelativePath<P>
where\n    P: Unpin,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Unpin for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl Unpin for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl Unpin for Tab",1,["trayracer::ui::Tab"]],["impl Unpin for Render",1,["trayracer::raytracer::render::Render"]],["impl Unpin for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl Unpin for Ray",1,["trayracer::raytracer::Ray"]],["impl Unpin for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl Unpin for Camera",1,["trayracer::scene::camera::Camera"]],["impl Unpin for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl Unpin for Light",1,["trayracer::scene::light::Light"]],["impl Unpin for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl Unpin for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl Unpin for Material",1,["trayracer::scene::material::Material"]],["impl Unpin for Object",1,["trayracer::scene::object::Object"]],["impl Unpin for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl Unpin for Settings",1,["trayracer::scene::settings::Settings"]],["impl Unpin for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl Unpin for Scene",1,["trayracer::scene::Scene"]],["impl Unpin for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl Unpin for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl Unpin for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl Unpin for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl Unpin for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl Unpin for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl Unpin for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl Unpin for Preview",1,["trayracer::ui::preview::Preview"]],["impl Unpin for Properties",1,["trayracer::ui::properties::Properties"]],["impl Unpin for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl Unpin for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl Unpin for App",1,["trayracer::ui::App"]],["impl Unpin for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl<'a> Unpin for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> Unpin for WithRelativePath<P>
where\n    P: Unpin,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> Unpin for WithRelativePath<P>
where\n    P: Unpin,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[12353]}
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
index 961cdca5..a857f21c 100644
--- a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
+++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl !RefUnwindSafe for Render",1,["trayracer::raytracer::render::Render"]],["impl !RefUnwindSafe for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl !RefUnwindSafe for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl !RefUnwindSafe for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl !RefUnwindSafe for Preview",1,["trayracer::ui::preview::Preview"]],["impl !RefUnwindSafe for Properties",1,["trayracer::ui::properties::Properties"]],["impl !RefUnwindSafe for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !RefUnwindSafe for App",1,["trayracer::ui::App"]],["impl !RefUnwindSafe for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl RefUnwindSafe for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl RefUnwindSafe for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl RefUnwindSafe for Tab",1,["trayracer::ui::Tab"]],["impl RefUnwindSafe for Ray",1,["trayracer::raytracer::Ray"]],["impl RefUnwindSafe for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl RefUnwindSafe for Camera",1,["trayracer::scene::camera::Camera"]],["impl RefUnwindSafe for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl RefUnwindSafe for Light",1,["trayracer::scene::light::Light"]],["impl RefUnwindSafe for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl RefUnwindSafe for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl RefUnwindSafe for Material",1,["trayracer::scene::material::Material"]],["impl RefUnwindSafe for Object",1,["trayracer::scene::object::Object"]],["impl RefUnwindSafe for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl RefUnwindSafe for Settings",1,["trayracer::scene::settings::Settings"]],["impl RefUnwindSafe for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl RefUnwindSafe for Scene",1,["trayracer::scene::Scene"]],["impl RefUnwindSafe for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl RefUnwindSafe for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl RefUnwindSafe for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl RefUnwindSafe for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl RefUnwindSafe for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> RefUnwindSafe for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> RefUnwindSafe for WithRelativePath<P>
where\n    P: RefUnwindSafe,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> RefUnwindSafe for WithRelativePath<P>
where\n    P: RefUnwindSafe,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl !RefUnwindSafe for Render",1,["trayracer::raytracer::render::Render"]],["impl !RefUnwindSafe for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl !RefUnwindSafe for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl !RefUnwindSafe for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl !RefUnwindSafe for Preview",1,["trayracer::ui::preview::Preview"]],["impl !RefUnwindSafe for Properties",1,["trayracer::ui::properties::Properties"]],["impl !RefUnwindSafe for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !RefUnwindSafe for App",1,["trayracer::ui::App"]],["impl !RefUnwindSafe for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl RefUnwindSafe for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl RefUnwindSafe for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl RefUnwindSafe for Tab",1,["trayracer::ui::Tab"]],["impl RefUnwindSafe for Ray",1,["trayracer::raytracer::Ray"]],["impl RefUnwindSafe for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl RefUnwindSafe for Camera",1,["trayracer::scene::camera::Camera"]],["impl RefUnwindSafe for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl RefUnwindSafe for Light",1,["trayracer::scene::light::Light"]],["impl RefUnwindSafe for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl RefUnwindSafe for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl RefUnwindSafe for Material",1,["trayracer::scene::material::Material"]],["impl RefUnwindSafe for Object",1,["trayracer::scene::object::Object"]],["impl RefUnwindSafe for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl RefUnwindSafe for Settings",1,["trayracer::scene::settings::Settings"]],["impl RefUnwindSafe for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl RefUnwindSafe for Scene",1,["trayracer::scene::Scene"]],["impl RefUnwindSafe for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl RefUnwindSafe for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl RefUnwindSafe for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl RefUnwindSafe for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl RefUnwindSafe for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl RefUnwindSafe for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> RefUnwindSafe for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> RefUnwindSafe for WithRelativePath<P>
where\n    P: RefUnwindSafe,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> RefUnwindSafe for WithRelativePath<P>
where\n    P: RefUnwindSafe,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[14148]}
\ No newline at end of file
diff --git a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
index 21245bc7..cab20934 100644
--- a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
+++ b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl !UnwindSafe for Render",1,["trayracer::raytracer::render::Render"]],["impl !UnwindSafe for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl !UnwindSafe for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl !UnwindSafe for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl !UnwindSafe for Preview",1,["trayracer::ui::preview::Preview"]],["impl !UnwindSafe for Properties",1,["trayracer::ui::properties::Properties"]],["impl !UnwindSafe for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !UnwindSafe for App",1,["trayracer::ui::App"]],["impl !UnwindSafe for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl UnwindSafe for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl UnwindSafe for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl UnwindSafe for Tab",1,["trayracer::ui::Tab"]],["impl UnwindSafe for Ray",1,["trayracer::raytracer::Ray"]],["impl UnwindSafe for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl UnwindSafe for Camera",1,["trayracer::scene::camera::Camera"]],["impl UnwindSafe for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl UnwindSafe for Light",1,["trayracer::scene::light::Light"]],["impl UnwindSafe for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl UnwindSafe for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl UnwindSafe for Material",1,["trayracer::scene::material::Material"]],["impl UnwindSafe for Object",1,["trayracer::scene::object::Object"]],["impl UnwindSafe for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl UnwindSafe for Settings",1,["trayracer::scene::settings::Settings"]],["impl UnwindSafe for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl UnwindSafe for Scene",1,["trayracer::scene::Scene"]],["impl UnwindSafe for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl UnwindSafe for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl UnwindSafe for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl UnwindSafe for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl UnwindSafe for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> UnwindSafe for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> UnwindSafe for WithRelativePath<P>
where\n    P: UnwindSafe,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> UnwindSafe for WithRelativePath<P>
where\n    P: UnwindSafe,
",1,["trayracer::scene::WithRelativePath"]]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl !UnwindSafe for Render",1,["trayracer::raytracer::render::Render"]],["impl !UnwindSafe for RenderingThread",1,["trayracer::raytracer::render::RenderingThread"]],["impl !UnwindSafe for Resources",1,["trayracer::ui::preview::gpu::Resources"]],["impl !UnwindSafe for WgpuPainter",1,["trayracer::ui::preview::gpu::WgpuPainter"]],["impl !UnwindSafe for Preview",1,["trayracer::ui::preview::Preview"]],["impl !UnwindSafe for Properties",1,["trayracer::ui::properties::Properties"]],["impl !UnwindSafe for StatusBar",1,["trayracer::ui::statusbar::StatusBar"]],["impl !UnwindSafe for App",1,["trayracer::ui::App"]],["impl !UnwindSafe for YamlMenu",1,["trayracer::ui::yamlmenu::YamlMenu"]],["impl UnwindSafe for Skybox",1,["trayracer::scene::skybox::Skybox"]],["impl UnwindSafe for SkyboxDef",1,["trayracer::scene::skybox::yaml::SkyboxDef"]],["impl UnwindSafe for Tab",1,["trayracer::ui::Tab"]],["impl UnwindSafe for Ray",1,["trayracer::raytracer::Ray"]],["impl UnwindSafe for Raytracer",1,["trayracer::raytracer::Raytracer"]],["impl UnwindSafe for Camera",1,["trayracer::scene::camera::Camera"]],["impl UnwindSafe for CameraDef",1,["trayracer::scene::camera::yaml::CameraDef"]],["impl UnwindSafe for Light",1,["trayracer::scene::light::Light"]],["impl UnwindSafe for LightDef",1,["trayracer::scene::light::yaml::LightDef"]],["impl UnwindSafe for IlluminationModel",1,["trayracer::scene::material::IlluminationModel"]],["impl UnwindSafe for Material",1,["trayracer::scene::material::Material"]],["impl UnwindSafe for Object",1,["trayracer::scene::object::Object"]],["impl UnwindSafe for ObjectDef",1,["trayracer::scene::object::yaml::ObjectDef"]],["impl UnwindSafe for Settings",1,["trayracer::scene::settings::Settings"]],["impl UnwindSafe for SettingsDef",1,["trayracer::scene::settings::yaml::SettingsDef"]],["impl UnwindSafe for Scene",1,["trayracer::scene::Scene"]],["impl UnwindSafe for Triangle",1,["trayracer::scene::triangle::Triangle"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::color::Yaml"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::point::Yaml"]],["impl UnwindSafe for Yaml",1,["trayracer::scene::yaml::vector::Yaml"]],["impl UnwindSafe for ShaderLight",1,["trayracer::ui::preview::gpu::ShaderLight"]],["impl UnwindSafe for ShaderUniforms",1,["trayracer::ui::preview::gpu::ShaderUniforms"]],["impl UnwindSafe for VertexCount",1,["trayracer::ui::preview::gpu::VertexCount"]],["impl UnwindSafe for RenderResult",1,["trayracer::ui::renderresult::RenderResult"]],["impl<'a> UnwindSafe for Hit<'a>",1,["trayracer::raytracer::Hit"]],["impl<P> UnwindSafe for WithRelativePath<P>
where\n    P: UnwindSafe,
",1,["trayracer::scene::object::WithRelativePath"]],["impl<P> UnwindSafe for WithRelativePath<P>
where\n    P: UnwindSafe,
",1,["trayracer::scene::WithRelativePath"]]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[13806]}
\ No newline at end of file
diff --git a/trait.impl/eframe/epi/trait.App.js b/trait.impl/eframe/epi/trait.App.js
index a657dd6f..479b98e6 100644
--- a/trait.impl/eframe/epi/trait.App.js
+++ b/trait.impl/eframe/epi/trait.App.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl App for App"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl App for App"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[134]}
\ No newline at end of file
diff --git a/trait.impl/egui_wgpu/renderer/trait.CallbackTrait.js b/trait.impl/egui_wgpu/renderer/trait.CallbackTrait.js
index 7958a9ed..ca1b13ec 100644
--- a/trait.impl/egui_wgpu/renderer/trait.CallbackTrait.js
+++ b/trait.impl/egui_wgpu/renderer/trait.CallbackTrait.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl CallbackTrait for WgpuPainter"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl CallbackTrait for WgpuPainter"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[194]}
\ No newline at end of file
diff --git a/trait.impl/serde/de/trait.Deserialize.js b/trait.impl/serde/de/trait.Deserialize.js
index f9cca16f..a613f16d 100644
--- a/trait.impl/serde/de/trait.Deserialize.js
+++ b/trait.impl/serde/de/trait.Deserialize.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl<'de> Deserialize<'de> for Skybox"],["impl<'de> Deserialize<'de> for SkyboxDef"],["impl<'de> Deserialize<'de> for Camera"],["impl<'de> Deserialize<'de> for CameraDef"],["impl<'de> Deserialize<'de> for Light"],["impl<'de> Deserialize<'de> for LightDef"],["impl<'de> Deserialize<'de> for ObjectDef"],["impl<'de> Deserialize<'de> for Settings"],["impl<'de> Deserialize<'de> for SettingsDef"],["impl<'de> Deserialize<'de> for Yaml"],["impl<'de> Deserialize<'de> for Yaml"],["impl<'de> Deserialize<'de> for Yaml"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl<'de> Deserialize<'de> for Skybox"],["impl<'de> Deserialize<'de> for SkyboxDef"],["impl<'de> Deserialize<'de> for Camera"],["impl<'de> Deserialize<'de> for CameraDef"],["impl<'de> Deserialize<'de> for Light"],["impl<'de> Deserialize<'de> for LightDef"],["impl<'de> Deserialize<'de> for ObjectDef"],["impl<'de> Deserialize<'de> for Settings"],["impl<'de> Deserialize<'de> for SettingsDef"],["impl<'de> Deserialize<'de> for Yaml"],["impl<'de> Deserialize<'de> for Yaml"],["impl<'de> Deserialize<'de> for Yaml"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[3868]}
\ No newline at end of file
diff --git a/trait.impl/serde/de/trait.DeserializeSeed.js b/trait.impl/serde/de/trait.DeserializeSeed.js
index 1a92713c..cd1ae0d9 100644
--- a/trait.impl/serde/de/trait.DeserializeSeed.js
+++ b/trait.impl/serde/de/trait.DeserializeSeed.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl<'de, P: AsRef<Path> + Sync> DeserializeSeed<'de> for WithRelativePath<P>"],["impl<'de, P: AsRef<Path>> DeserializeSeed<'de> for WithRelativePath<P>"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl<'de, P: AsRef<Path> + Sync> DeserializeSeed<'de> for WithRelativePath<P>"],["impl<'de, P: AsRef<Path>> DeserializeSeed<'de> for WithRelativePath<P>"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[1419]}
\ No newline at end of file
diff --git a/trait.impl/serde/ser/trait.Serialize.js b/trait.impl/serde/ser/trait.Serialize.js
index 937235df..4928911d 100644
--- a/trait.impl/serde/ser/trait.Serialize.js
+++ b/trait.impl/serde/ser/trait.Serialize.js
@@ -1,3 +1,9 @@
-(function() {var implementors = {
-"trayracer":[["impl Serialize for Skybox"],["impl Serialize for SkyboxDef"],["impl Serialize for Camera"],["impl Serialize for CameraDef"],["impl Serialize for Light"],["impl Serialize for LightDef"],["impl Serialize for Object"],["impl Serialize for ObjectDef"],["impl Serialize for Settings"],["impl Serialize for SettingsDef"],["impl Serialize for Scene"],["impl Serialize for Yaml"],["impl Serialize for Yaml"],["impl Serialize for Yaml"]]
-};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
+(function() {
+    var implementors = Object.fromEntries([["trayracer",[["impl Serialize for Skybox"],["impl Serialize for SkyboxDef"],["impl Serialize for Camera"],["impl Serialize for CameraDef"],["impl Serialize for Light"],["impl Serialize for LightDef"],["impl Serialize for Object"],["impl Serialize for ObjectDef"],["impl Serialize for Settings"],["impl Serialize for SettingsDef"],["impl Serialize for Scene"],["impl Serialize for Yaml"],["impl Serialize for Yaml"],["impl Serialize for Yaml"]]]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()
+//{"start":57,"fragment_lengths":[4110]}
\ No newline at end of file
diff --git a/trayracer/all.html b/trayracer/all.html
index 10a3f94d..2e6c2ce2 100644
--- a/trayracer/all.html
+++ b/trayracer/all.html
@@ -1 +1 @@
-List of all items in this crate
List of all items
Structs
Enums
Functions
Type Aliases
Statics

\ No newline at end of file
+List of all items in this crate
List of all items
Structs
Enums
Functions
Type Aliases
Statics

\ No newline at end of file
diff --git a/trayracer/fn.main.html b/trayracer/fn.main.html
index 09e59e99..3423980b 100644
--- a/trayracer/fn.main.html
+++ b/trayracer/fn.main.html
@@ -1 +1 @@
-main in trayracer - Rust
Function trayracer::main
source · 
pub(crate) fn main() -> Result<()>

\ No newline at end of file
+main in trayracer - Rust
trayracer
Function main
source 
pub(crate) fn main() -> Result<()>

\ No newline at end of file
diff --git a/trayracer/index.html b/trayracer/index.html
index 7bdecf04..1db461ca 100644
--- a/trayracer/index.html
+++ b/trayracer/index.html
@@ -1 +1 @@
-trayracer - Rust
Crate trayracer
source · 
Modules§
Statics§
Functions§

\ No newline at end of file
+trayracer - Rust
Crate trayracer
source 
Modules§
Statics§
Functions§

\ No newline at end of file
diff --git a/trayracer/raytracer/index.html b/trayracer/raytracer/index.html
index 66ef4f66..ff04cea7 100644
--- a/trayracer/raytracer/index.html
+++ b/trayracer/raytracer/index.html
@@ -1 +1 @@
-trayracer::raytracer - Rust
Module trayracer::raytracer
source · 
Modules§
Structs§

\ No newline at end of file
+trayracer::raytracer - Rust
trayracer
Module raytracer
source 
Modules§
Structs§

\ No newline at end of file
diff --git a/trayracer/raytracer/render/index.html b/trayracer/raytracer/render/index.html
index 1e6d3e71..cb69fdc1 100644
--- a/trayracer/raytracer/render/index.html
+++ b/trayracer/raytracer/render/index.html
@@ -1 +1 @@
-trayracer::raytracer::render - Rust
Module trayracer::raytracer::render
source · 
Structs§

\ No newline at end of file
+trayracer::raytracer::render - Rust
trayracer::raytracer
Module render
source 
Structs§

\ No newline at end of file
diff --git a/trayracer/raytracer/render/struct.Render.html b/trayracer/raytracer/render/struct.Render.html
index 4a417169..0e409e7b 100644
--- a/trayracer/raytracer/render/struct.Render.html
+++ b/trayracer/raytracer/render/struct.Render.html
@@ -1,46 +1,47 @@
-Render in trayracer::raytracer::render - Rust
Struct trayracer::raytracer::render::Render
source · 
pub struct Render {
+Render in trayracer::raytracer::render - Rust
trayracer::raytracer::render
Struct Render
source 
pub struct Render {
     pub texture: TextureHandle,
-    pub progress: Arc<AtomicU16>,
-    pub thread: Option<JoinHandle<()>>,
-    pub cancel: Arc<AtomicBool>,
-    pub image: Arc<Mutex<RgbImage>>,
-    pub time: Arc<AtomicU32>,
-}
Fields§
§texture: TextureHandle§progress: Arc<AtomicU16>
Progress of the rendering in the range [0, u16::MAX]

-
§thread: Option<JoinHandle<()>>§cancel: Arc<AtomicBool>
Cancel the rendering if true

-
§image: Arc<Mutex<RgbImage>>§time: Arc<AtomicU32>
Write the rendering time in milliseconds

-
Implementations§
source§
impl Render
source
pub fn new(texture: TextureHandle, image: Arc<Mutex<RgbImage>>) -> Self
source
pub fn render(&mut self, ctx: Context, scene: &Scene)
Auto Trait Implementations§
§
impl Freeze for Render
§
impl !RefUnwindSafe for Render
§
impl Send for Render
§
impl Sync for Render
§
impl Unpin for Render
§
impl !UnwindSafe for Render
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+    pub progress: Arc<AtomicU16>,
+    pub thread: Option<JoinHandle<()>>,
+    pub cancel: Arc<AtomicBool>,
+    pub image: Arc<Mutex<RgbImage>>,
+    pub time: Arc<AtomicU32>,
+}
Fields§
§texture: TextureHandle§progress: Arc<AtomicU16>
Progress of the rendering in the range [0, u16::MAX]

+
§thread: Option<JoinHandle<()>>§cancel: Arc<AtomicBool>
Cancel the rendering if true

+
§image: Arc<Mutex<RgbImage>>§time: Arc<AtomicU32>
Write the rendering time in milliseconds

+
Implementations§
source§
impl Render
source
pub fn new(texture: TextureHandle, image: Arc<Mutex<RgbImage>>) -> Self
source
pub fn render(&mut self, ctx: Context, scene: &Scene)
Auto Trait Implementations§
§
impl Freeze for Render
§
impl !RefUnwindSafe for Render
§
impl Send for Render
§
impl Sync for Render
§
impl Unpin for Render
§
impl !UnwindSafe for Render
Blanket Implementations§
source§
impl<T> Any for T
where
+    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
+    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
+    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
+    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
+then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
+further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
 generate &mut Any’s vtable from &mut Trait’s.
§
impl<T> DowncastSync for T
where
-    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
-further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
+further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

 
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
 Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
-Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
-    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

 
That is, this conversion is whatever the implementation of
-From<T> for U chooses to do.

-
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
+From<T> for U chooses to do.

+
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
 if into_left is true.
 Converts self into a Right variant of Either<Self, Self>
 otherwise. Read more
source§
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where
-    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
+    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
 if into_left(&self) returns true.
 Converts self into a Right variant of Either<Self, Self>
-otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
-    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
-superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T, U> TryFrom<U> for T
where
-    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
-    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
+otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
source§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
+    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
+superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
source§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
source§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
     V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
-    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
 [WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
-[WithDispatch] wrapper. Read more
§
impl<T> WasmNotSend for T
where
-    T: Send,
§
impl<T> WasmNotSendSync for T
where
+[WithDispatch] wrapper. Read more
§
impl<T> ErasedDestructor for T
where
+    T: 'static,
§
impl<T> MaybeSendSync for T
§
impl<T> WasmNotSend for T
where
+    T: Send,
§
impl<T> WasmNotSendSync for T
where
     T: WasmNotSend + WasmNotSync,
§
impl<T> WasmNotSync for T
where
-    T: Sync,

\ No newline at end of file
+    T: Sync,

\ No newline at end of file
diff --git a/trayracer/raytracer/render/struct.RenderingThread.html b/trayracer/raytracer/render/struct.RenderingThread.html
index ba86c6de..bfc54ff6 100644
--- a/trayracer/raytracer/render/struct.RenderingThread.html
+++ b/trayracer/raytracer/render/struct.RenderingThread.html
@@ -1,50 +1,51 @@
-RenderingThread in trayracer::raytracer::render - Rust
Struct trayracer::raytracer::render::RenderingThread
source · 
struct RenderingThread {
+RenderingThread in trayracer::raytracer::render - Rust
trayracer::raytracer::render
Struct RenderingThread
source 
struct RenderingThread {
     ctx: Context,
     scene: Scene,
     texture: TextureHandle,
-    image: Arc<Mutex<RgbImage>>,
-    cancel: Arc<AtomicBool>,
-    progress: Arc<AtomicU16>,
-    time: Arc<AtomicU32>,
+    image: Arc<Mutex<RgbImage>>,
+    cancel: Arc<AtomicBool>,
+    progress: Arc<AtomicU16>,
+    time: Arc<AtomicU32>,
 }
Fields§
§ctx: Context§scene: Scene§texture: TextureHandle
egui Texture (GPU exclusive)

-
§image: Arc<Mutex<RgbImage>>
image data (CPU exclusive)

-
§cancel: Arc<AtomicBool>
Cancel the rendering if true

-
§progress: Arc<AtomicU16>
Progress of the rendering in the range [0, u16::MAX]

-
§time: Arc<AtomicU32>
Write the rendering time in milliseconds

+
§image: Arc<Mutex<RgbImage>>
image data (CPU exclusive)

+
§cancel: Arc<AtomicBool>
Cancel the rendering if true

+
§progress: Arc<AtomicU16>
Progress of the rendering in the range [0, u16::MAX]

+
§time: Arc<AtomicU32>
Write the rendering time in milliseconds

 
Implementations§
source§
impl RenderingThread
source
fn run(self)
main rendering thread

-
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
+    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
+    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
+    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
+then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
+further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
 generate &mut Any’s vtable from &mut Trait’s.
§
impl<T> DowncastSync for T
where
-    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
-further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
+further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

 
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
 Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
-Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
-    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

 
That is, this conversion is whatever the implementation of
-From<T> for U chooses to do.

-
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
+From<T> for U chooses to do.

+
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
 if into_left is true.
 Converts self into a Right variant of Either<Self, Self>
 otherwise. Read more
source§
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where
-    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
+    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
 if into_left(&self) returns true.
 Converts self into a Right variant of Either<Self, Self>
-otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
-    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
-superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T, U> TryFrom<U> for T
where
-    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
-    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
+otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
source§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
+    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
+superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
source§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
source§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
     V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
-    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
 [WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
-[WithDispatch] wrapper. Read more
§
impl<T> WasmNotSend for T
where
-    T: Send,
§
impl<T> WasmNotSendSync for T
where
+[WithDispatch] wrapper. Read more
§
impl<T> ErasedDestructor for T
where
+    T: 'static,
§
impl<T> MaybeSendSync for T
§
impl<T> WasmNotSend for T
where
+    T: Send,
§
impl<T> WasmNotSendSync for T
where
     T: WasmNotSend + WasmNotSync,
§
impl<T> WasmNotSync for T
where
-    T: Sync,

\ No newline at end of file
+    T: Sync,

\ No newline at end of file
diff --git a/trayracer/raytracer/struct.Hit.html b/trayracer/raytracer/struct.Hit.html
index 5fed7a4e..0d03bf88 100644
--- a/trayracer/raytracer/struct.Hit.html
+++ b/trayracer/raytracer/struct.Hit.html
@@ -1,45 +1,47 @@
-Hit in trayracer::raytracer - Rust
Struct trayracer::raytracer::Hit
source · 
pub struct Hit<'a> {
-    pub name: &'a str,
-    pub point: Point3<f32>,
-    pub normal: Vector3<f32>,
-    pub material: Option<&'a Material>,
-    pub uv: Vector2<f32>,
-}
Fields§
§name: &'a str§point: Point3<f32>§normal: Vector3<f32>§material: Option<&'a Material>§uv: Vector2<f32>
Trait Implementations§
source§
impl<'a> Clone for Hit<'a>
source§
fn clone(&self) -> Hit<'a>
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl<'a> Debug for Hit<'a>
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
§
impl<'a> Freeze for Hit<'a>
§
impl<'a> RefUnwindSafe for Hit<'a>
§
impl<'a> Send for Hit<'a>
§
impl<'a> Sync for Hit<'a>
§
impl<'a> Unpin for Hit<'a>
§
impl<'a> UnwindSafe for Hit<'a>
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
-    T: Clone,
source§
default unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+Hit in trayracer::raytracer - Rust
trayracer::raytracer
Struct Hit
source 
pub struct Hit<'a> {
+    pub name: &'a str,
+    pub point: Point3<f32>,
+    pub normal: Vector3<f32>,
+    pub material: Option<&'a Material>,
+    pub uv: Vector2<f32>,
+}
Fields§
§name: &'a str§point: Point3<f32>§normal: Vector3<f32>§material: Option<&'a Material>§uv: Vector2<f32>
Trait Implementations§
source§
impl<'a> Clone for Hit<'a>
source§
fn clone(&self) -> Hit<'a>
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl<'a> Debug for Hit<'a>
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
§
impl<'a> Freeze for Hit<'a>
§
impl<'a> RefUnwindSafe for Hit<'a>
§
impl<'a> Send for Hit<'a>
§
impl<'a> Sync for Hit<'a>
§
impl<'a> Unpin for Hit<'a>
§
impl<'a> UnwindSafe for Hit<'a>
Blanket Implementations§
source§
impl<T> Any for T
where
+    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
+    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
+    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
+    T: Clone,
source§
unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
+    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
+then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
+further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
 generate &mut Any’s vtable from &mut Trait’s.
§
impl<T> DowncastSync for T
where
-    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
-further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
+further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> DynClone for T
where
+    T: Clone,
source§
fn __clone_box(&self, _: Private) -> *mut ()
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

 
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
 Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
-Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
-    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

 
That is, this conversion is whatever the implementation of
-From<T> for U chooses to do.

-
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
+From<T> for U chooses to do.

+
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
 if into_left is true.
 Converts self into a Right variant of Either<Self, Self>
 otherwise. Read more
source§
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where
-    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
+    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
 if into_left(&self) returns true.
 Converts self into a Right variant of Either<Self, Self>
-otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
-    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
-superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T> ToOwned for T
where
-    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
source§
impl<T, U> TryFrom<U> for T
where
-    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
-    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
+otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
source§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
+    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
+superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T> ToOwned for T
where
+    T: Clone,
source§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
source§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
source§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
     V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
-    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
 [WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
-[WithDispatch] wrapper. Read more
§
impl<T> SerializableAny for T
where
-    T: 'static + Any + Clone + for<'a> Send + Sync,
§
impl<T> WasmNotSend for T
where
-    T: Send,
§
impl<T> WasmNotSendSync for T
where
+[WithDispatch] wrapper. Read more
§
impl<T> ErasedDestructor for T
where
+    T: 'static,
§
impl<T> MaybeSendSync for T
§
impl<T> SerializableAny for T
where
+    T: 'static + Any + Clone + for<'a> Send + Sync,
§
impl<T> WasmNotSend for T
where
+    T: Send,
§
impl<T> WasmNotSendSync for T
where
     T: WasmNotSend + WasmNotSync,
§
impl<T> WasmNotSync for T
where
-    T: Sync,
\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/raytracer/struct.Ray.html b/trayracer/raytracer/struct.Ray.html index 100f0ac3..8a3a83ba 100644 --- a/trayracer/raytracer/struct.Ray.html +++ b/trayracer/raytracer/struct.Ray.html @@ -1,46 +1,46 @@ -Ray in trayracer::raytracer - Rust

Struct trayracer::raytracer::Ray

source · 
pub struct Ray {
-    pub origin: Point3<f32>,
-    pub direction: Vector3<f32>,
-}

Fields§

§origin: Point3<f32>§direction: Vector3<f32>

Trait Implementations§

source§

impl Clone for Ray

source§

fn clone(&self) -> Ray

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Ray

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl PartialEq for Ray

source§

fn eq(&self, other: &Ray) -> bool

This method tests for self and other values to be equal, and is used -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Copy for Ray

source§

impl StructuralPartialEq for Ray

Auto Trait Implementations§

§

impl Freeze for Ray

§

impl RefUnwindSafe for Ray

§

impl Send for Ray

§

impl Sync for Ray

§

impl Unpin for Ray

§

impl UnwindSafe for Ray

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Ray in trayracer::raytracer - Rust
trayracer::raytracer

Struct Ray

source 
pub struct Ray {
+    pub origin: Point3<f32>,
+    pub direction: Vector3<f32>,
+}

Fields§

§origin: Point3<f32>§direction: Vector3<f32>

Trait Implementations§

source§

impl Clone for Ray

source§

fn clone(&self) -> Ray

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Ray

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl PartialEq for Ray

source§

fn eq(&self, other: &Ray) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl Copy for Ray

source§

impl StructuralPartialEq for Ray

Auto Trait Implementations§

§

impl Freeze for Ray

§

impl RefUnwindSafe for Ray

§

impl Send for Ray

§

impl Sync for Ray

§

impl Unpin for Ray

§

impl UnwindSafe for Ray

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/raytracer/struct.Raytracer.html b/trayracer/raytracer/struct.Raytracer.html index 370556ea..51f9d933 100644 --- a/trayracer/raytracer/struct.Raytracer.html +++ b/trayracer/raytracer/struct.Raytracer.html @@ -1,52 +1,53 @@ -Raytracer in trayracer::raytracer - Rust

Struct trayracer::raytracer::Raytracer

source · 
pub struct Raytracer {
+Raytracer in trayracer::raytracer - Rust
trayracer::raytracer
Struct Raytracer
source 
pub struct Raytracer {
     scene: Scene,
-    delta: f32,
-    max_depth: u32,
+    delta: f32,
+    max_depth: u32,
 }
Fields§
§scene: Scene
Scene is cloned into here for rendering

-
§delta: f32§max_depth: u32
max number of nested shade calls

-
Implementations§
source§
impl Raytracer
source
const NO_MATERIAL_COLOR: Vector3<f32> = _
source
pub const fn new(scene: Scene, delta: f32, max_depth: u32) -> Self
source
fn raycast(&self, ray: Ray) -> Option<Hit<'_>>
source
fn reflect(incoming: Vector3<f32>, normal: Vector3<f32>) -> Vector3<f32>
source
fn skybox(&self, direction: Vector3<f32>) -> Vector3<f32>
source
fn texture(texture: &RgbImage, uv: Vector2<f32>) -> Vector3<f32>
source
fn raycast_transparent(&self, ray: Ray) -> Box<[Hit<'_>]>
Raycast and continue on hits if the material is transparent

-
source
fn shade(&self, ray: Ray, depth: u32) -> Vector3<f32>
source
fn shade_impl(&self, ray: Ray, hit: &Hit<'_>, depth: u32) -> Vector3<f32>
source
pub fn render(
+
§delta: f32§max_depth: u32
max number of nested shade calls

+
Implementations§
source§
impl Raytracer
source
const NO_MATERIAL_COLOR: Vector3<f32> = _
source
pub const fn new(scene: Scene, delta: f32, max_depth: u32) -> Self
source
fn raycast(&self, ray: Ray) -> Option<Hit<'_>>
source
fn reflect(incoming: Vector3<f32>, normal: Vector3<f32>) -> Vector3<f32>
source
fn skybox(&self, direction: Vector3<f32>) -> Vector3<f32>
source
fn texture(texture: &RgbImage, uv: Vector2<f32>) -> Vector3<f32>
source
fn raycast_transparent(&self, ray: Ray) -> Box<[Hit<'_>]>
Raycast and continue on hits if the material is transparent

+
source
fn shade(&self, ray: Ray, depth: u32) -> Vector3<f32>
source
fn shade_impl(&self, ray: Ray, hit: &Hit<'_>, depth: u32) -> Vector3<f32>
source
pub fn render(
     &self,
-    (x, y): (u32, u32),
-    (width, height): (u32, u32),
-    anti_aliasing: bool,
-) -> Vector3<f32>
Render a pixel at the given coordinates.
+    (x, y): (u32, u32),
+    (width, height): (u32, u32),
+    anti_aliasing: bool,
+) -> Vector3<f32>
Render a pixel at the given coordinates.
 x and y are in the range 0..width and 0..height
 where (0, 0) is the top left corner.
 Anti-aliasing is done by sampling multiple rays per pixel, enhanced with stratified sampling.

-

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/camera/index.html b/trayracer/scene/camera/index.html index 001953e7..dc82ca0c 100644 --- a/trayracer/scene/camera/index.html +++ b/trayracer/scene/camera/index.html @@ -1 +1 @@ -trayracer::scene::camera - Rust

Module trayracer::scene::camera

source ·

Modules§

Structs§

\ No newline at end of file +trayracer::scene::camera - Rust
trayracer::scene

Module camera

source

Modules§

Structs§

\ No newline at end of file diff --git a/trayracer/scene/camera/struct.Camera.html b/trayracer/scene/camera/struct.Camera.html index d0ea265c..f289014b 100644 --- a/trayracer/scene/camera/struct.Camera.html +++ b/trayracer/scene/camera/struct.Camera.html @@ -1,58 +1,59 @@ -Camera in trayracer::scene::camera - Rust

Struct trayracer::scene::camera::Camera

source · 
pub struct Camera {
-    pub position: Point3<f32>,
-    pub look_at: Point3<f32>,
-    pub up: Vector3<f32>,
-    pub fov: f32,
-    pub resolution: (u32, u32),
-}

Fields§

§position: Point3<f32>§look_at: Point3<f32>§up: Vector3<f32>§fov: f32§resolution: (u32, u32)

Implementations§

source§

impl Camera

source

pub fn ray(&self, x: f32, y: f32) -> Ray

Returns a ray from the given pixel coordinates. +Camera in trayracer::scene::camera - Rust

trayracer::scene::camera

Struct Camera

source 
pub struct Camera {
+    pub position: Point3<f32>,
+    pub look_at: Point3<f32>,
+    pub up: Vector3<f32>,
+    pub fov: f32,
+    pub resolution: (u32, u32),
+}

Fields§

§position: Point3<f32>§look_at: Point3<f32>§up: Vector3<f32>§fov: f32§resolution: (u32, u32)

Implementations§

source§

impl Camera

source

pub fn ray(&self, x: f32, y: f32) -> Ray

Returns a ray from the given pixel coordinates. x and y are in the range -1..1 and represent the relative position of the pixel in the image. (0, 0) is the center of the image.

-

Trait Implementations§

source§

impl Clone for Camera

source§

fn clone(&self) -> Camera

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Camera

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Camera

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Camera

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where - D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Camera

source§

fn eq(&self, other: &Camera) -> bool

This method tests for self and other values to be equal, and is used -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Serialize for Camera

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where - S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl StructuralPartialEq for Camera

Auto Trait Implementations§

§

impl Freeze for Camera

§

impl RefUnwindSafe for Camera

§

impl Send for Camera

§

impl Sync for Camera

§

impl Unpin for Camera

§

impl UnwindSafe for Camera

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +

Trait Implementations§

source§

impl Clone for Camera

source§

fn clone(&self) -> Camera

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Camera

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Camera

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Camera

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where + D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Camera

source§

fn eq(&self, other: &Camera) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl Serialize for Camera

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl StructuralPartialEq for Camera

Auto Trait Implementations§

§

impl Freeze for Camera

§

impl RefUnwindSafe for Camera

§

impl Send for Camera

§

impl Sync for Camera

§

impl Unpin for Camera

§

impl UnwindSafe for Camera

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/camera/yaml/index.html b/trayracer/scene/camera/yaml/index.html index 28dd0353..193384bf 100644 --- a/trayracer/scene/camera/yaml/index.html +++ b/trayracer/scene/camera/yaml/index.html @@ -1 +1 @@ -trayracer::scene::camera::yaml - Rust

Module trayracer::scene::camera::yaml

source ·

Structs§

\ No newline at end of file +trayracer::scene::camera::yaml - Rust
trayracer::scene::camera

Module yaml

source

Structs§

\ No newline at end of file diff --git a/trayracer/scene/camera/yaml/struct.CameraDef.html b/trayracer/scene/camera/yaml/struct.CameraDef.html index 5008cf50..5babf441 100644 --- a/trayracer/scene/camera/yaml/struct.CameraDef.html +++ b/trayracer/scene/camera/yaml/struct.CameraDef.html @@ -1,46 +1,47 @@ -CameraDef in trayracer::scene::camera::yaml - Rust

Struct trayracer::scene::camera::yaml::CameraDef

source · 
pub struct CameraDef {
-    pub position: Point3<f32>,
-    pub look_at: Point3<f32>,
-    pub up_vec: Vector3<f32>,
-    pub field_of_view: f32,
-    pub width: u32,
-    pub height: u32,
-}

Fields§

§position: Point3<f32>§look_at: Point3<f32>§up_vec: Vector3<f32>§field_of_view: f32§width: u32§height: u32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for CameraDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for CameraDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +CameraDef in trayracer::scene::camera::yaml - Rust
trayracer::scene::camera::yaml

Struct CameraDef

source 
pub struct CameraDef {
+    pub position: Point3<f32>,
+    pub look_at: Point3<f32>,
+    pub up_vec: Vector3<f32>,
+    pub field_of_view: f32,
+    pub width: u32,
+    pub height: u32,
+}

Fields§

§position: Point3<f32>§look_at: Point3<f32>§up_vec: Vector3<f32>§field_of_view: f32§width: u32§height: u32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for CameraDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for CameraDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/index.html b/trayracer/scene/index.html index 4773e5d1..e1ed856e 100644 --- a/trayracer/scene/index.html +++ b/trayracer/scene/index.html @@ -1 +1 @@ -trayracer::scene - Rust

Module trayracer::scene

source ·

Re-exports§

Modules§

Structs§

Type Aliases§

\ No newline at end of file +trayracer::scene - Rust
trayracer

Module scene

source

Re-exports§

Modules§

Structs§

Type Aliases§

\ No newline at end of file diff --git a/trayracer/scene/light/index.html b/trayracer/scene/light/index.html index 4117c477..765d707b 100644 --- a/trayracer/scene/light/index.html +++ b/trayracer/scene/light/index.html @@ -1 +1 @@ -trayracer::scene::light - Rust

Module trayracer::scene::light

source ·

Modules§

Structs§

\ No newline at end of file +trayracer::scene::light - Rust
trayracer::scene

Module light

source

Modules§

Structs§

\ No newline at end of file diff --git a/trayracer/scene/light/struct.Light.html b/trayracer/scene/light/struct.Light.html index 957920a6..ed48f14d 100644 --- a/trayracer/scene/light/struct.Light.html +++ b/trayracer/scene/light/struct.Light.html @@ -1,53 +1,53 @@ -Light in trayracer::scene::light - Rust

Struct trayracer::scene::light::Light

source · 
pub struct Light {
-    pub position: Point3<f32>,
-    pub color: Vector3<f32>,
-    pub intensity: f32,
-}

Fields§

§position: Point3<f32>§color: Vector3<f32>§intensity: f32

Trait Implementations§

source§

impl Clone for Light

source§

fn clone(&self) -> Light

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Light

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Light

source§

fn default() -> Light

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Light

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where - D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Light

source§

fn eq(&self, other: &Light) -> bool

This method tests for self and other values to be equal, and is used -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Serialize for Light

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where - S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl Copy for Light

source§

impl StructuralPartialEq for Light

Auto Trait Implementations§

§

impl Freeze for Light

§

impl RefUnwindSafe for Light

§

impl Send for Light

§

impl Sync for Light

§

impl Unpin for Light

§

impl UnwindSafe for Light

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Light in trayracer::scene::light - Rust
trayracer::scene::light

Struct Light

source 
pub struct Light {
+    pub position: Point3<f32>,
+    pub color: Vector3<f32>,
+    pub intensity: f32,
+}

Fields§

§position: Point3<f32>§color: Vector3<f32>§intensity: f32

Trait Implementations§

source§

impl Clone for Light

source§

fn clone(&self) -> Light

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Light

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Light

source§

fn default() -> Light

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Light

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where + D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Light

source§

fn eq(&self, other: &Light) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl Serialize for Light

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl Copy for Light

source§

impl StructuralPartialEq for Light

Auto Trait Implementations§

§

impl Freeze for Light

§

impl RefUnwindSafe for Light

§

impl Send for Light

§

impl Sync for Light

§

impl Unpin for Light

§

impl UnwindSafe for Light

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/light/yaml/index.html b/trayracer/scene/light/yaml/index.html index 4cca2642..5a1e632f 100644 --- a/trayracer/scene/light/yaml/index.html +++ b/trayracer/scene/light/yaml/index.html @@ -1 +1 @@ -trayracer::scene::light::yaml - Rust

Module trayracer::scene::light::yaml

source ·

Structs§

\ No newline at end of file +trayracer::scene::light::yaml - Rust
trayracer::scene::light

Module yaml

source

Structs§

\ No newline at end of file diff --git a/trayracer/scene/light/yaml/struct.LightDef.html b/trayracer/scene/light/yaml/struct.LightDef.html index af7fe21b..156ed21b 100644 --- a/trayracer/scene/light/yaml/struct.LightDef.html +++ b/trayracer/scene/light/yaml/struct.LightDef.html @@ -1,43 +1,44 @@ -LightDef in trayracer::scene::light::yaml - Rust

Struct trayracer::scene::light::yaml::LightDef

source · 
pub struct LightDef {
-    pub position: Point3<f32>,
-    pub ke: Vector3<f32>,
-    pub intensity: f32,
-}

Fields§

§position: Point3<f32>§ke: Vector3<f32>§intensity: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for LightDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for LightDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +LightDef in trayracer::scene::light::yaml - Rust
trayracer::scene::light::yaml

Struct LightDef

source 
pub struct LightDef {
+    pub position: Point3<f32>,
+    pub ke: Vector3<f32>,
+    pub intensity: f32,
+}

Fields§

§position: Point3<f32>§ke: Vector3<f32>§intensity: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for LightDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for LightDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/material/index.html b/trayracer/scene/material/index.html index 4b50d933..56bb346a 100644 --- a/trayracer/scene/material/index.html +++ b/trayracer/scene/material/index.html @@ -1,2 +1,2 @@ -trayracer::scene::material - Rust

Module trayracer::scene::material

source ·

Structs§

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/material/struct.Material.html b/trayracer/scene/material/struct.Material.html index 7cd56cb8..122562ca 100644 --- a/trayracer/scene/material/struct.Material.html +++ b/trayracer/scene/material/struct.Material.html @@ -1,48 +1,50 @@ -Material in trayracer::scene::material - Rust

Struct trayracer::scene::material::Material

source · 
pub struct Material {
-    pub name: String,
-    pub diffuse_color: Option<Vector3<f32>>,
-    pub specular_color: Option<Vector3<f32>>,
-    pub specular_exponent: Option<f32>,
-    pub diffuse_texture: Option<RgbImage>,
+Material in trayracer::scene::material - Rust
trayracer::scene::material
Struct Material
source 
pub struct Material {
+    pub name: String,
+    pub diffuse_color: Option<Vector3<f32>>,
+    pub specular_color: Option<Vector3<f32>>,
+    pub specular_exponent: Option<f32>,
+    pub diffuse_texture: Option<RgbImage>,
     pub illumination_model: IlluminationModel,
-    pub dissolve: Option<f32>,
-    pub refraction_index: Option<f32>,
-}
Fields§
§name: String§diffuse_color: Option<Vector3<f32>>§specular_color: Option<Vector3<f32>>§specular_exponent: Option<f32>§diffuse_texture: Option<RgbImage>§illumination_model: IlluminationModel§dissolve: Option<f32>§refraction_index: Option<f32>
Trait Implementations§
source§
impl Clone for Material
source§
fn clone(&self) -> Material
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for Material
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
-    T: Clone,
source§
default unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+    pub dissolve: Option<f32>,
+    pub refraction_index: Option<f32>,
+}

Fields§

§name: String§diffuse_color: Option<Vector3<f32>>§specular_color: Option<Vector3<f32>>§specular_exponent: Option<f32>§diffuse_texture: Option<RgbImage>§illumination_model: IlluminationModel§dissolve: Option<f32>§refraction_index: Option<f32>

Trait Implementations§

source§

impl Clone for Material

source§

fn clone(&self) -> Material

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Material

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/object/fn.filename.html b/trayracer/scene/object/fn.filename.html index 36f43569..ff954c1d 100644 --- a/trayracer/scene/object/fn.filename.html +++ b/trayracer/scene/object/fn.filename.html @@ -1 +1 @@ -filename in trayracer::scene::object - Rust

Function trayracer::scene::object::filename

source · 
fn filename<P: AsRef<Path>>(path: P) -> String
\ No newline at end of file +filename in trayracer::scene::object - Rust
trayracer::scene::object

Function filename

source 
fn filename<P: AsRef<Path>>(path: P) -> String
\ No newline at end of file diff --git a/trayracer/scene/object/fn.load_texture.html b/trayracer/scene/object/fn.load_texture.html index 77beca07..9f89a05b 100644 --- a/trayracer/scene/object/fn.load_texture.html +++ b/trayracer/scene/object/fn.load_texture.html @@ -1 +1 @@ -load_texture in trayracer::scene::object - Rust

Function trayracer::scene::object::load_texture

source · 
fn load_texture<P: AsRef<Path>>(path: P) -> Result<RgbImage>
\ No newline at end of file +load_texture in trayracer::scene::object - Rust
trayracer::scene::object

Function load_texture

source 
fn load_texture<P: AsRef<Path>>(path: P) -> Result<RgbImage>
\ No newline at end of file diff --git a/trayracer/scene/object/fn.triangulate.html b/trayracer/scene/object/fn.triangulate.html index 1ac7ec33..a05a403d 100644 --- a/trayracer/scene/object/fn.triangulate.html +++ b/trayracer/scene/object/fn.triangulate.html @@ -1,7 +1,7 @@ -triangulate in trayracer::scene::object - Rust

Function trayracer::scene::object::triangulate

source · 
fn triangulate(
+triangulate in trayracer::scene::object - Rust
trayracer::scene::object
Function triangulate
source 
fn triangulate(
     obj: &Obj,
     poly: &SimplePolygon,
-    material_index: Option<usize>,
-    (computed_normals_zero, no_normals, no_uv): &mut (u32, u32, u32),
-) -> Vec<Triangle>
Expand description
Triangulate a polygon and compute normals and uv coordinates if they are missing

+    material_index: Option<usize>,
+    (computed_normals_zero, no_normals, no_uv): &mut (u32, u32, u32),
+) -> Vec<Triangle>
Expand description

Triangulate a polygon and compute normals and uv coordinates if they are missing

\ No newline at end of file diff --git a/trayracer/scene/object/index.html b/trayracer/scene/object/index.html index df19eb14..f4c213ea 100644 --- a/trayracer/scene/object/index.html +++ b/trayracer/scene/object/index.html @@ -1 +1 @@ -trayracer::scene::object - Rust

Module trayracer::scene::object

source ·

Modules§

Structs§

Functions§

\ No newline at end of file +trayracer::scene::object - Rust
trayracer::scene

Module object

source

Modules§

Structs§

Functions§

\ No newline at end of file diff --git a/trayracer/scene/object/struct.Object.html b/trayracer/scene/object/struct.Object.html index af712292..6b4bb13e 100644 --- a/trayracer/scene/object/struct.Object.html +++ b/trayracer/scene/object/struct.Object.html @@ -1,55 +1,57 @@ -Object in trayracer::scene::object - Rust

Struct trayracer::scene::object::Object

source · 
pub struct Object {
-    pub name: String,
-    material_name: String,
-    path: PathBuf,
-    pub triangles: Vec<Triangle>,
-    pub materials: Vec<Material>,
-    pub translation: Translation3<f32>,
-    pub rotation: UnitQuaternion<f32>,
-    pub scale: Scale3<f32>,
-    bvh: Bvh<f32, 3>,
-}

Fields§

§name: String§material_name: String§path: PathBuf§triangles: Vec<Triangle>§materials: Vec<Material>§translation: Translation3<f32>§rotation: UnitQuaternion<f32>§scale: Scale3<f32>§bvh: Bvh<f32, 3>

Implementations§

source§

impl Object

source

pub fn from_obj<P: AsRef<Path>>( +Object in trayracer::scene::object - Rust
trayracer::scene::object

Struct Object

source 
pub struct Object {
+    pub name: String,
+    material_name: String,
+    path: PathBuf,
+    pub triangles: Vec<Triangle>,
+    pub materials: Vec<Material>,
+    pub translation: Translation3<f32>,
+    pub rotation: UnitQuaternion<f32>,
+    pub scale: Scale3<f32>,
+    bvh: Bvh<f32, 3>,
+}

Fields§

§name: String§material_name: String§path: PathBuf§triangles: Vec<Triangle>§materials: Vec<Material>§translation: Translation3<f32>§rotation: UnitQuaternion<f32>§scale: Scale3<f32>§bvh: Bvh<f32, 3>

Implementations§

source§

impl Object

source

pub fn from_obj<P: AsRef<Path>>( path: P, - translation: Translation3<f32>, - rotation: UnitQuaternion<f32>, - scale: Scale3<f32>, -) -> Result<Self>

source

pub fn transform(&self) -> Affine3<f32>

source

pub fn intersect(&self, ray: Ray, delta: f32) -> Option<Hit<'_>>

Trait Implementations§

source§

impl Clone for Object

source§

fn clone(&self) -> Object

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Object

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Serialize for Object

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where - S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Object

§

impl RefUnwindSafe for Object

§

impl Send for Object

§

impl Sync for Object

§

impl Unpin for Object

§

impl UnwindSafe for Object

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot + translation: Translation3<f32>, + rotation: UnitQuaternion<f32>, + scale: Scale3<f32>, +) -> Result<Self>

source

pub fn transform(&self) -> Affine3<f32>

source

pub fn intersect(&self, ray: Ray, delta: f32) -> Option<Hit<'_>>

Trait Implementations§

source§

impl Clone for Object

source§

fn clone(&self) -> Object

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Object

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Serialize for Object

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Object

§

impl RefUnwindSafe for Object

§

impl Send for Object

§

impl Sync for Object

§

impl Unpin for Object

§

impl UnwindSafe for Object

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/object/struct.WithRelativePath.html b/trayracer/scene/object/struct.WithRelativePath.html index d5ac61ef..c1ae1ce5 100644 --- a/trayracer/scene/object/struct.WithRelativePath.html +++ b/trayracer/scene/object/struct.WithRelativePath.html @@ -1,44 +1,45 @@ -WithRelativePath in trayracer::scene::object - Rust

Struct trayracer::scene::object::WithRelativePath

source · 
pub struct WithRelativePath<P: AsRef<Path>>(pub P);

Tuple Fields§

§0: P

Trait Implementations§

source§

impl<'de, P: AsRef<Path>> DeserializeSeed<'de> for WithRelativePath<P>

§

type Value = Object

The type produced by using this seed.
source§

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where - D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except -with some initial piece of data (the seed) passed in.

Auto Trait Implementations§

§

impl<P> Freeze for WithRelativePath<P>
where - P: Freeze,

§

impl<P> RefUnwindSafe for WithRelativePath<P>
where - P: RefUnwindSafe,

§

impl<P> Send for WithRelativePath<P>
where - P: Send,

§

impl<P> Sync for WithRelativePath<P>
where - P: Sync,

§

impl<P> Unpin for WithRelativePath<P>
where - P: Unpin,

§

impl<P> UnwindSafe for WithRelativePath<P>
where - P: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +WithRelativePath in trayracer::scene::object - Rust
trayracer::scene::object

Struct WithRelativePath

source 
pub struct WithRelativePath<P: AsRef<Path>>(pub P);

Tuple Fields§

§0: P

Trait Implementations§

source§

impl<'de, P: AsRef<Path>> DeserializeSeed<'de> for WithRelativePath<P>

source§

type Value = Object

The type produced by using this seed.
source§

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where + D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except +with some initial piece of data (the seed) passed in.

Auto Trait Implementations§

§

impl<P> Freeze for WithRelativePath<P>
where + P: Freeze,

§

impl<P> RefUnwindSafe for WithRelativePath<P>
where + P: RefUnwindSafe,

§

impl<P> Send for WithRelativePath<P>
where + P: Send,

§

impl<P> Sync for WithRelativePath<P>
where + P: Sync,

§

impl<P> Unpin for WithRelativePath<P>
where + P: Unpin,

§

impl<P> UnwindSafe for WithRelativePath<P>
where + P: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/object/yaml/index.html b/trayracer/scene/object/yaml/index.html index 30528c8f..2db11a6c 100644 --- a/trayracer/scene/object/yaml/index.html +++ b/trayracer/scene/object/yaml/index.html @@ -1 +1 @@ -trayracer::scene::object::yaml - Rust

Module trayracer::scene::object::yaml

source ·

Structs§

\ No newline at end of file +trayracer::scene::object::yaml - Rust
trayracer::scene::object

Module yaml

source

Structs§

\ No newline at end of file diff --git a/trayracer/scene/object/yaml/struct.ObjectDef.html b/trayracer/scene/object/yaml/struct.ObjectDef.html index 3ed9cf11..f5344589 100644 --- a/trayracer/scene/object/yaml/struct.ObjectDef.html +++ b/trayracer/scene/object/yaml/struct.ObjectDef.html @@ -1,44 +1,45 @@ -ObjectDef in trayracer::scene::object::yaml - Rust

Struct trayracer::scene::object::yaml::ObjectDef

source · 
pub struct ObjectDef {
-    pub file_path: PathBuf,
-    pub position: Point3<f32>,
-    pub rotation: Vector3<f32>,
-    pub scale: Vector3<f32>,
-}

Fields§

§file_path: PathBuf§position: Point3<f32>§rotation: Vector3<f32>§scale: Vector3<f32>

Trait Implementations§

source§

impl<'de> Deserialize<'de> for ObjectDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for ObjectDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +ObjectDef in trayracer::scene::object::yaml - Rust
trayracer::scene::object::yaml

Struct ObjectDef

source 
pub struct ObjectDef {
+    pub file_path: PathBuf,
+    pub position: Point3<f32>,
+    pub rotation: Vector3<f32>,
+    pub scale: Vector3<f32>,
+}

Fields§

§file_path: PathBuf§position: Point3<f32>§rotation: Vector3<f32>§scale: Vector3<f32>

Trait Implementations§

source§

impl<'de> Deserialize<'de> for ObjectDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for ObjectDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/settings/index.html b/trayracer/scene/settings/index.html index 773f3d86..13a1b5e7 100644 --- a/trayracer/scene/settings/index.html +++ b/trayracer/scene/settings/index.html @@ -1 +1 @@ -trayracer::scene::settings - Rust

Module trayracer::scene::settings

source ·

Modules§

Structs§

\ No newline at end of file +trayracer::scene::settings - Rust
trayracer::scene

Module settings

source

Modules§

Structs§

\ No newline at end of file diff --git a/trayracer/scene/settings/struct.Settings.html b/trayracer/scene/settings/struct.Settings.html index abdb4339..e7452626 100644 --- a/trayracer/scene/settings/struct.Settings.html +++ b/trayracer/scene/settings/struct.Settings.html @@ -1,55 +1,56 @@ -Settings in trayracer::scene::settings - Rust

Struct trayracer::scene::settings::Settings

source · 
pub struct Settings {
-    pub max_bounces: u32,
-    pub samples: u32,
-    pub ambient_color: Vector3<f32>,
-    pub ambient_intensity: f32,
+Settings in trayracer::scene::settings - Rust
trayracer::scene::settings
Struct Settings
source 
pub struct Settings {
+    pub max_bounces: u32,
+    pub samples: u32,
+    pub ambient_color: Vector3<f32>,
+    pub ambient_intensity: f32,
     pub skybox: Skybox,
-    pub anti_aliasing: bool,
-}
Fields§
§max_bounces: u32§samples: u32§ambient_color: Vector3<f32>§ambient_intensity: f32§skybox: Skybox§anti_aliasing: bool
Trait Implementations§
source§
impl Clone for Settings
source§
fn clone(&self) -> Settings
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for Settings
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Default for Settings
source§
fn default() -> Self
Returns the “default value” for a type. Read more
source§
impl<'de> Deserialize<'de> for Settings
source§
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
-    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§
impl PartialEq for Settings
source§
fn eq(&self, other: &Settings) -> bool
This method tests for self and other values to be equal, and is used
-by ==.
1.0.0 · source§
fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always
-sufficient, and should not be overridden without very good reason.
source§
impl Serialize for Settings
source§
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
-    S: Serializer,
Serialize this value into the given Serde serializer. Read more
source§
impl StructuralPartialEq for Settings
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
-    T: Clone,
source§
default unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+    pub anti_aliasing: bool,
+}

Fields§

§max_bounces: u32§samples: u32§ambient_color: Vector3<f32>§ambient_intensity: f32§skybox: Skybox§anti_aliasing: bool

Trait Implementations§

source§

impl Clone for Settings

source§

fn clone(&self) -> Settings

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Settings

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Settings

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Settings

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where + D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Settings

source§

fn eq(&self, other: &Settings) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl Serialize for Settings

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl StructuralPartialEq for Settings

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more

source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/settings/yaml/index.html b/trayracer/scene/settings/yaml/index.html index 5f487fcb..c5f50cb2 100644 --- a/trayracer/scene/settings/yaml/index.html +++ b/trayracer/scene/settings/yaml/index.html @@ -1 +1 @@ -trayracer::scene::settings::yaml - Rust

Module trayracer::scene::settings::yaml

source ·

Structs§

\ No newline at end of file +trayracer::scene::settings::yaml - Rust
trayracer::scene::settings

Module yaml

source

Structs§

\ No newline at end of file diff --git a/trayracer/scene/settings/yaml/struct.SettingsDef.html b/trayracer/scene/settings/yaml/struct.SettingsDef.html index de22a626..e9156b3e 100644 --- a/trayracer/scene/settings/yaml/struct.SettingsDef.html +++ b/trayracer/scene/settings/yaml/struct.SettingsDef.html @@ -1,45 +1,46 @@ -SettingsDef in trayracer::scene::settings::yaml - Rust

Struct trayracer::scene::settings::yaml::SettingsDef

source · 
pub struct SettingsDef {
-    pub max_bounces: u32,
-    pub samples: u32,
-    pub ambient_color: Vector3<f32>,
+SettingsDef in trayracer::scene::settings::yaml - Rust
trayracer::scene::settings::yaml
Struct SettingsDef
source 
pub struct SettingsDef {
+    pub max_bounces: u32,
+    pub samples: u32,
+    pub ambient_color: Vector3<f32>,
     pub skybox: Skybox,
-    pub anti_aliasing: bool,
-}
Fields§
§max_bounces: u32§samples: u32§ambient_color: Vector3<f32>§skybox: Skybox§anti_aliasing: bool
Trait Implementations§
source§
impl<'de> Deserialize<'de> for SettingsDef
source§
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where
-    __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§
impl Serialize for SettingsDef
source§
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where
-    __S: Serializer,
Serialize this value into the given Serde serializer. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+    pub anti_aliasing: bool,
+}

Fields§

§max_bounces: u32§samples: u32§ambient_color: Vector3<f32>§skybox: Skybox§anti_aliasing: bool

Trait Implementations§

source§

impl<'de> Deserialize<'de> for SettingsDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for SettingsDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/skybox/enum.Skybox.html b/trayracer/scene/skybox/enum.Skybox.html index 325b012a..c46d2ab3 100644 --- a/trayracer/scene/skybox/enum.Skybox.html +++ b/trayracer/scene/skybox/enum.Skybox.html @@ -1,54 +1,55 @@ -Skybox in trayracer::scene::skybox - Rust

Enum trayracer::scene::skybox::Skybox

source · 
pub enum Skybox {
+Skybox in trayracer::scene::skybox - Rust
trayracer::scene::skybox
Enum Skybox
source 
pub enum Skybox {
     Image {
-        path: PathBuf,
+        path: PathBuf,
         image: RgbImage,
     },
-    Color(Vector3<f32>),
-}
Variants§
§
Image
Fields
§path: PathBuf
§image: RgbImage
§
Color(Vector3<f32>)
Implementations§
source§
impl Skybox
source
fn load_from_path<P: AsRef<Path>>(path: P) -> Result<Self>
Trait Implementations§
source§
impl Clone for Skybox
source§
fn clone(&self) -> Skybox
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for Skybox
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Default for Skybox
source§
fn default() -> Self
Returns the “default value” for a type. Read more
source§
impl<'de> Deserialize<'de> for Skybox
source§
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
-    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§
impl PartialEq for Skybox
source§
fn eq(&self, other: &Skybox) -> bool
This method tests for self and other values to be equal, and is used
-by ==.
1.0.0 · source§
fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always
-sufficient, and should not be overridden without very good reason.
source§
impl Serialize for Skybox
source§
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
-    S: Serializer,
Serialize this value into the given Serde serializer. Read more
source§
impl StructuralPartialEq for Skybox
Auto Trait Implementations§
§
impl Freeze for Skybox
§
impl RefUnwindSafe for Skybox
§
impl Send for Skybox
§
impl Sync for Skybox
§
impl Unpin for Skybox
§
impl UnwindSafe for Skybox
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
-    T: Clone,
source§
default unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+    Color(Vector3<f32>),
+}

Variants§

§

Image

Fields

§path: PathBuf
§image: RgbImage
§

Color(Vector3<f32>)

Implementations§

source§

impl Skybox

source

fn load_from_path<P: AsRef<Path>>(path: P) -> Result<Self>

Trait Implementations§

source§

impl Clone for Skybox

source§

fn clone(&self) -> Skybox

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Skybox

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for Skybox

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for Skybox

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where + D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for Skybox

source§

fn eq(&self, other: &Skybox) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl Serialize for Skybox

source§

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl StructuralPartialEq for Skybox

Auto Trait Implementations§

§

impl Freeze for Skybox

§

impl RefUnwindSafe for Skybox

§

impl Send for Skybox

§

impl Sync for Skybox

§

impl Unpin for Skybox

§

impl UnwindSafe for Skybox

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more

source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/skybox/index.html b/trayracer/scene/skybox/index.html index 179536fc..08829b96 100644 --- a/trayracer/scene/skybox/index.html +++ b/trayracer/scene/skybox/index.html @@ -1 +1 @@ -trayracer::scene::skybox - Rust

Module trayracer::scene::skybox

source ·

Modules§

Enums§

\ No newline at end of file +trayracer::scene::skybox - Rust
trayracer::scene

Module skybox

source

Modules§

Enums§

\ No newline at end of file diff --git a/trayracer/scene/skybox/yaml/enum.SkyboxDef.html b/trayracer/scene/skybox/yaml/enum.SkyboxDef.html index 49620f87..421fee7c 100644 --- a/trayracer/scene/skybox/yaml/enum.SkyboxDef.html +++ b/trayracer/scene/skybox/yaml/enum.SkyboxDef.html @@ -1,42 +1,43 @@ -SkyboxDef in trayracer::scene::skybox::yaml - Rust

Enum trayracer::scene::skybox::yaml::SkyboxDef

source · 
pub enum SkyboxDef {
-    Path(String),
-    Color(Vector3<f32>),
-}

Variants§

§

Path(String)

§

Color(Vector3<f32>)

Trait Implementations§

source§

impl<'de> Deserialize<'de> for SkyboxDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for SkyboxDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +SkyboxDef in trayracer::scene::skybox::yaml - Rust
trayracer::scene::skybox::yaml

Enum SkyboxDef

source 
pub enum SkyboxDef {
+    Path(String),
+    Color(Vector3<f32>),
+}

Variants§

§

Path(String)

§

Color(Vector3<f32>)

Trait Implementations§

source§

impl<'de> Deserialize<'de> for SkyboxDef

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for SkyboxDef

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/skybox/yaml/index.html b/trayracer/scene/skybox/yaml/index.html index 8a36c356..0e495c2f 100644 --- a/trayracer/scene/skybox/yaml/index.html +++ b/trayracer/scene/skybox/yaml/index.html @@ -1 +1 @@ -trayracer::scene::skybox::yaml - Rust

Module trayracer::scene::skybox::yaml

source ·

Enums§

\ No newline at end of file +trayracer::scene::skybox::yaml - Rust
trayracer::scene::skybox

Module yaml

source

Enums§

\ No newline at end of file diff --git a/trayracer/scene/struct.Scene.html b/trayracer/scene/struct.Scene.html index 6340b3a6..fbad3a3e 100644 --- a/trayracer/scene/struct.Scene.html +++ b/trayracer/scene/struct.Scene.html @@ -1,46 +1,48 @@ -Scene in trayracer::scene - Rust

Struct trayracer::scene::Scene

source · 
pub struct Scene {
-    pub path: PathBuf,
-    pub objects: Vec<Object>,
-    pub lights: Vec<Light>,
+Scene in trayracer::scene - Rust
trayracer::scene
Struct Scene
source 
pub struct Scene {
+    pub path: PathBuf,
+    pub objects: Vec<Object>,
+    pub lights: Vec<Light>,
     pub camera: Camera,
     pub settings: Settings,
-}
Fields§
§path: PathBuf§objects: Vec<Object>§lights: Vec<Light>§camera: Camera§settings: Settings
Implementations§
source§
impl Scene
source
pub fn load<P: AsRef<Path>>(path: P) -> Result<Self>
Trait Implementations§
source§
impl Clone for Scene
source§
fn clone(&self) -> Self
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for Scene
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Serialize for Scene
source§
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where
-    __S: Serializer,
Serialize this value into the given Serde serializer. Read more
Auto Trait Implementations§
§
impl Freeze for Scene
§
impl RefUnwindSafe for Scene
§
impl Send for Scene
§
impl Sync for Scene
§
impl Unpin for Scene
§
impl UnwindSafe for Scene
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§
impl<T> CloneToUninit for T
where
-    T: Clone,
source§
default unsafe fn clone_to_uninit(&self, dst: *mut T)
🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+}

Fields§

§path: PathBuf§objects: Vec<Object>§lights: Vec<Light>§camera: Camera§settings: Settings

Implementations§

source§

impl Scene

source

pub fn load<P: AsRef<Path>>(path: P) -> Result<Self>

Trait Implementations§

source§

impl Clone for Scene

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Scene

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Serialize for Scene

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Scene

§

impl RefUnwindSafe for Scene

§

impl Send for Scene

§

impl Sync for Scene

§

impl Unpin for Scene

§

impl UnwindSafe for Scene

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/struct.WithRelativePath.html b/trayracer/scene/struct.WithRelativePath.html index 8e5971d9..251ca8b5 100644 --- a/trayracer/scene/struct.WithRelativePath.html +++ b/trayracer/scene/struct.WithRelativePath.html @@ -1,44 +1,45 @@ -WithRelativePath in trayracer::scene - Rust

Struct trayracer::scene::WithRelativePath

source · 
struct WithRelativePath<P: AsRef<Path>>(P);

Tuple Fields§

§0: P

Trait Implementations§

source§

impl<'de, P: AsRef<Path> + Sync> DeserializeSeed<'de> for WithRelativePath<P>

§

type Value = Scene

The type produced by using this seed.
source§

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where - D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except -with some initial piece of data (the seed) passed in.

Auto Trait Implementations§

§

impl<P> Freeze for WithRelativePath<P>
where - P: Freeze,

§

impl<P> RefUnwindSafe for WithRelativePath<P>
where - P: RefUnwindSafe,

§

impl<P> Send for WithRelativePath<P>
where - P: Send,

§

impl<P> Sync for WithRelativePath<P>
where - P: Sync,

§

impl<P> Unpin for WithRelativePath<P>
where - P: Unpin,

§

impl<P> UnwindSafe for WithRelativePath<P>
where - P: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +WithRelativePath in trayracer::scene - Rust
trayracer::scene

Struct WithRelativePath

source 
struct WithRelativePath<P: AsRef<Path>>(P);

Tuple Fields§

§0: P

Trait Implementations§

source§

impl<'de, P: AsRef<Path> + Sync> DeserializeSeed<'de> for WithRelativePath<P>

source§

type Value = Scene

The type produced by using this seed.
source§

fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where + D: Deserializer<'de>,

Equivalent to the more common Deserialize::deserialize method, except +with some initial piece of data (the seed) passed in.

Auto Trait Implementations§

§

impl<P> Freeze for WithRelativePath<P>
where + P: Freeze,

§

impl<P> RefUnwindSafe for WithRelativePath<P>
where + P: RefUnwindSafe,

§

impl<P> Send for WithRelativePath<P>
where + P: Send,

§

impl<P> Sync for WithRelativePath<P>
where + P: Sync,

§

impl<P> Unpin for WithRelativePath<P>
where + P: Unpin,

§

impl<P> UnwindSafe for WithRelativePath<P>
where + P: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/triangle/index.html b/trayracer/scene/triangle/index.html index 9c51aeee..7231e44a 100644 --- a/trayracer/scene/triangle/index.html +++ b/trayracer/scene/triangle/index.html @@ -1 +1 @@ -trayracer::scene::triangle - Rust

Module trayracer::scene::triangle

source ·

Structs§

\ No newline at end of file +trayracer::scene::triangle - Rust
trayracer::scene

Module triangle

source

Structs§

\ No newline at end of file diff --git a/trayracer/scene/triangle/struct.Triangle.html b/trayracer/scene/triangle/struct.Triangle.html index 81797422..5d590efe 100644 --- a/trayracer/scene/triangle/struct.Triangle.html +++ b/trayracer/scene/triangle/struct.Triangle.html @@ -1,66 +1,67 @@ -Triangle in trayracer::scene::triangle - Rust

Struct trayracer::scene::triangle::Triangle

source · 
pub struct Triangle {
-    pub a: Point3<f32>,
-    pub b: Point3<f32>,
-    pub c: Point3<f32>,
-    pub a_normal: Vector3<f32>,
-    pub b_normal: Vector3<f32>,
-    pub c_normal: Vector3<f32>,
-    pub a_uv: Vector2<f32>,
-    pub b_uv: Vector2<f32>,
-    pub c_uv: Vector2<f32>,
-    pub material_index: Option<usize>,
-    bvh_index: usize,
-}

Fields§

§a: Point3<f32>§b: Point3<f32>§c: Point3<f32>§a_normal: Vector3<f32>§b_normal: Vector3<f32>§c_normal: Vector3<f32>§a_uv: Vector2<f32>§b_uv: Vector2<f32>§c_uv: Vector2<f32>§material_index: Option<usize>§bvh_index: usize

Implementations§

source§

impl Triangle

source

pub const fn new( - a: Point3<f32>, - b: Point3<f32>, - c: Point3<f32>, - a_normal: Vector3<f32>, - b_normal: Vector3<f32>, - c_normal: Vector3<f32>, - a_uv: Vector2<f32>, - b_uv: Vector2<f32>, - c_uv: Vector2<f32>, - material_index: Option<usize>, -) -> Self

source

pub fn intersect(&self, ray: Ray, delta: f32) -> Option<(f32, f32, f32)>

return barycentric coordinates if ray intersects triangle

-

Trait Implementations§

source§

impl BHShape<f32, 3> for Triangle

source§

fn set_bh_node_index(&mut self, index: usize)

Sets the index of the referenced BoundingHierarchy node.
source§

fn bh_node_index(&self) -> usize

Gets the index of the referenced BoundingHierarchy node.
source§

impl Bounded<f32, 3> for Triangle

source§

fn aabb(&self) -> Aabb<f32, 3>

Returns the geometric bounds of this object in the form of an Aabb. Read more
source§

impl Clone for Triangle

source§

fn clone(&self) -> Triangle

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Triangle

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl PartialEq for Triangle

source§

fn eq(&self, other: &Triangle) -> bool

This method tests for self and other values to be equal, and is used -by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl StructuralPartialEq for Triangle

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Triangle in trayracer::scene::triangle - Rust
trayracer::scene::triangle

Struct Triangle

source 
pub struct Triangle {
+    pub a: Point3<f32>,
+    pub b: Point3<f32>,
+    pub c: Point3<f32>,
+    pub a_normal: Vector3<f32>,
+    pub b_normal: Vector3<f32>,
+    pub c_normal: Vector3<f32>,
+    pub a_uv: Vector2<f32>,
+    pub b_uv: Vector2<f32>,
+    pub c_uv: Vector2<f32>,
+    pub material_index: Option<usize>,
+    bvh_index: usize,
+}

Fields§

§a: Point3<f32>§b: Point3<f32>§c: Point3<f32>§a_normal: Vector3<f32>§b_normal: Vector3<f32>§c_normal: Vector3<f32>§a_uv: Vector2<f32>§b_uv: Vector2<f32>§c_uv: Vector2<f32>§material_index: Option<usize>§bvh_index: usize

Implementations§

source§

impl Triangle

source

pub const fn new( + a: Point3<f32>, + b: Point3<f32>, + c: Point3<f32>, + a_normal: Vector3<f32>, + b_normal: Vector3<f32>, + c_normal: Vector3<f32>, + a_uv: Vector2<f32>, + b_uv: Vector2<f32>, + c_uv: Vector2<f32>, + material_index: Option<usize>, +) -> Self

source

pub fn intersect(&self, ray: Ray, delta: f32) -> Option<(f32, f32, f32)>

return barycentric coordinates if ray intersects triangle

+

Trait Implementations§

source§

impl BHShape<f32, 3> for Triangle

source§

fn set_bh_node_index(&mut self, index: usize)

Sets the index of the referenced BoundingHierarchy node.
source§

fn bh_node_index(&self) -> usize

Gets the index of the referenced BoundingHierarchy node.
source§

impl Bounded<f32, 3> for Triangle

source§

fn aabb(&self) -> Aabb<f32, 3>

Returns the geometric bounds of this object in the form of an Aabb. Read more
source§

impl Clone for Triangle

source§

fn clone(&self) -> Triangle

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for Triangle

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl PartialEq for Triangle

source§

fn eq(&self, other: &Triangle) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl StructuralPartialEq for Triangle

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> Scalar for T
where - T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

source§

impl<T> Scalar for T
where + T: 'static + Clone + PartialEq + Debug,

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/type.Color.html b/trayracer/scene/type.Color.html index de2eca8f..d9f7540b 100644 --- a/trayracer/scene/type.Color.html +++ b/trayracer/scene/type.Color.html @@ -1,7 +1,7 @@ -Color in trayracer::scene - Rust

Type Alias trayracer::scene::Color

source · 
pub type Color = Vector3<f32>;

Aliased Type§

struct Color {
-    pub data: ArrayStorage<f32, 3, 1>,
+Color in trayracer::scene - Rust
trayracer::scene
Type Alias Color
source 
pub type Color = Vector3<f32>;
Aliased Type§
struct Color {
+    pub data: ArrayStorage<f32, 3, 1>,
     /* private fields */
-}
Fields§
§data: ArrayStorage<f32, 3, 1>
The data storage that contains all the matrix components. Disappointed?

+}

Fields§

§data: ArrayStorage<f32, 3, 1>

The data storage that contains all the matrix components. Disappointed?

Well, if you came here to see how you can access the matrix components, you may be in luck: you can access the individual components of all vectors with compile-time dimensions <= 6 using field notation like this: diff --git a/trayracer/scene/yaml/color/fn.deserialize.html b/trayracer/scene/yaml/color/fn.deserialize.html index 01358981..c8b11595 100644 --- a/trayracer/scene/yaml/color/fn.deserialize.html +++ b/trayracer/scene/yaml/color/fn.deserialize.html @@ -1,2 +1,2 @@ -deserialize in trayracer::scene::yaml::color - Rust

Function trayracer::scene::yaml::color::deserialize

source · 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vector3<f32>, D::Error>
where
-    D: Deserializer<'de>,
\ No newline at end of file +deserialize in trayracer::scene::yaml::color - Rust
trayracer::scene::yaml::color

Function deserialize

source 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vector3<f32>, D::Error>
where
+    D: Deserializer<'de>,
\ No newline at end of file diff --git a/trayracer/scene/yaml/color/fn.serialize.html b/trayracer/scene/yaml/color/fn.serialize.html index 387a1eef..e6c19268 100644 --- a/trayracer/scene/yaml/color/fn.serialize.html +++ b/trayracer/scene/yaml/color/fn.serialize.html @@ -1,5 +1,5 @@ -serialize in trayracer::scene::yaml::color - Rust

Function trayracer::scene::yaml::color::serialize

source · 
pub fn serialize<S>(
-    color: &Vector3<f32>,
+serialize in trayracer::scene::yaml::color - Rust
trayracer::scene::yaml::color
Function serialize
source 
pub fn serialize<S>(
+    color: &Vector3<f32>,
     serializer: S,
-) -> Result<S::Ok, S::Error>
where
-    S: Serializer,

\ No newline at end of file
+) -> Result<S::Ok, S::Error>
where
+    S: Serializer,
\ No newline at end of file diff --git a/trayracer/scene/yaml/color/index.html b/trayracer/scene/yaml/color/index.html index 7e51fc7a..8869e2f2 100644 --- a/trayracer/scene/yaml/color/index.html +++ b/trayracer/scene/yaml/color/index.html @@ -1,2 +1,2 @@ -trayracer::scene::yaml::color - Rust

Module trayracer::scene::yaml::color

source ·
Expand description

provide (de)serialization for Color (aka. Vector3) from r,g,b fields

+trayracer::scene::yaml::color - Rust
trayracer::scene::yaml

Module color

source
Expand description

provide (de)serialization for Color (aka. Vector3) from r,g,b fields

Structs§

Functions§

\ No newline at end of file diff --git a/trayracer/scene/yaml/color/struct.Yaml.html b/trayracer/scene/yaml/color/struct.Yaml.html index d5a614f5..e6125a50 100644 --- a/trayracer/scene/yaml/color/struct.Yaml.html +++ b/trayracer/scene/yaml/color/struct.Yaml.html @@ -1,43 +1,44 @@ -Yaml in trayracer::scene::yaml::color - Rust

Struct trayracer::scene::yaml::color::Yaml

source · 
struct Yaml {
-    r: f32,
-    g: f32,
-    b: f32,
-}

Fields§

§r: f32§g: f32§b: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Yaml in trayracer::scene::yaml::color - Rust
trayracer::scene::yaml::color

Struct Yaml

source 
struct Yaml {
+    r: f32,
+    g: f32,
+    b: f32,
+}

Fields§

§r: f32§g: f32§b: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/yaml/index.html b/trayracer/scene/yaml/index.html index 3ce380fd..6919f283 100644 --- a/trayracer/scene/yaml/index.html +++ b/trayracer/scene/yaml/index.html @@ -1 +1 @@ -trayracer::scene::yaml - Rust

Module trayracer::scene::yaml

source ·

Modules§

  • color
    provide (de)serialization for Color (aka. Vector3) from r,g,b fields
  • point
    provide (de)serialization for Point3 from x,y,z fields
  • vector
    provide (de)serialization for Vector3 from x,y,z fields
\ No newline at end of file +trayracer::scene::yaml - Rust
trayracer::scene

Module yaml

source

Modules§

  • color
    provide (de)serialization for Color (aka. Vector3) from r,g,b fields
  • point
    provide (de)serialization for Point3 from x,y,z fields
  • vector
    provide (de)serialization for Vector3 from x,y,z fields
\ No newline at end of file diff --git a/trayracer/scene/yaml/point/fn.deserialize.html b/trayracer/scene/yaml/point/fn.deserialize.html index 1bdb03bc..18fea8d6 100644 --- a/trayracer/scene/yaml/point/fn.deserialize.html +++ b/trayracer/scene/yaml/point/fn.deserialize.html @@ -1,2 +1,2 @@ -deserialize in trayracer::scene::yaml::point - Rust

Function trayracer::scene::yaml::point::deserialize

source · 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Point3<f32>, D::Error>
where
-    D: Deserializer<'de>,
\ No newline at end of file +deserialize in trayracer::scene::yaml::point - Rust
trayracer::scene::yaml::point

Function deserialize

source 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Point3<f32>, D::Error>
where
+    D: Deserializer<'de>,
\ No newline at end of file diff --git a/trayracer/scene/yaml/point/fn.serialize.html b/trayracer/scene/yaml/point/fn.serialize.html index 13fdbadd..ed30c706 100644 --- a/trayracer/scene/yaml/point/fn.serialize.html +++ b/trayracer/scene/yaml/point/fn.serialize.html @@ -1,5 +1,5 @@ -serialize in trayracer::scene::yaml::point - Rust

Function trayracer::scene::yaml::point::serialize

source · 
pub fn serialize<S>(
-    point: &Point3<f32>,
+serialize in trayracer::scene::yaml::point - Rust
trayracer::scene::yaml::point
Function serialize
source 
pub fn serialize<S>(
+    point: &Point3<f32>,
     serializer: S,
-) -> Result<S::Ok, S::Error>
where
-    S: Serializer,

\ No newline at end of file
+) -> Result<S::Ok, S::Error>
where
+    S: Serializer,
\ No newline at end of file diff --git a/trayracer/scene/yaml/point/index.html b/trayracer/scene/yaml/point/index.html index 2cbb62ab..923ba3ba 100644 --- a/trayracer/scene/yaml/point/index.html +++ b/trayracer/scene/yaml/point/index.html @@ -1,2 +1,2 @@ -trayracer::scene::yaml::point - Rust

Module trayracer::scene::yaml::point

source ·
Expand description

provide (de)serialization for Point3 from x,y,z fields

+trayracer::scene::yaml::point - Rust
trayracer::scene::yaml

Module point

source
Expand description

provide (de)serialization for Point3 from x,y,z fields

Structs§

Functions§

\ No newline at end of file diff --git a/trayracer/scene/yaml/point/struct.Yaml.html b/trayracer/scene/yaml/point/struct.Yaml.html index 1b3d7b3c..35adfc62 100644 --- a/trayracer/scene/yaml/point/struct.Yaml.html +++ b/trayracer/scene/yaml/point/struct.Yaml.html @@ -1,43 +1,44 @@ -Yaml in trayracer::scene::yaml::point - Rust

Struct trayracer::scene::yaml::point::Yaml

source · 
struct Yaml {
-    x: f32,
-    y: f32,
-    z: f32,
-}

Fields§

§x: f32§y: f32§z: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Yaml in trayracer::scene::yaml::point - Rust
trayracer::scene::yaml::point

Struct Yaml

source 
struct Yaml {
+    x: f32,
+    y: f32,
+    z: f32,
+}

Fields§

§x: f32§y: f32§z: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/scene/yaml/vector/fn.deserialize.html b/trayracer/scene/yaml/vector/fn.deserialize.html index 18fcb778..17a9f353 100644 --- a/trayracer/scene/yaml/vector/fn.deserialize.html +++ b/trayracer/scene/yaml/vector/fn.deserialize.html @@ -1,2 +1,2 @@ -deserialize in trayracer::scene::yaml::vector - Rust

Function trayracer::scene::yaml::vector::deserialize

source · 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vector3<f32>, D::Error>
where
-    D: Deserializer<'de>,
\ No newline at end of file +deserialize in trayracer::scene::yaml::vector - Rust
trayracer::scene::yaml::vector

Function deserialize

source 
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vector3<f32>, D::Error>
where
+    D: Deserializer<'de>,
\ No newline at end of file diff --git a/trayracer/scene/yaml/vector/fn.serialize.html b/trayracer/scene/yaml/vector/fn.serialize.html index ed5a28e8..e202fc62 100644 --- a/trayracer/scene/yaml/vector/fn.serialize.html +++ b/trayracer/scene/yaml/vector/fn.serialize.html @@ -1,5 +1,5 @@ -serialize in trayracer::scene::yaml::vector - Rust

Function trayracer::scene::yaml::vector::serialize

source · 
pub fn serialize<S>(
-    point: &Vector3<f32>,
+serialize in trayracer::scene::yaml::vector - Rust
trayracer::scene::yaml::vector
Function serialize
source 
pub fn serialize<S>(
+    point: &Vector3<f32>,
     serializer: S,
-) -> Result<S::Ok, S::Error>
where
-    S: Serializer,

\ No newline at end of file
+) -> Result<S::Ok, S::Error>
where
+    S: Serializer,
\ No newline at end of file diff --git a/trayracer/scene/yaml/vector/index.html b/trayracer/scene/yaml/vector/index.html index f65cc969..bf31ab2a 100644 --- a/trayracer/scene/yaml/vector/index.html +++ b/trayracer/scene/yaml/vector/index.html @@ -1,2 +1,2 @@ -trayracer::scene::yaml::vector - Rust

Module trayracer::scene::yaml::vector

source ·
Expand description

provide (de)serialization for Vector3 from x,y,z fields

+trayracer::scene::yaml::vector - Rust
trayracer::scene::yaml

Module vector

source
Expand description

provide (de)serialization for Vector3 from x,y,z fields

Structs§

Functions§

\ No newline at end of file diff --git a/trayracer/scene/yaml/vector/struct.Yaml.html b/trayracer/scene/yaml/vector/struct.Yaml.html index 825d2b64..f36f5ca1 100644 --- a/trayracer/scene/yaml/vector/struct.Yaml.html +++ b/trayracer/scene/yaml/vector/struct.Yaml.html @@ -1,43 +1,44 @@ -Yaml in trayracer::scene::yaml::vector - Rust

Struct trayracer::scene::yaml::vector::Yaml

source · 
struct Yaml {
-    x: f32,
-    y: f32,
-    z: f32,
-}

Fields§

§x: f32§y: f32§z: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +Yaml in trayracer::scene::yaml::vector - Rust
trayracer::scene::yaml::vector

Struct Yaml

source 
struct Yaml {
+    x: f32,
+    y: f32,
+    z: f32,
+}

Fields§

§x: f32§y: f32§z: f32

Trait Implementations§

source§

impl<'de> Deserialize<'de> for Yaml

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Serialize for Yaml

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more

Auto Trait Implementations§

§

impl Freeze for Yaml

§

impl RefUnwindSafe for Yaml

§

impl Send for Yaml

§

impl Sync for Yaml

§

impl Unpin for Yaml

§

impl UnwindSafe for Yaml

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
source§

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/static._RUST_I18N_BACKEND.html b/trayracer/static._RUST_I18N_BACKEND.html index 49f5f5eb..322ca95a 100644 --- a/trayracer/static._RUST_I18N_BACKEND.html +++ b/trayracer/static._RUST_I18N_BACKEND.html @@ -1,3 +1,3 @@ -_RUST_I18N_BACKEND in trayracer - Rust

Static trayracer::_RUST_I18N_BACKEND

source · 
pub(crate) static _RUST_I18N_BACKEND: Lazy<Box<dyn Backend>>
Expand description

I18n backend instance

+_RUST_I18N_BACKEND in trayracer - Rust
trayracer

Static _RUST_I18N_BACKEND

source 
pub(crate) static _RUST_I18N_BACKEND: Lazy<Box<dyn Backend>>
Expand description

I18n backend instance

[PUBLIC] This is a public API, and as an example in examples/

\ No newline at end of file diff --git a/trayracer/static._RUST_I18N_FALLBACK_LOCALE.html b/trayracer/static._RUST_I18N_FALLBACK_LOCALE.html index 60e542ba..8dd66c4d 100644 --- a/trayracer/static._RUST_I18N_FALLBACK_LOCALE.html +++ b/trayracer/static._RUST_I18N_FALLBACK_LOCALE.html @@ -1 +1 @@ -_RUST_I18N_FALLBACK_LOCALE in trayracer - Rust

Static trayracer::_RUST_I18N_FALLBACK_LOCALE

source · 
pub(crate) static _RUST_I18N_FALLBACK_LOCALE: Option<&[&'static str]>
\ No newline at end of file +_RUST_I18N_FALLBACK_LOCALE in trayracer - Rust
trayracer

Static _RUST_I18N_FALLBACK_LOCALE

source 
pub(crate) static _RUST_I18N_FALLBACK_LOCALE: Option<&[&'static str]>
\ No newline at end of file diff --git a/trayracer/static._RUST_I18N_MINIFY_KEY.html b/trayracer/static._RUST_I18N_MINIFY_KEY.html index 0eb56bb6..09a7223f 100644 --- a/trayracer/static._RUST_I18N_MINIFY_KEY.html +++ b/trayracer/static._RUST_I18N_MINIFY_KEY.html @@ -1 +1 @@ -_RUST_I18N_MINIFY_KEY in trayracer - Rust

Static trayracer::_RUST_I18N_MINIFY_KEY

source · 
pub(crate) static _RUST_I18N_MINIFY_KEY: bool
\ No newline at end of file +_RUST_I18N_MINIFY_KEY in trayracer - Rust
trayracer

Static _RUST_I18N_MINIFY_KEY

source 
pub(crate) static _RUST_I18N_MINIFY_KEY: bool
\ No newline at end of file diff --git a/trayracer/static._RUST_I18N_MINIFY_KEY_LEN.html b/trayracer/static._RUST_I18N_MINIFY_KEY_LEN.html index 6dca3603..0187f185 100644 --- a/trayracer/static._RUST_I18N_MINIFY_KEY_LEN.html +++ b/trayracer/static._RUST_I18N_MINIFY_KEY_LEN.html @@ -1 +1 @@ -_RUST_I18N_MINIFY_KEY_LEN in trayracer - Rust

Static trayracer::_RUST_I18N_MINIFY_KEY_LEN

source · 
pub(crate) static _RUST_I18N_MINIFY_KEY_LEN: usize
\ No newline at end of file +_RUST_I18N_MINIFY_KEY_LEN in trayracer - Rust
trayracer

Static _RUST_I18N_MINIFY_KEY_LEN

source 
pub(crate) static _RUST_I18N_MINIFY_KEY_LEN: usize
\ No newline at end of file diff --git a/trayracer/static._RUST_I18N_MINIFY_KEY_PREFIX.html b/trayracer/static._RUST_I18N_MINIFY_KEY_PREFIX.html index 0f466720..cbe05282 100644 --- a/trayracer/static._RUST_I18N_MINIFY_KEY_PREFIX.html +++ b/trayracer/static._RUST_I18N_MINIFY_KEY_PREFIX.html @@ -1 +1 @@ -_RUST_I18N_MINIFY_KEY_PREFIX in trayracer - Rust

Static trayracer::_RUST_I18N_MINIFY_KEY_PREFIX

source · 
pub(crate) static _RUST_I18N_MINIFY_KEY_PREFIX: &str
\ No newline at end of file +_RUST_I18N_MINIFY_KEY_PREFIX in trayracer - Rust
trayracer

Static _RUST_I18N_MINIFY_KEY_PREFIX

source 
pub(crate) static _RUST_I18N_MINIFY_KEY_PREFIX: &str
\ No newline at end of file diff --git a/trayracer/static._RUST_I18N_MINIFY_KEY_THRESH.html b/trayracer/static._RUST_I18N_MINIFY_KEY_THRESH.html index ea866524..fd4cc5ab 100644 --- a/trayracer/static._RUST_I18N_MINIFY_KEY_THRESH.html +++ b/trayracer/static._RUST_I18N_MINIFY_KEY_THRESH.html @@ -1 +1 @@ -_RUST_I18N_MINIFY_KEY_THRESH in trayracer - Rust

Static trayracer::_RUST_I18N_MINIFY_KEY_THRESH

source · 
pub(crate) static _RUST_I18N_MINIFY_KEY_THRESH: usize
\ No newline at end of file +_RUST_I18N_MINIFY_KEY_THRESH in trayracer - Rust
trayracer

Static _RUST_I18N_MINIFY_KEY_THRESH

source 
pub(crate) static _RUST_I18N_MINIFY_KEY_THRESH: usize
\ No newline at end of file diff --git a/trayracer/ui/enum.Tab.html b/trayracer/ui/enum.Tab.html index a19c8a23..883168a4 100644 --- a/trayracer/ui/enum.Tab.html +++ b/trayracer/ui/enum.Tab.html @@ -1,41 +1,41 @@ -Tab in trayracer::ui - Rust

Enum trayracer::ui::Tab

source · 
enum Tab {
+Tab in trayracer::ui - Rust
trayracer::ui
Enum Tab
source 
enum Tab {
     Preview,
     RenderResult,
-}
Variants§
§
Preview
§
RenderResult
Trait Implementations§
source§
impl PartialEq for Tab
source§
fn eq(&self, other: &Tab) -> bool
This method tests for self and other values to be equal, and is used
-by ==.
1.0.0 · source§
fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always
-sufficient, and should not be overridden without very good reason.
source§
impl StructuralPartialEq for Tab
Auto Trait Implementations§
§
impl Freeze for Tab
§
impl RefUnwindSafe for Tab
§
impl Send for Tab
§
impl Sync for Tab
§
impl Unpin for Tab
§
impl UnwindSafe for Tab
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+}

Variants§

§

Preview

§

RenderResult

Trait Implementations§

source§

impl PartialEq for Tab

source§

fn eq(&self, other: &Tab) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, +and should not be overridden without very good reason.
source§

impl StructuralPartialEq for Tab

Auto Trait Implementations§

§

impl Freeze for Tab

§

impl RefUnwindSafe for Tab

§

impl Send for Tab

§

impl Sync for Tab

§

impl Unpin for Tab

§

impl UnwindSafe for Tab

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/index.html b/trayracer/ui/index.html index ac181b6e..bcf91954 100644 --- a/trayracer/ui/index.html +++ b/trayracer/ui/index.html @@ -1,2 +1,2 @@ -trayracer::ui - Rust

Module trayracer::ui

source ·

Modules§

Structs§

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/preview/gpu/struct.ShaderLight.html b/trayracer/ui/preview/gpu/struct.ShaderLight.html index 8943f641..49fda463 100644 --- a/trayracer/ui/preview/gpu/struct.ShaderLight.html +++ b/trayracer/ui/preview/gpu/struct.ShaderLight.html @@ -1,54 +1,55 @@ -ShaderLight in trayracer::ui::preview::gpu - Rust

Struct trayracer::ui::preview::gpu::ShaderLight

source · 
#[repr(C, align(16))]
struct ShaderLight {
-    position: [f32; 3],
-    _pad: [f32; 1],
-    color: [f32; 3],
-    intensity: f32,
-}

Fields§

§position: [f32; 3]§_pad: [f32; 1]§color: [f32; 3]§intensity: f32

Trait Implementations§

source§

impl Clone for ShaderLight

source§

fn clone(&self) -> ShaderLight

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for ShaderLight

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for ShaderLight

source§

fn default() -> ShaderLight

Returns the “default value” for a type. Read more
source§

impl Zeroable for ShaderLight

§

fn zeroed() -> Self

Calls zeroed. Read more
source§

impl Copy for ShaderLight

source§

impl Pod for ShaderLight

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CheckedBitPattern for T
where +ShaderLight in trayracer::ui::preview::gpu - Rust
trayracer::ui::preview::gpu

Struct ShaderLight

source 
#[repr(C, align(16))]
struct ShaderLight {
+    position: [f32; 3],
+    _pad: [f32; 1],
+    color: [f32; 3],
+    intensity: f32,
+}

Fields§

§position: [f32; 3]§_pad: [f32; 1]§color: [f32; 3]§intensity: f32

Trait Implementations§

source§

impl Clone for ShaderLight

source§

fn clone(&self) -> ShaderLight

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for ShaderLight

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for ShaderLight

source§

fn default() -> ShaderLight

Returns the “default value” for a type. Read more
source§

impl Zeroable for ShaderLight

§

fn zeroed() -> Self

Calls zeroed. Read more
source§

impl Copy for ShaderLight

source§

impl Pod for ShaderLight

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CheckedBitPattern for T
where T: AnyBitPattern,

§

type Bits = T

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during -is_valid_bit_pattern.
§

fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret bits -as &Self.
source§

impl<T> CloneToUninit for T
where - T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +is_valid_bit_pattern.
§

fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret bits +as &Self.
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> AnyBitPattern for T
where - T: Pod,

§

impl<T> NoUninit for T
where + T: Pod,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> NoUninit for T
where T: Pod,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/preview/gpu/struct.ShaderUniforms.html b/trayracer/ui/preview/gpu/struct.ShaderUniforms.html index 403ab7ce..6a4190fc 100644 --- a/trayracer/ui/preview/gpu/struct.ShaderUniforms.html +++ b/trayracer/ui/preview/gpu/struct.ShaderUniforms.html @@ -1,55 +1,56 @@ -ShaderUniforms in trayracer::ui::preview::gpu - Rust

Struct trayracer::ui::preview::gpu::ShaderUniforms

source · 
#[repr(C, align(16))]
struct ShaderUniforms {
-    view: [[f32; 4]; 4],
-    lights_count: u32,
-    _pad: [u32; 3],
-    ambient_color: [f32; 3],
-    ambient_intensity: f32,
-}

Fields§

§view: [[f32; 4]; 4]§lights_count: u32§_pad: [u32; 3]§ambient_color: [f32; 3]§ambient_intensity: f32

Trait Implementations§

source§

impl Clone for ShaderUniforms

source§

fn clone(&self) -> ShaderUniforms

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for ShaderUniforms

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for ShaderUniforms

source§

fn default() -> ShaderUniforms

Returns the “default value” for a type. Read more
source§

impl Zeroable for ShaderUniforms

§

fn zeroed() -> Self

Calls zeroed. Read more
source§

impl Copy for ShaderUniforms

source§

impl Pod for ShaderUniforms

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CheckedBitPattern for T
where +ShaderUniforms in trayracer::ui::preview::gpu - Rust
trayracer::ui::preview::gpu

Struct ShaderUniforms

source 
#[repr(C, align(16))]
struct ShaderUniforms {
+    view: [[f32; 4]; 4],
+    lights_count: u32,
+    _pad: [u32; 3],
+    ambient_color: [f32; 3],
+    ambient_intensity: f32,
+}

Fields§

§view: [[f32; 4]; 4]§lights_count: u32§_pad: [u32; 3]§ambient_color: [f32; 3]§ambient_intensity: f32

Trait Implementations§

source§

impl Clone for ShaderUniforms

source§

fn clone(&self) -> ShaderUniforms

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for ShaderUniforms

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for ShaderUniforms

source§

fn default() -> ShaderUniforms

Returns the “default value” for a type. Read more
source§

impl Zeroable for ShaderUniforms

§

fn zeroed() -> Self

Calls zeroed. Read more
source§

impl Copy for ShaderUniforms

source§

impl Pod for ShaderUniforms

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CheckedBitPattern for T
where T: AnyBitPattern,

§

type Bits = T

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during -is_valid_bit_pattern.
§

fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret bits -as &Self.
source§

impl<T> CloneToUninit for T
where - T: Copy,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +is_valid_bit_pattern.
§

fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret bits +as &Self.
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> NoneValue for T
where - T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where - R: Read + ReadEndian<P>, - P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where + T: Default,

§

type NoneType = T

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<R, P> ReadPrimitive<R> for P
where + R: Read + ReadEndian<P>, + P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> AnyBitPattern for T
where - T: Pod,

§

impl<T> NoUninit for T
where + T: Pod,

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> NoUninit for T
where T: Pod,

§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/preview/gpu/struct.VertexCount.html b/trayracer/ui/preview/gpu/struct.VertexCount.html index a49830d0..9a378003 100644 --- a/trayracer/ui/preview/gpu/struct.VertexCount.html +++ b/trayracer/ui/preview/gpu/struct.VertexCount.html @@ -1,36 +1,37 @@ -VertexCount in trayracer::ui::preview::gpu - Rust

Struct trayracer::ui::preview::gpu::VertexCount

source · 
struct VertexCount(usize);

Tuple Fields§

§0: usize

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +VertexCount in trayracer::ui::preview::gpu - Rust
trayracer::ui::preview::gpu

Struct VertexCount

source 
struct VertexCount(usize);

Tuple Fields§

§0: usize

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/preview/gpu/struct.WgpuPainter.html b/trayracer/ui/preview/gpu/struct.WgpuPainter.html index 4b5c8ab8..85b311a8 100644 --- a/trayracer/ui/preview/gpu/struct.WgpuPainter.html +++ b/trayracer/ui/preview/gpu/struct.WgpuPainter.html @@ -1,16 +1,16 @@ -WgpuPainter in trayracer::ui::preview::gpu - Rust

Struct trayracer::ui::preview::gpu::WgpuPainter

source · 
pub struct WgpuPainter {
-    scene: Arc<RwLock<Option<Scene>>>,
-}

Fields§

§scene: Arc<RwLock<Option<Scene>>>

Implementations§

source§

impl WgpuPainter

source

const MAX_LIGHTS: usize = 255usize

source

const MAX_OBJECTS: usize = 255usize

source

pub const fn new(scene: Arc<RwLock<Option<Scene>>>) -> Self

Trait Implementations§

source§

impl CallbackTrait for WgpuPainter

source§

fn prepare( +WgpuPainter in trayracer::ui::preview::gpu - Rust
trayracer::ui::preview::gpu

Struct WgpuPainter

source 
pub struct WgpuPainter {
+    scene: Arc<RwLock<Option<Scene>>>,
+}

Fields§

§scene: Arc<RwLock<Option<Scene>>>

Implementations§

source§

impl WgpuPainter

source

const MAX_LIGHTS: usize = 255usize

source

const MAX_OBJECTS: usize = 255usize

source

pub const fn new(scene: Arc<RwLock<Option<Scene>>>) -> Self

Trait Implementations§

source§

impl CallbackTrait for WgpuPainter

source§

fn prepare( &self, device: &Device, queue: &Queue, _screen_descriptor: &ScreenDescriptor, _egui_encoder: &mut CommandEncoder, callback_resources: &mut CallbackResources, -) -> Vec<CommandBuffer>

source§

fn paint<'a>( +) -> Vec<CommandBuffer>

source§

fn paint<'a>( &'a self, _info: PaintCallbackInfo, - render_pass: &mut RenderPass<'a>, + render_pass: &mut RenderPass<'static>, callback_resources: &'a CallbackResources, )

Called after all [CallbackTrait::finish_prepare] calls are done. Read more
§

fn finish_prepare( &self, @@ -18,42 +18,44 @@ _queue: &Queue, _egui_encoder: &mut CommandEncoder, _callback_resources: &mut TypeMap, -) -> Vec<CommandBuffer>

Called after all [CallbackTrait::prepare] calls are done.
source§

impl Clone for WgpuPainter

source§

fn clone(&self) -> WgpuPainter

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +) -> Vec<CommandBuffer>

Called after all [CallbackTrait::prepare] calls are done.
source§

impl Clone for WgpuPainter

source§

fn clone(&self) -> WgpuPainter

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/preview/index.html b/trayracer/ui/preview/index.html index fa730524..986b3b1c 100644 --- a/trayracer/ui/preview/index.html +++ b/trayracer/ui/preview/index.html @@ -1 +1 @@ -trayracer::ui::preview - Rust

Module trayracer::ui::preview

source ·

Modules§

Structs§

\ No newline at end of file +trayracer::ui::preview - Rust
trayracer::ui

Module preview

source

Modules§

Structs§

\ No newline at end of file diff --git a/trayracer/ui/preview/struct.Preview.html b/trayracer/ui/preview/struct.Preview.html index 509ac88c..20b1c17c 100644 --- a/trayracer/ui/preview/struct.Preview.html +++ b/trayracer/ui/preview/struct.Preview.html @@ -1,50 +1,52 @@ -Preview in trayracer::ui::preview - Rust

Struct trayracer::ui::preview::Preview

source · 
pub struct Preview {
-    active: bool,
-    speed: f32,
-    sensitivity: f32,
+Preview in trayracer::ui::preview - Rust
trayracer::ui::preview
Struct Preview
source 
pub struct Preview {
+    active: bool,
+    speed: f32,
+    sensitivity: f32,
     gpu: WgpuPainter,
-    dropped_files: Vec<DroppedFile>,
-}
Fields§
§active: bool§speed: f32§sensitivity: f32§gpu: WgpuPainter§dropped_files: Vec<DroppedFile>
Implementations§
source§
impl Preview
source
pub const fn new(scene: Arc<RwLock<Option<Scene>>>) -> Self
source
fn change_preview_movement(
+    dropped_files: Vec<DroppedFile>,
+}

Fields§

§active: bool§speed: f32§sensitivity: f32§gpu: WgpuPainter§dropped_files: Vec<DroppedFile>

Implementations§

source§

impl Preview

source

pub const fn new(scene: Arc<RwLock<Option<Scene>>>) -> Self

source

fn change_preview_movement( &mut self, ui: &Ui, response: &Response, - active: bool, -)

source

pub fn show(&mut self, ui: &mut Ui, scene: &mut Option<Scene>)

source

fn handle_file(path: &PathBuf, scene: &mut Option<Scene>)

source

pub fn show_hover_overlay(ctx: &Context, scene: &Option<Scene>, rect: Rect)

source

fn move_camera(&mut self, ui: &Ui, response: &Response, scene: &mut Scene)

Trait Implementations§

source§

impl Clone for Preview

source§

fn clone(&self) -> Preview

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where - T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot + active: bool, +)
source

pub fn show(&mut self, ui: &mut Ui, scene: &mut Option<Scene>)

source

fn handle_file(path: &PathBuf, scene: &mut Option<Scene>)

source

pub fn show_hover_overlay(ctx: &Context, scene: Option<&Scene>, rect: Rect)

source

fn move_camera(&mut self, ui: &Ui, response: &Response, scene: &mut Scene)

Trait Implementations§

source§

impl Clone for Preview

source§

fn clone(&self) -> Preview

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where + T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> DynClone for T
where + T: Clone,

source§

fn __clone_box(&self, _: Private) -> *mut ()

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where - T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T> ToOwned for T
where + T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> SerializableAny for T
where - T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more

§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> SerializableAny for T
where + T: 'static + Any + Clone + for<'a> Send + Sync,

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/properties/fn.xyz_drag_value.html b/trayracer/ui/properties/fn.xyz_drag_value.html index 9697af97..defb2746 100644 --- a/trayracer/ui/properties/fn.xyz_drag_value.html +++ b/trayracer/ui/properties/fn.xyz_drag_value.html @@ -1 +1 @@ -xyz_drag_value in trayracer::ui::properties - Rust

Function trayracer::ui::properties::xyz_drag_value

source · 
fn xyz_drag_value(ui: &mut Ui, value: &mut XYZ<f32>)
\ No newline at end of file +xyz_drag_value in trayracer::ui::properties - Rust
trayracer::ui::properties

Function xyz_drag_value

source 
fn xyz_drag_value(ui: &mut Ui, value: &mut XYZ<f32>)
\ No newline at end of file diff --git a/trayracer/ui/properties/index.html b/trayracer/ui/properties/index.html index 298b5e36..b2254551 100644 --- a/trayracer/ui/properties/index.html +++ b/trayracer/ui/properties/index.html @@ -1 +1 @@ -trayracer::ui::properties - Rust

Module trayracer::ui::properties

source ·

Structs§

Functions§

\ No newline at end of file +trayracer::ui::properties - Rust
trayracer::ui

Module properties

source

Structs§

Functions§

\ No newline at end of file diff --git a/trayracer/ui/properties/struct.Properties.html b/trayracer/ui/properties/struct.Properties.html index 8f98bd6d..2c6a8faa 100644 --- a/trayracer/ui/properties/struct.Properties.html +++ b/trayracer/ui/properties/struct.Properties.html @@ -1,41 +1,37 @@ -Properties in trayracer::ui::properties - Rust

Struct trayracer::ui::properties::Properties

source · 
pub struct Properties {
-    skybox_dialog: Option<FileDialog>,
-    object_dialog: Option<FileDialog>,
-}

Fields§

§skybox_dialog: Option<FileDialog>

Dialog to select a skybox image

-
§object_dialog: Option<FileDialog>

Dialog to add a new object

-

Implementations§

source§

impl Properties

source

pub const fn new() -> Self

source

pub fn show(&mut self, scene: &mut Scene, ui: &mut Ui, render: &Render)

source

pub fn camera_settings(scene: &mut Scene, ui: &mut Ui)

source

fn scene_settings(&mut self, scene: &mut Scene, ui: &mut Ui, render: &Render)

source

fn ambient_options(ui: &mut Ui, scene: &mut Scene)

source

fn render_options(ui: &mut Ui, render: &Render, scene: &mut Scene)

source

fn skybox_options(&mut self, ui: &mut Ui, scene: &mut Scene)

source

fn load_skybox_img(&mut self)

source

fn lights(ui: &mut Ui, scene: &mut Scene)

source

fn objects(&mut self, ui: &mut Ui, scene: &mut Scene)

source

const fn format_render_size(size: (u32, u32)) -> &'static str

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+Properties in trayracer::ui::properties - Rust
trayracer::ui::properties

Struct Properties

source 
pub struct Properties {
+    skybox_dialog: Option<FileDialog>,
+    object_dialog: Option<FileDialog>,
+}

Fields§

§skybox_dialog: Option<FileDialog>

Dialog to select a skybox image

+
§object_dialog: Option<FileDialog>

Dialog to add a new object

+

Implementations§

source§

impl Properties

source

pub const fn new() -> Self

source

pub fn show(&mut self, scene: &mut Scene, ui: &mut Ui, render: &Render)

source

pub fn camera_settings(scene: &mut Scene, ui: &mut Ui)

source

fn scene_settings(&mut self, scene: &mut Scene, ui: &mut Ui, render: &Render)

source

fn ambient_options(ui: &mut Ui, scene: &mut Scene)

source

fn render_options(ui: &mut Ui, render: &Render, scene: &mut Scene)

source

fn skybox_options(&mut self, ui: &mut Ui, scene: &mut Scene)

source

fn load_skybox_img(&mut self)

source

fn lights(ui: &mut Ui, scene: &mut Scene)

source

fn objects(&mut self, ui: &mut Ui, scene: &mut Scene)

source

const fn format_render_size(size: (u32, u32)) -> &'static str

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where - T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

\ No newline at end of file diff --git a/trayracer/ui/renderresult/index.html b/trayracer/ui/renderresult/index.html index d7cc8939..4766489f 100644 --- a/trayracer/ui/renderresult/index.html +++ b/trayracer/ui/renderresult/index.html @@ -1 +1 @@ -trayracer::ui::renderresult - Rust

Module trayracer::ui::renderresult

source ·

Structs§

\ No newline at end of file +trayracer::ui::renderresult - Rust
trayracer::ui

Module renderresult

source

Structs§

\ No newline at end of file diff --git a/trayracer/ui/renderresult/struct.RenderResult.html b/trayracer/ui/renderresult/struct.RenderResult.html index 9bb6dd55..d4c554a9 100644 --- a/trayracer/ui/renderresult/struct.RenderResult.html +++ b/trayracer/ui/renderresult/struct.RenderResult.html @@ -1,39 +1,40 @@ -RenderResult in trayracer::ui::renderresult - Rust

Struct trayracer::ui::renderresult::RenderResult

source · 
pub struct RenderResult {
-    zoom: f32,
+RenderResult in trayracer::ui::renderresult - Rust
trayracer::ui::renderresult
Struct RenderResult
source 
pub struct RenderResult {
+    zoom: f32,
     position: Vec2,
-}
Fields§
§zoom: f32§position: Vec2
Implementations§
source§
impl RenderResult
source
pub const fn new() -> Self
source
pub fn show(&mut self, ui: &mut Ui, scene: &Scene, render: &Render)
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+}

Fields§

§zoom: f32§position: Vec2

Implementations§

source§

impl RenderResult

source

pub const fn new() -> Self

source

pub fn show(&mut self, ui: &mut Ui, scene: &Scene, render: &Render)

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+ T: Any + Send + Sync,
§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be +further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

§

impl<T> WasmNotSend for T
where + T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file + T: Sync, \ No newline at end of file diff --git a/trayracer/ui/statusbar/index.html b/trayracer/ui/statusbar/index.html index aed8062b..e3a4abf5 100644 --- a/trayracer/ui/statusbar/index.html +++ b/trayracer/ui/statusbar/index.html @@ -1 +1 @@ -trayracer::ui::statusbar - Rust

Module trayracer::ui::statusbar

source ·

Structs§

\ No newline at end of file +trayracer::ui::statusbar - Rust
trayracer::ui

Module statusbar

source

Structs§

\ No newline at end of file diff --git a/trayracer/ui/statusbar/struct.StatusBar.html b/trayracer/ui/statusbar/struct.StatusBar.html index fb32325b..92a8fbe3 100644 --- a/trayracer/ui/statusbar/struct.StatusBar.html +++ b/trayracer/ui/statusbar/struct.StatusBar.html @@ -1,51 +1,47 @@ -StatusBar in trayracer::ui::statusbar - Rust

Struct trayracer::ui::statusbar::StatusBar

source · 
pub struct StatusBar {
-    save_render_dialog: Option<FileDialog>,
-    show_about: bool,
-}

Fields§

§save_render_dialog: Option<FileDialog>§show_about: bool

Whether the about window should be shown

+StatusBar in trayracer::ui::statusbar - Rust
trayracer::ui::statusbar

Struct StatusBar

source 
pub struct StatusBar {
+    save_render_dialog: Option<FileDialog>,
+    show_about: bool,
+}

Fields§

§save_render_dialog: Option<FileDialog>§show_about: bool

Whether the about window should be shown

Implementations§

source§

impl StatusBar

source

pub const fn new() -> Self

source

pub fn show( &mut self, ui: &mut Ui, - scene: Option<&mut Scene>, + scene: Option<&mut Scene>, render: &mut Render, current_tab: &mut Tab, )

source

pub fn about_us_button(&mut self, ui: &mut Ui)

source

fn about_window(&mut self, ui: &Ui)

source

pub fn export_button(&mut self, ui: &mut Ui, render: &Render)

source

pub fn render_button( ui: &mut Ui, render: &mut Render, - scene: Option<&mut Scene>, + scene: Option<&mut Scene>, current_tab: &mut Tab, -)

source

pub fn progress_bar(ui: &mut Ui, render: &Render)

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+)
source

pub fn progress_bar(ui: &mut Ui, render: &Render)

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where - T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

\ No newline at end of file diff --git a/trayracer/ui/struct.App.html b/trayracer/ui/struct.App.html index 651ac5fb..e065405c 100644 --- a/trayracer/ui/struct.App.html +++ b/trayracer/ui/struct.App.html @@ -1,4 +1,4 @@ -App in trayracer::ui - Rust

Struct trayracer::ui::App

source · 
pub struct App {
+App in trayracer::ui - Rust
trayracer::ui
Struct App
source 
pub struct App {
     current_tab: Tab,
     render: Render,
     properties: Properties,
@@ -6,44 +6,40 @@
     preview: Preview,
     render_result: RenderResult,
     yaml_menu: YamlMenu,
-    scene: Arc<RwLock<Option<Scene>>>,
+    scene: Arc<RwLock<Option<Scene>>>,
 }
Expand description
Main application
 This holds all the UI elements and application state

-
Fields§
§current_tab: Tab§render: Render§properties: Properties§statusbar: StatusBar§preview: Preview§render_result: RenderResult§yaml_menu: YamlMenu§scene: Arc<RwLock<Option<Scene>>>
Implementations§
source§
impl App
source
pub fn new(cc: &CreationContext<'_>) -> Result<Self>
Trait Implementations§
source§
impl App for App
Main application loop (called every frame)

-
source§
fn update(&mut self, ctx: &Context, _frame: &mut Frame)
Called each time the UI needs repainting, which may be many times per second. Read more
§
fn save(&mut self, _storage: &mut dyn Storage)
Called on shutdown, and perhaps at regular intervals. Allows you to save state. Read more
§
fn on_exit(&mut self)
Called once on shutdown, after [Self::save]. Read more
§
fn auto_save_interval(&self) -> Duration
Time between automatic calls to [Self::save]
§
fn clear_color(&self, _visuals: &Visuals) -> [f32; 4]
Background color values for the app, e.g. what is sent to gl.clearColor. Read more
§
fn persist_egui_memory(&self) -> bool
Controls whether or not the egui memory (window positions etc) will be
-persisted (only if the “persistence” feature is enabled).
§
fn raw_input_hook(&mut self, _ctx: &Context, _raw_input: &mut RawInput)
A hook for manipulating or filtering raw input before it is processed by [Self::update]. Read more
Auto Trait Implementations§
§
impl Freeze for App
§
impl !RefUnwindSafe for App
§
impl Send for App
§
impl Sync for App
§
impl Unpin for App
§
impl !UnwindSafe for App
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
-    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
-    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
-    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
-then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
-further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
-generate &mut Any’s vtable from &mut Trait’s.
§
impl<T> DowncastSync for T
where
-    T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be
-further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
Fields§
§current_tab: Tab§render: Render§properties: Properties§statusbar: StatusBar§preview: Preview§render_result: RenderResult§yaml_menu: YamlMenu§scene: Arc<RwLock<Option<Scene>>>
Implementations§
source§
impl App
source
pub fn new(cc: &CreationContext<'_>) -> Result<Self>
Trait Implementations§
source§
impl App for App
Main application loop (called every frame)

+
source§
fn update(&mut self, ctx: &Context, _frame: &mut Frame)
Called each time the UI needs repainting, which may be many times per second. Read more
§
fn save(&mut self, _storage: &mut dyn Storage)
Called on shutdown, and perhaps at regular intervals. Allows you to save state. Read more
§
fn on_exit(&mut self)
Called once on shutdown, after [Self::save]. Read more
§
fn auto_save_interval(&self) -> Duration
Time between automatic calls to [Self::save]
§
fn clear_color(&self, _visuals: &Visuals) -> [f32; 4]
Background color values for the app, e.g. what is sent to gl.clearColor. Read more
§
fn persist_egui_memory(&self) -> bool
Controls whether or not the egui memory (window positions etc) will be
+persisted (only if the “persistence” feature is enabled).
§
fn raw_input_hook(&mut self, _ctx: &Context, _raw_input: &mut RawInput)
A hook for manipulating or filtering raw input before it is processed by [Self::update]. Read more
Auto Trait Implementations§
§
impl Freeze for App
§
impl !RefUnwindSafe for App
§
impl !Send for App
§
impl !Sync for App
§
impl Unpin for App
§
impl !UnwindSafe for App
Blanket Implementations§
source§
impl<T> Any for T
where
+    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
source§
impl<T> Borrow<T> for T
where
+    T: ?Sized,
source§
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
source§
impl<T> BorrowMut<T> for T
where
+    T: ?Sized,
source§
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§
impl<T> Downcast<T> for T
§
fn downcast(&self) -> &T
§
impl<T> Downcast for T
where
+    T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
+then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
+further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+generate &Any’s vtable from &Trait’s.
§
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
+generate &mut Any’s vtable from &mut Trait’s.
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

 
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
 Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
-Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
-    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

 
That is, this conversion is whatever the implementation of
-From<T> for U chooses to do.

-
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
+From<T> for U chooses to do.

+
source§
impl<T> IntoEither for T
source§
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts self into a Left variant of Either<Self, Self>
 if into_left is true.
 Converts self into a Right variant of Either<Self, Self>
 otherwise. Read more
source§
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where
-    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
+    F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self>
 if into_left(&self) returns true.
 Converts self into a Right variant of Either<Self, Self>
-otherwise. Read more
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<SS, SP> SupersetOf<SS> for SP
where
-    SS: SubsetOf<SP>,
§
fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self from the equivalent element of its
-superset. Read more
§
fn is_in_subset(&self) -> bool
Checks if self is actually part of its subset T (and can be converted to it).
§
fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§
fn from_subset(element: &SS) -> SP
The inclusion map: converts self to the equivalent element of its superset.
source§
impl<T, U> TryFrom<U> for T
where
-    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
-    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T> Upcast<T> for T
§
fn upcast(&self) -> Option<&T>
§
impl<V, T> VZip<V> for T
where
+otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where - T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

\ No newline at end of file diff --git a/trayracer/ui/yamlmenu/index.html b/trayracer/ui/yamlmenu/index.html index 136f28fc..4711978a 100644 --- a/trayracer/ui/yamlmenu/index.html +++ b/trayracer/ui/yamlmenu/index.html @@ -1 +1 @@ -trayracer::ui::yamlmenu - Rust

Module trayracer::ui::yamlmenu

source ·

Structs§

\ No newline at end of file +trayracer::ui::yamlmenu - Rust
trayracer::ui

Module yamlmenu

source

Structs§

\ No newline at end of file diff --git a/trayracer/ui/yamlmenu/struct.YamlMenu.html b/trayracer/ui/yamlmenu/struct.YamlMenu.html index c1613481..9ae2fb92 100644 --- a/trayracer/ui/yamlmenu/struct.YamlMenu.html +++ b/trayracer/ui/yamlmenu/struct.YamlMenu.html @@ -1,39 +1,35 @@ -YamlMenu in trayracer::ui::yamlmenu - Rust

Struct trayracer::ui::yamlmenu::YamlMenu

source · 
pub struct YamlMenu {
-    pub open_yaml_dialog: Option<FileDialog>,
-    create_yaml_dialog: Option<FileDialog>,
-}

Fields§

§open_yaml_dialog: Option<FileDialog>§create_yaml_dialog: Option<FileDialog>

Implementations§

source§

impl YamlMenu

source

pub const fn new() -> Self

source

pub fn show(&mut self, scene: &mut Option<Scene>, ui: &mut Ui)

source

pub fn load_scene(&mut self)

source

pub fn create_scene(&mut self)

source

fn buttons(&mut self, scene: &mut Option<Scene>, ui: &mut Ui)

source

fn save_scene(scene: &Option<Scene>)

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where - T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where - T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where - T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where - T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can -then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be -further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot -generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where - T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be -further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+YamlMenu in trayracer::ui::yamlmenu - Rust
trayracer::ui::yamlmenu

Struct YamlMenu

source 
pub struct YamlMenu {
+    pub open_yaml_dialog: Option<FileDialog>,
+    create_yaml_dialog: Option<FileDialog>,
+}

Fields§

§open_yaml_dialog: Option<FileDialog>§create_yaml_dialog: Option<FileDialog>

Implementations§

source§

impl YamlMenu

source

pub const fn new() -> Self

source

pub fn show(&mut self, scene: &mut Option<Scene>, ui: &mut Ui)

source

pub fn load_scene(&mut self)

source

pub fn create_scene(&mut self)

source

fn buttons(&mut self, scene: &mut Option<Scene>, ui: &mut Ui)

source

fn save_scene(scene: Option<&Scene>)

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where + T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where + T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where + T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can +then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be +further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot +generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an -Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where - U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of -From<T> for U chooses to do.

-
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> +From<T> for U chooses to do.

+
source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where - F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> + F: FnOnce(&Self) -> bool,
Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> -otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where - SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its -superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where - U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where - U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where +otherwise. Read more

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where + SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its +superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where + U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where + U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where - S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a + S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a -[WithDispatch] wrapper. Read more
§

impl<T> WasmNotSend for T
where - T: Send,

§

impl<T> WasmNotSendSync for T
where - T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where - T: Sync,

\ No newline at end of file +[WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where + T: 'static,

§

impl<T> MaybeSendSync for T

\ No newline at end of file diff --git a/type.impl/nalgebra/base/alias/type.Vector3.js b/type.impl/nalgebra/base/alias/type.Vector3.js index fbffe23e..c93f8c6a 100644 --- a/type.impl/nalgebra/base/alias/type.Vector3.js +++ b/type.impl/nalgebra/base/alias/type.Vector3.js @@ -1,3 +1,9 @@ -(function() {var type_impls = { -"trayracer":[] -};if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file +(function() { + var type_impls = Object.fromEntries([["trayracer",[]]]); + if (window.register_type_impls) { + window.register_type_impls(type_impls); + } else { + window.pending_type_impls = type_impls; + } +})() +//{"start":55,"fragment_lengths":[16]} \ No newline at end of file