Merge branch 'master' into custom-ui-widget

amethyst_animation/src/material.rs

@@ -1,16 +1,16 @@
 use minterpolate::InterpolationPrimitive;
 
-use amethyst_core::specs::prelude::Read;
-use amethyst_renderer::{Material, MaterialTextureSet, Sprite, TextureOffset};
+use amethyst_assets::Handle;
+use amethyst_renderer::{Material, Sprite, Texture, TextureOffset};
 
 use {AnimationSampling, ApplyData, BlendMethod};
 
 /// Sampler primitive for Material animations
 /// Note that material can only ever be animated with `Step`, or a panic will occur.
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum MaterialPrimitive {
     /// Dynamically altering the texture rendered
-    Texture(u64),
+    Texture(Handle<Texture>),
     /// Dynamically altering the section of the texture rendered.
     Offset((f32, f32), (f32, f32)),
 }
@@ -99,7 +99,7 @@ pub enum MaterialChannel {
 }
 
 impl<'a> ApplyData<'a> for Material {
-    type ApplyData = Read<'a, MaterialTextureSet>;
+    type ApplyData = ();
 }
 
 fn offset(offset: &TextureOffset) -> MaterialPrimitive {
@@ -114,104 +114,67 @@ impl AnimationSampling for Material {
     type Primitive = MaterialPrimitive;
     type Channel = MaterialChannel;
 
-    fn apply_sample(
-        &mut self,
-        channel: &Self::Channel,
-        data: &Self::Primitive,
-        extra: &Read<MaterialTextureSet>,
-    ) {
-        match (*channel, *data) {
+    fn apply_sample(&mut self, channel: &Self::Channel, data: &Self::Primitive, _: &()) {
+        match (channel, data) {
             (MaterialChannel::AlbedoTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.albedo = handle;
-                }
+                self.albedo = i.clone();
             }
             (MaterialChannel::EmissionTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.emission = handle;
-                }
+                self.emission = i.clone();
             }
             (MaterialChannel::NormalTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.normal = handle;
-                }
+                self.normal = i.clone();
             }
             (MaterialChannel::MetallicTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.metallic = handle;
-                }
+                self.metallic = i.clone();
             }
             (MaterialChannel::RoughnessTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.roughness = handle;
-                }
+                self.roughness = i.clone();
             }
             (MaterialChannel::AmbientOcclusionTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.ambient_occlusion = handle;
-                }
+                self.ambient_occlusion = i.clone();
             }
             (MaterialChannel::CaveatTexture, MaterialPrimitive::Texture(i)) => {
-                if let Some(handle) = extra.handle(i) {
-                    self.caveat = handle;
-                }
+                self.caveat = i.clone();
             }
 
             (MaterialChannel::AlbedoOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.albedo_offset = texture_offset(u, v)
+                self.albedo_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::EmissionOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.emission_offset = texture_offset(u, v)
+                self.emission_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::NormalOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.normal_offset = texture_offset(u, v)
+                self.normal_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::MetallicOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.metallic_offset = texture_offset(u, v)
+                self.metallic_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::RoughnessOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.roughness_offset = texture_offset(u, v)
+                self.roughness_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::AmbientOcclusionOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.ambient_occlusion_offset = texture_offset(u, v)
+                self.ambient_occlusion_offset = texture_offset(*u, *v)
             }
             (MaterialChannel::CaveatOffset, MaterialPrimitive::Offset(u, v)) => {
-                self.caveat_offset = texture_offset(u, v)
+                self.caveat_offset = texture_offset(*u, *v)
             }
 
             _ => panic!("Bad combination of data in Material animation"),
         }
     }
 
-    fn current_sample(
-        &self,
-        channel: &Self::Channel,
-        extra: &Read<MaterialTextureSet>,
-    ) -> Self::Primitive {
-        const ERR_MSG: &str = "Unable to get requested channel from MaterialTextureSet.";
-
+    fn current_sample(&self, channel: &Self::Channel, _: &()) -> Self::Primitive {
         match *channel {
-            MaterialChannel::AlbedoTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.albedo).expect(ERR_MSG))
-            }
-            MaterialChannel::EmissionTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.emission).expect(ERR_MSG))
-            }
-            MaterialChannel::NormalTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.normal).expect(ERR_MSG))
-            }
-            MaterialChannel::MetallicTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.metallic).expect(ERR_MSG))
-            }
-            MaterialChannel::RoughnessTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.roughness).expect(ERR_MSG))
-            }
+            MaterialChannel::AlbedoTexture => MaterialPrimitive::Texture(self.albedo.clone()),
+            MaterialChannel::EmissionTexture => MaterialPrimitive::Texture(self.emission.clone()),
+            MaterialChannel::NormalTexture => MaterialPrimitive::Texture(self.normal.clone()),
+            MaterialChannel::MetallicTexture => MaterialPrimitive::Texture(self.metallic.clone()),
+            MaterialChannel::RoughnessTexture => MaterialPrimitive::Texture(self.roughness.clone()),
             MaterialChannel::AmbientOcclusionTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.ambient_occlusion).expect(ERR_MSG))
-            }
-            MaterialChannel::CaveatTexture => {
-                MaterialPrimitive::Texture(extra.id(&self.caveat).expect(ERR_MSG))
+                MaterialPrimitive::Texture(self.ambient_occlusion.clone())
             }
+            MaterialChannel::CaveatTexture => MaterialPrimitive::Texture(self.caveat.clone()),
             MaterialChannel::AlbedoOffset => offset(&self.albedo_offset),
             MaterialChannel::EmissionOffset => offset(&self.emission_offset),
             MaterialChannel::NormalOffset => offset(&self.normal_offset),

amethyst_animation/src/sprite.rs

@@ -1,16 +1,16 @@
 use minterpolate::InterpolationPrimitive;
 
-use amethyst_core::specs::prelude::Read;
-use amethyst_renderer::{SpriteRender, SpriteSheetSet};
+use amethyst_assets::Handle;
+use amethyst_renderer::{SpriteRender, SpriteSheet};
 
 use {AnimationSampling, ApplyData, BlendMethod};
 
 /// Sampler primitive for SpriteRender animations
 /// Note that sprites can only ever be animated with `Step`, or a panic will occur.
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum SpriteRenderPrimitive {
     /// A spritesheet id
-    SpriteSheet(u64),
+    SpriteSheet(Handle<SpriteSheet>),
     /// An index into a spritesheet
     SpriteIndex(usize),
 }
@@ -55,30 +55,22 @@ pub enum SpriteRenderChannel {
 }
 
 impl<'a> ApplyData<'a> for SpriteRender {
-    type ApplyData = Read<'a, SpriteSheetSet>;
+    type ApplyData = ();
 }
 
 impl AnimationSampling for SpriteRender {
     type Primitive = SpriteRenderPrimitive;
     type Channel = SpriteRenderChannel;
 
-    fn apply_sample(
-        &mut self,
-        channel: &Self::Channel,
-        data: &Self::Primitive,
-        sprite_sheet_set: &Read<SpriteSheetSet>,
-    ) {
-        use self::{SpriteRenderChannel as Channel, SpriteRenderPrimitive as Primitive};
-        match (*channel, *data) {
-            (Channel::SpriteSheet, Primitive::SpriteSheet(i)) => {
-                if let Some(handle) = sprite_sheet_set.handle(i) {
-                    self.sprite_sheet = handle;
-                } else {
-                    warn!("No sprite sheet handle found for ID: `{}`", i);
-                }
+    fn apply_sample(&mut self, channel: &Self::Channel, data: &Self::Primitive, _: &()) {
+        use self::SpriteRenderChannel as Channel;
+        use self::SpriteRenderPrimitive as Primitive;
+        match (channel, data) {
+            (Channel::SpriteSheet, Primitive::SpriteSheet(handle)) => {
+                self.sprite_sheet = handle.clone();
             }
             (Channel::SpriteIndex, Primitive::SpriteIndex(index)) => {
-                self.sprite_number = index;
+                self.sprite_number = *index;
             }
 
             // Error cases
@@ -99,19 +91,12 @@ impl AnimationSampling for SpriteRender {
         }
     }
 
-    fn current_sample(
-        &self,
-        channel: &Self::Channel,
-        sprite_sheet_set: &Read<SpriteSheetSet>,
-    ) -> Self::Primitive {
-        use self::{SpriteRenderChannel as Channel, SpriteRenderPrimitive as Primitive};
+    fn current_sample(&self, channel: &Self::Channel, _: &()) -> Self::Primitive {
+        use self::SpriteRenderChannel as Channel;
+        use self::SpriteRenderPrimitive as Primitive;
 
-        const ERR_MSG: &str = "Unable to get requested spritesheet from SpriteSheetSet.";
-
-        match *channel {
-            Channel::SpriteSheet => {
-                Primitive::SpriteSheet(sprite_sheet_set.id(&self.sprite_sheet).expect(ERR_MSG))
-            }
+        match channel {
+            Channel::SpriteSheet => Primitive::SpriteSheet(self.sprite_sheet.clone()),
             Channel::SpriteIndex => Primitive::SpriteIndex(self.sprite_number),
         }
     }

amethyst_derive/src/event_reader.rs

@@ -51,7 +51,7 @@ pub enum SomeEvent {{
     let reads : Vec<_> = (0..tys.len()).map(|n| {
         let variant = &names[n];
         quote! {
-            events.extend(data.#n.read(self.#n.as_mut().expect("ReaderId undefined, has setup been run?")).cloned().map(|e| #event_name::#variant(e)));
+            events.extend(data.#n.read(self.#n.as_mut().expect("ReaderId undefined, has setup been run?")).cloned().map(#event_name::#variant));
         }
     }).collect();
     let setups: Vec<_> = (0..tys.len())

amethyst_renderer/src/lib.rs

@@ -123,8 +123,7 @@ pub use {
         JointTransformsPrefab, JointWeights,
     },
     sprite::{
-        Sprite, SpriteRender, SpriteSheet, SpriteSheetFormat, SpriteSheetHandle, SpriteSheetSet,
-        TextureCoordinates,
+        Sprite, SpriteRender, SpriteSheet, SpriteSheetFormat, SpriteSheetHandle, TextureCoordinates,
     },
     sprite_visibility::{SpriteVisibility, SpriteVisibilitySortingSystem},
     system::RenderSystem,

amethyst_renderer/src/sprite.rs

@@ -1,4 +1,3 @@
-use fnv::FnvHashMap;
 use ron::de::from_bytes as from_ron_bytes;
 
 use amethyst_assets::{
@@ -184,67 +183,6 @@ impl Component for SpriteRender {
     type Storage = VecStorage<Self>;
 }
 
-/// Sprite sheets used by sprite render animations
-///
-/// In sprite animations, it is plausible to switch the `SpriteSheet` during the animation.
-/// `Animation`s require their primitives to be `Copy`. However, `Handle<SpriteSheet>`s are `Clone`
-/// but not `Copy`. Therefore, to allow switching of the `SpriteSheet`, we use a `Copy` ID, and map
-/// that to the sprite sheet handle so that it can be looked up when being sampled in the animation.
-#[derive(Debug, Default)]
-pub struct SpriteSheetSet {
-    sprite_sheets: FnvHashMap<u64, SpriteSheetHandle>,
-    sprite_sheet_inverse: FnvHashMap<SpriteSheetHandle, u64>,
-}
-
-impl SpriteSheetSet {
-    /// Create new sprite sheet set
-    pub fn new() -> Self {
-        SpriteSheetSet {
-            sprite_sheets: FnvHashMap::default(),
-            sprite_sheet_inverse: FnvHashMap::default(),
-        }
-    }
-
-    /// Retrieve the handle for a given index
-    pub fn handle(&self, id: u64) -> Option<SpriteSheetHandle> {
-        self.sprite_sheets.get(&id).cloned()
-    }
-
-    /// Retrieve the index for a given handle
-    pub fn id(&self, handle: &SpriteSheetHandle) -> Option<u64> {
-        self.sprite_sheet_inverse.get(handle).cloned()
-    }
-
-    /// Insert a sprite sheet handle at the given index
-    pub fn insert(&mut self, id: u64, handle: SpriteSheetHandle) {
-        self.sprite_sheets.insert(id, handle.clone());
-        self.sprite_sheet_inverse.insert(handle, id);
-    }
-
-    /// Remove the given index
-    pub fn remove(&mut self, id: u64) {
-        if let Some(handle) = self.sprite_sheets.remove(&id) {
-            self.sprite_sheet_inverse.remove(&handle);
-        }
-    }
-
-    /// Get number of sprite sheets in the set
-    pub fn len(&self) -> usize {
-        self.sprite_sheets.len()
-    }
-
-    /// Returns whether the set contains any sprite sheets
-    pub fn is_empty(&self) -> bool {
-        self.sprite_sheets.is_empty()
-    }
-
-    /// Remove all sprite sheet handles in the set
-    pub fn clear(&mut self) {
-        self.sprite_sheets.clear();
-        self.sprite_sheet_inverse.clear();
-    }
-}
-
 /// Structure acting as scaffolding for serde when loading a spritesheet file.
 /// Positions originate in the top-left corner (bitmap image convention).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

amethyst_ui/src/font/default.rs

@@ -1,3 +1,5 @@
+use std::fs;
+
 use font_kit::handle::Handle as FontKitHandle;
 
 use amethyst_assets::{AssetStorage, Loader, SimpleFormat};
@@ -14,16 +16,34 @@ pub fn get_default_font(loader: &Loader, storage: &AssetStorage<FontAsset>) -> F
 
     match system_font {
         Ok(handle) => match handle {
-            FontKitHandle::Path { .. } => unimplemented!(
-                "Default system font was provided as a path, this is not yet supported.
-				If you see this message, open an issue so that we know we need to implement it."
-            ),
+            FontKitHandle::Path { path, .. } => {
+                if let Some(file_extension) = path.extension() {
+                    let format = if file_extension == "ttf" || file_extension == "otf" {
+                        Some(TtfFormat)
+                    } else {
+                        error!("System font '{}' has unknown format", path.display());
+                        None
+                    };
+
+                    if let Some(format) = format {
+                        match fs::read(&path) {
+                            Ok(bytes) => match format.import(bytes, ()) {
+                                Ok(data) => return loader.load_from_data(data, (), storage),
+                                Err(err) => warn!("System font at '{}' cannot be loaded. Fallback to default. Error: {}", path.display(), err),
+                            },
+                            Err(err) => warn!("System font at '{}' is not available for use. Fallback to default. Error: {}", path.display(), err)
+                        }
+                    }
+                } else {
+                    warn!("System font has no file extension!");
+                }
+            }
             FontKitHandle::Memory { bytes, .. } => {
                 let font_data = TtfFormat.import(bytes.to_vec(), ());
                 match font_data {
-					Ok(data) => return loader.load_from_data(data, (), storage),
-					Err(e) => warn!("Failed to load default system font from bytes. Falling back to built-in.\nError: {:?}", e),
-				}
+                    Ok(data) => return loader.load_from_data(data, (), storage),
+                    Err(e) => warn!("Failed to load default system font from bytes. Falling back to built-in.\nError: {:?}", e),
+                }
             }
         },
         Err(e) => warn!(