Merge pull request #2105 from peppy/skinning-basics

Implement skin support for (most) hitsounds and (osu!) hitcircles

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/ApproachCircle.cs

@@ -6,30 +6,24 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class ApproachCircle : Container
     {
-        private readonly Sprite approachCircle;
-
         public ApproachCircle()
         {
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            AutoSizeAxes = Axes.Both;
-
-            Children = new Drawable[]
-            {
-                approachCircle = new Sprite()
-            };
+            RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load(TextureStore textures)
         {
-            approachCircle.Texture = textures.Get(@"Play/osu/approachcircle");
+            Child = new SkinnableDrawable("Play/osu/approachcircle", name => new Sprite { Texture = textures.Get(name) });
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/CirclePiece.cs

@@ -2,20 +2,16 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
 using osu.Framework.Input.Bindings;
+using osu.Game.Skinning;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
     {
-        private readonly Sprite disc;
-
         public Func<bool> Hit;
 
         public CirclePiece()
@@ -27,26 +23,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            Children = new Drawable[]
-            {
-                disc = new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre
-                },
-                new TrianglesPiece
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
-                    Alpha = 0.5f,
-                }
-            };
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            disc.Texture = textures.Get(@"Play/osu/disc");
+            InternalChild = new SkinnableDrawable("Play/osu/hitcircle", _ => new DefaultCirclePiece());
         }
 
         public bool OnPressed(OsuAction action)

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/DefaultCirclePiece.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class DefaultCirclePiece : Container
+    {
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            RelativeSizeAxes = Axes.Both;
+            Children = new Drawable[]
+            {
+                new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Texture = textures.Get(@"Play/osu/disc"),
+                },
+                new TrianglesPiece
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingMode.Additive,
+                    Alpha = 0.5f,
+                }
+            };
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/GlowPiece.cs

@@ -6,34 +6,30 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class GlowPiece : Container
     {
-        private readonly Sprite layer;
-
         public GlowPiece()
         {
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
-
-            Children = new[]
-            {
-                layer = new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Blending = BlendingMode.Additive,
-                    Alpha = 0.5f
-                }
-            };
+            RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load(TextureStore textures)
         {
-            layer.Texture = textures.Get(@"Play/osu/ring-glow");
+            Child = new SkinnableDrawable("Play/osu/ring-glow", name => new Sprite
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Texture = textures.Get(name),
+                Blending = BlendingMode.Additive,
+                Alpha = 0.5f
+            }, false);
         }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/NumberPiece.cs

@@ -8,6 +8,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.Sprites;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -28,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             Children = new Drawable[]
             {
-                new CircularContainer
+                new SkinnableDrawable("Play/osu/number-glow", name => new CircularContainer
                 {
                     Masking = true,
                     Origin = Anchor.Centre,
@@ -38,11 +39,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                         Radius = 60,
                         Colour = Color4.White.Opacity(0.5f),
                     },
-                    Children = new[]
-                    {
-                        new Box()
-                    }
-                },
+                    Child = new Box()
+                }, false),
                 number = new OsuSpriteText
                 {
                     Text = @"1",

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/RingPiece.cs

@@ -6,6 +6,7 @@ using osu.Framework.Graphics.Containers;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -15,24 +16,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         {
             Size = new Vector2(128);
 
-            Masking = true;
-            CornerRadius = Size.X / 2;
-
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            BorderThickness = 10;
-            BorderColour = Color4.White;
-
-            Children = new Drawable[]
+            InternalChild = new SkinnableDrawable("Play/osu/hitcircleoverlay", _ => new Container
             {
-                new Box
+                Masking = true,
+                CornerRadius = Size.X / 2,
+                BorderThickness = 10,
+                BorderColour = Color4.White,
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    AlwaysPresent = true,
-                    Alpha = 0,
-                    RelativeSizeAxes = Axes.Both
+                    new Box
+                    {
+                        AlwaysPresent = true,
+                        Alpha = 0,
+                        RelativeSizeAxes = Axes.Both
+                    }
                 }
-            };
+            });
         }
     }
 }

osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj

@@ -92,6 +92,7 @@
     <Compile Include="Objects\Drawables\IRequireTracking.cs" />
     <Compile Include="Objects\Drawables\ITrackSnaking.cs" />
     <Compile Include="Objects\Drawables\Pieces\ApproachCircle.cs" />
+    <Compile Include="Objects\Drawables\Pieces\DefaultCirclePiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\SpinnerBackground.cs" />
     <Compile Include="Objects\Drawables\Pieces\CirclePiece.cs" />
     <Compile Include="Objects\Drawables\DrawableSlider.cs" />

osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs

@@ -2,10 +2,9 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Sample;
 using osu.Game.Audio;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.Audio
 {
@@ -14,7 +13,9 @@ namespace osu.Game.Rulesets.Taiko.Audio
         private readonly ControlPointInfo controlPoints;
         private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>();
 
-        public DrumSampleMapping(ControlPointInfo controlPoints, AudioManager audio)
+        public readonly List<SkinnableSound> Sounds = new List<SkinnableSound>();
+
+        public DrumSampleMapping(ControlPointInfo controlPoints)
         {
             this.controlPoints = controlPoints;
 
@@ -27,20 +28,34 @@ namespace osu.Game.Rulesets.Taiko.Audio
 
             foreach (var s in samplePoints)
             {
+                var centre = s.GetSampleInfo();
+                var rim = s.GetSampleInfo(SampleInfo.HIT_CLAP);
+
+                // todo: this is ugly
+                centre.Namespace = "taiko";
+                rim.Namespace = "taiko";
+
                 mappings[s.Time] = new DrumSample
                 {
-                    Centre = s.GetSampleInfo().GetChannel(audio.Sample, "Taiko"),
-                    Rim = s.GetSampleInfo(SampleInfo.HIT_CLAP).GetChannel(audio.Sample, "Taiko")
+                    Centre = addSound(centre),
+                    Rim = addSound(rim)
                 };
             }
         }
 
+        private SkinnableSound addSound(SampleInfo sampleInfo)
+        {
+            var drawable = new SkinnableSound(sampleInfo);
+            Sounds.Add(drawable);
+            return drawable;
+        }
+
         public DrumSample SampleAt(double time) => mappings[controlPoints.SamplePointAt(time).Time];
 
         public class DrumSample
         {
-            public SampleChannel Centre;
-            public SampleChannel Rim;
+            public SkinnableSound Centre;
+            public SkinnableSound Rim;
         }
     }
 }

osu.Game.Rulesets.Taiko/UI/InputDrum.cs

@@ -4,7 +4,6 @@
 using System;
 using OpenTK;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
@@ -34,9 +33,9 @@ namespace osu.Game.Rulesets.Taiko.UI
         }
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load()
         {
-            var sampleMappings = new DrumSampleMapping(controlPoints, audio);
+            var sampleMappings = new DrumSampleMapping(controlPoints);
 
             Children = new Drawable[]
             {
@@ -63,6 +62,8 @@ namespace osu.Game.Rulesets.Taiko.UI
                     CentreAction = TaikoAction.RightCentre
                 }
             };
+
+            AddRangeInternal(sampleMappings.Sounds);
         }
 
         /// <summary>

osu.Game/Audio/SampleInfo.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using osu.Framework.Audio.Sample;
 
 namespace osu.Game.Audio
 {
@@ -14,22 +13,10 @@ namespace osu.Game.Audio
         public const string HIT_NORMAL = @"hitnormal";
         public const string HIT_CLAP = @"hitclap";
 
-        public SampleChannel GetChannel(SampleManager manager, string resourceNamespace = null)
-        {
-            SampleChannel channel = null;
-
-            if (resourceNamespace != null)
-                channel = manager.Get($"Gameplay/{resourceNamespace}/{Bank}-{Name}");
-
-            // try without namespace as a fallback.
-            if (channel == null)
-                channel = manager.Get($"Gameplay/{Bank}-{Name}");
-
-            if (channel != null)
-                channel.Volume.Value = Volume / 100.0;
-
-            return channel;
-        }
+        /// <summary>
+        /// An optional ruleset namespace.
+        /// </summary>
+        public string Namespace;
 
         /// <summary>
         /// The bank to load the sample from.

osu.Game/Configuration/OsuConfigManager.cs

@@ -14,6 +14,8 @@ namespace osu.Game.Configuration
         {
             // UI/selection defaults
             Set(OsuSetting.Ruleset, 0, 0, int.MaxValue);
+            Set(OsuSetting.Skin, 0, 0, int.MaxValue);
+
             Set(OsuSetting.BeatmapDetailTab, BeatmapDetailTab.Details);
 
             Set(OsuSetting.ShowConvertedBeatmaps, true);
@@ -122,6 +124,7 @@ namespace osu.Game.Configuration
         ChatDisplayHeight,
         Version,
         ShowConvertedBeatmaps,
-        SpeedChangeVisualisation
+        SpeedChangeVisualisation,
+        Skin
     }
 }

osu.Game/Database/OsuDbContext.cs

@@ -13,6 +13,7 @@ using osu.Game.IO;
 using osu.Game.Rulesets;
 using DatabasedKeyBinding = osu.Game.Input.Bindings.DatabasedKeyBinding;
 using LogLevel = Microsoft.Extensions.Logging.LogLevel;
+using osu.Game.Skinning;
 
 namespace osu.Game.Database
 {
@@ -26,6 +27,7 @@ namespace osu.Game.Database
         public DbSet<DatabasedSetting> DatabasedSetting { get; set; }
         public DbSet<FileInfo> FileInfo { get; set; }
         public DbSet<RulesetInfo> RulesetInfo { get; set; }
+        public DbSet<SkinInfo> SkinInfo { get; set; }
 
         private readonly string connectionString;
 

osu.Game/Migrations/20180219060912_AddSkins.Designer.cs

@@ -0,0 +1,379 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using osu.Game.Database;
+using System;
+
+namespace osu.Game.Migrations
+{
+    [DbContext(typeof(OsuDbContext))]
+    [Migration("20180219060912_AddSkins")]
+    partial class AddSkins
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.0-rtm-26452");
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapDifficulty", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("ApproachRate");
+
+                    b.Property<float>("CircleSize");
+
+                    b.Property<float>("DrainRate");
+
+                    b.Property<float>("OverallDifficulty");
+
+                    b.Property<float>("SliderMultiplier");
+
+                    b.Property<float>("SliderTickRate");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapDifficulty");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AudioLeadIn");
+
+                    b.Property<int>("BaseDifficultyID");
+
+                    b.Property<int>("BeatDivisor");
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<bool>("Countdown");
+
+                    b.Property<double>("DistanceSpacing");
+
+                    b.Property<int>("GridSize");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<bool>("Hidden");
+
+                    b.Property<bool>("LetterboxInBreaks");
+
+                    b.Property<string>("MD5Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapID");
+
+                    b.Property<string>("Path");
+
+                    b.Property<int>("RulesetID");
+
+                    b.Property<bool>("SpecialStyle");
+
+                    b.Property<float>("StackLeniency");
+
+                    b.Property<double>("StarDifficulty");
+
+                    b.Property<string>("StoredBookmarks");
+
+                    b.Property<double>("TimelineZoom");
+
+                    b.Property<string>("Version");
+
+                    b.Property<bool>("WidescreenStoryboard");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BaseDifficultyID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MD5Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapID")
+                        .IsUnique();
+
+                    b.HasIndex("RulesetID");
+
+                    b.ToTable("BeatmapInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapMetadata", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Artist");
+
+                    b.Property<string>("ArtistUnicode");
+
+                    b.Property<string>("AudioFile");
+
+                    b.Property<string>("AuthorString")
+                        .HasColumnName("Author");
+
+                    b.Property<string>("BackgroundFile");
+
+                    b.Property<int>("PreviewTime");
+
+                    b.Property<string>("Source");
+
+                    b.Property<string>("Tags");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TitleUnicode");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapMetadata");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.ToTable("BeatmapSetFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapSetID");
+
+                    b.Property<bool>("Protected");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("DeletePending");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapSetID")
+                        .IsUnique();
+
+                    b.ToTable("BeatmapSetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Configuration.DatabasedSetting", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("IntKey")
+                        .HasColumnName("Key");
+
+                    b.Property<int?>("RulesetID");
+
+                    b.Property<string>("StringValue")
+                        .HasColumnName("Value");
+
+                    b.Property<int?>("Variant");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("RulesetID", "Variant");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("osu.Game.Input.Bindings.DatabasedKeyBinding", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("IntAction")
+                        .HasColumnName("Action");
+
+                    b.Property<string>("KeysString")
+                        .HasColumnName("Keys");
+
+                    b.Property<int?>("RulesetID");
+
+                    b.Property<int?>("Variant");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("IntAction");
+
+                    b.HasIndex("RulesetID", "Variant");
+
+                    b.ToTable("KeyBinding");
+                });
+
+            modelBuilder.Entity("osu.Game.IO.FileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int>("ReferenceCount");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("ReferenceCount");
+
+                    b.ToTable("FileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Rulesets.RulesetInfo", b =>
+                {
+                    b.Property<int?>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("InstantiationInfo");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("ShortName");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Available");
+
+                    b.HasIndex("ShortName")
+                        .IsUnique();
+
+                    b.ToTable("RulesetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.Property<int>("SkinInfoID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.HasIndex("SkinInfoID");
+
+                    b.ToTable("SkinFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Creator");
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("SkinInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapDifficulty", "BaseDifficulty")
+                        .WithMany()
+                        .HasForeignKey("BaseDifficultyID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo", "BeatmapSet")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("MetadataID");
+
+                    b.HasOne("osu.Game.Rulesets.RulesetInfo", "Ruleset")
+                        .WithMany()
+                        .HasForeignKey("RulesetID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("BeatmapSets")
+                        .HasForeignKey("MetadataID");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Skinning.SkinInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("SkinInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

osu.Game/Migrations/20180219060912_AddSkins.cs

@@ -0,0 +1,73 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace osu.Game.Migrations
+{
+    public partial class AddSkins : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "SkinInfo",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Creator = table.Column<string>(type: "TEXT", nullable: true),
+                    DeletePending = table.Column<bool>(type: "INTEGER", nullable: false),
+                    Name = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SkinInfo", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "SkinFileInfo",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    FileInfoID = table.Column<int>(type: "INTEGER", nullable: false),
+                    Filename = table.Column<string>(type: "TEXT", nullable: false),
+                    SkinInfoID = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SkinFileInfo", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_SkinFileInfo_FileInfo_FileInfoID",
+                        column: x => x.FileInfoID,
+                        principalTable: "FileInfo",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_SkinFileInfo_SkinInfo_SkinInfoID",
+                        column: x => x.SkinInfoID,
+                        principalTable: "SkinInfo",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SkinFileInfo_FileInfoID",
+                table: "SkinFileInfo",
+                column: "FileInfoID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SkinFileInfo_SkinInfoID",
+                table: "SkinFileInfo",
+                column: "SkinInfoID");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "SkinFileInfo");
+
+            migrationBuilder.DropTable(
+                name: "SkinInfo");
+        }
+    }
+}

osu.Game/Migrations/OsuDbContextModelSnapshot.cs

@@ -281,6 +281,43 @@ namespace osu.Game.Migrations
                     b.ToTable("RulesetInfo");
                 });
 
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.Property<int>("SkinInfoID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.HasIndex("SkinInfoID");
+
+                    b.ToTable("SkinFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Creator");
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("SkinInfo");
+                });
+
             modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
                 {
                     b.HasOne("osu.Game.Beatmaps.BeatmapDifficulty", "BaseDifficulty")
@@ -322,6 +359,19 @@ namespace osu.Game.Migrations
                         .WithMany("BeatmapSets")
                         .HasForeignKey("MetadataID");
                 });
+
+            modelBuilder.Entity("osu.Game.Skinning.SkinFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Skinning.SkinInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("SkinInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
 #pragma warning restore 612, 618
         }
     }

osu.Game/OsuGame.cs

@@ -30,6 +30,7 @@ using osu.Game.Rulesets;
 using osu.Game.Screens.Play;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Skinning;
 using OpenTK.Graphics;
 
 namespace osu.Game
@@ -79,6 +80,8 @@ namespace osu.Game
         private Bindable<int> configRuleset;
         public Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
 
+        private Bindable<int> configSkin;
+
         private readonly string[] args;
 
         private SettingsOverlay settings;
@@ -122,10 +125,18 @@ namespace osu.Game
 
             dependencies.CacheAs(this);
 
+            // bind config int to database RulesetInfo
             configRuleset = LocalConfig.GetBindable<int>(OsuSetting.Ruleset);
             Ruleset.Value = RulesetStore.GetRuleset(configRuleset.Value) ?? RulesetStore.AvailableRulesets.First();
             Ruleset.ValueChanged += r => configRuleset.Value = r.ID ?? 0;
 
+            // bind config int to database SkinInfo
+            configSkin = LocalConfig.GetBindable<int>(OsuSetting.Skin);
+
+            SkinManager.CurrentSkinInfo.ValueChanged += s => configSkin.Value = s.ID;
+            configSkin.ValueChanged += id => SkinManager.CurrentSkinInfo.Value = SkinManager.Query(s => s.ID == id) ?? SkinInfo.Default;
+            configSkin.TriggerChange();
+
             LocalConfig.BindWith(OsuSetting.VolumeInactive, inactiveVolumeAdjust);
         }
 
@@ -187,7 +198,9 @@ namespace osu.Game
             CursorOverrideContainer.CanShowCursor = currentScreen?.CursorVisible ?? false;
 
             // hook up notifications to components.
+            SkinManager.PostNotification = n => notifications?.Post(n);
             BeatmapManager.PostNotification = n => notifications?.Post(n);
+
             BeatmapManager.GetStableStorage = GetStorageForStableInstall;
 
             AddRange(new Drawable[]

osu.Game/OsuGameBase.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
@@ -30,6 +30,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.IO;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game
 {
@@ -39,6 +40,8 @@ namespace osu.Game
 
         protected BeatmapManager BeatmapManager;
 
+        protected SkinManager SkinManager;
+
         protected RulesetStore RulesetStore;
 
         protected FileStore FileStore;
@@ -103,6 +106,8 @@ namespace osu.Game
 
             runMigrations();
 
+            dependencies.Cache(SkinManager = new SkinManager(Host.Storage, contextFactory, Host, Audio));
+
             dependencies.Cache(API = new APIAccess
             {
                 Username = LocalConfig.Get<string>(OsuSetting.Username),
@@ -120,6 +125,7 @@ namespace osu.Game
 
             fileImporters.Add(BeatmapManager);
             fileImporters.Add(ScoreStore);
+            fileImporters.Add(SkinManager);
 
             //this completely overrides the framework default. will need to change once we make a proper FontStore.
             dependencies.Cache(Fonts = new FontStore { ScaleAdjust = 100 });

osu.Game/Overlays/Settings/Sections/SkinSection.cs

@@ -1,26 +1,33 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Skinning;
 using OpenTK;
 
 namespace osu.Game.Overlays.Settings.Sections
 {
     public class SkinSection : SettingsSection
     {
+        private SettingsDropdown<int> skinDropdown;
+
         public override string Header => "Skin";
+
         public override FontAwesome Icon => FontAwesome.fa_paint_brush;
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load(OsuConfigManager config, SkinManager skins)
         {
             FlowContent.Spacing = new Vector2(0, 5);
             Children = new Drawable[]
             {
+                skinDropdown = new SettingsDropdown<int>(),
                 new SettingsSlider<double, SizeSlider>
                 {
                     LabelText = "Menu cursor size",
@@ -39,6 +46,14 @@ namespace osu.Game.Overlays.Settings.Sections
                     Bindable = config.GetBindable<bool>(OsuSetting.AutoCursorSize)
                 },
             };
+
+            void reloadSkins() => skinDropdown.Items = skins.GetAllUsableSkins().Select(s => new KeyValuePair<string, int>(s.Name, s.ID));
+            skins.ItemAdded += _ => reloadSkins();
+            skins.ItemRemoved += _ => reloadSkins();
+
+            reloadSkins();
+
+            skinDropdown.Bindable = config.GetBindable<int>(OsuSetting.Skin);
         }
 
         private class SizeSlider : OsuSliderBar<double>

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -3,20 +3,19 @@
 
 using System;
 using System.Collections.Generic;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Sample;
-using osu.Game.Rulesets.Judgements;
-using Container = osu.Framework.Graphics.Containers.Container;
-using osu.Game.Rulesets.Objects.Types;
-using OpenTK.Graphics;
-using osu.Game.Audio;
 using System.Linq;
-using osu.Game.Graphics;
+using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using OpenTK;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
+using osu.Game.Audio;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
+using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
@@ -32,7 +31,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
         // Todo: Rulesets should be overriding the resources instead, but we need to figure out where/when to apply overrides first
         protected virtual string SampleNamespace => null;
 
-        protected List<SampleChannel> Samples = new List<SampleChannel>();
+        protected SkinnableSound Samples;
+
         protected virtual IEnumerable<SampleInfo> GetSamples() => HitObject.Samples;
 
         private List<DrawableHitObject> nestedHitObjects;
@@ -83,31 +83,22 @@ namespace osu.Game.Rulesets.Objects.Drawables
         }
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        private void load()
         {
-            var samples = GetSamples();
+            var samples = GetSamples().ToArray();
+
             if (samples.Any())
             {
                 if (HitObject.SampleControlPoint == null)
                     throw new ArgumentNullException(nameof(HitObject.SampleControlPoint), $"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
                                                                                           + $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}.");
-
-                foreach (SampleInfo s in samples)
+                AddInternal(Samples = new SkinnableSound(samples.Select(s => new SampleInfo
                 {
-                    SampleInfo localSampleInfo = new SampleInfo
-                    {
-                        Bank = s.Bank ?? HitObject.SampleControlPoint.SampleBank,
-                        Name = s.Name,
-                        Volume = s.Volume > 0 ? s.Volume : HitObject.SampleControlPoint.SampleVolume
-                    };
-
-                    SampleChannel channel = localSampleInfo.GetChannel(audio.Sample, SampleNamespace);
-
-                    if (channel == null)
-                        continue;
-
-                    Samples.Add(channel);
-                }
+                    Bank = s.Bank ?? HitObject.SampleControlPoint.SampleBank,
+                    Name = s.Name,
+                    Volume = s.Volume > 0 ? s.Volume : HitObject.SampleControlPoint.SampleVolume,
+                    Namespace = SampleNamespace
+                }).ToArray()));
             }
         }
 
@@ -139,7 +130,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// Plays all the hitsounds for this <see cref="DrawableHitObject"/>.
         /// </summary>
-        public void PlaySamples() => Samples.ForEach(s => s?.Play());
+        public void PlaySamples() => Samples?.Play();
 
         protected override void Update()
         {
@@ -221,10 +212,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 return false;
 
             if (NestedHitObjects != null)
-            {
                 foreach (var d in NestedHitObjects)
                     judgementOccurred |= d.UpdateJudgement(userTriggered);
-            }
 
             if (!ProvidesJudgement || judgementFinalized || judgementOccurred)
                 return judgementOccurred;

osu.Game/Skinning/DefaultSkin.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Skinning
+{
+    public class DefaultSkin : Skin
+    {
+        public DefaultSkin()
+            : base(SkinInfo.Default)
+        {
+        }
+
+        public override Drawable GetDrawableComponent(string componentName)
+        {
+            return null;
+        }
+
+        public override SampleChannel GetSample(string sampleName)
+        {
+            return null;
+        }
+    }
+}

osu.Game/Skinning/LegacySkin.cs

@@ -0,0 +1,47 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.IO;
+using System.Linq;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
+
+namespace osu.Game.Skinning
+{
+    public class LegacySkin : Skin
+    {
+        private readonly TextureStore textures;
+
+        private readonly SampleManager samples;
+
+        public LegacySkin(SkinInfo skin, IResourceStore<byte[]> storage, AudioManager audioManager)
+            : base(skin)
+        {
+            samples = audioManager.GetSampleManager(storage);
+            textures = new TextureStore(new RawTextureLoaderStore(storage));
+        }
+
+        private string getPathForFile(string filename) =>
+            SkinInfo.Files.FirstOrDefault(f => string.Equals(Path.GetFileNameWithoutExtension(f.Filename), filename, StringComparison.InvariantCultureIgnoreCase))?.FileInfo.StoragePath;
+
+        public override Drawable GetDrawableComponent(string componentName)
+        {
+            var texture = textures.Get(getPathForFile(componentName.Split('/').Last()));
+            if (texture == null) return null;
+
+            return new Sprite
+            {
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                Texture = texture,
+            };
+        }
+
+        public override SampleChannel GetSample(string sampleName) => samples.Get(getPathForFile(sampleName.Split('/').Last()));
+    }
+}

osu.Game/Skinning/Skin.cs

@@ -0,0 +1,22 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Skinning
+{
+    public abstract class Skin
+    {
+        public readonly SkinInfo SkinInfo;
+
+        public abstract Drawable GetDrawableComponent(string componentName);
+
+        public abstract SampleChannel GetSample(string sampleName);
+
+        protected Skin(SkinInfo skin)
+        {
+            SkinInfo = skin;
+        }
+    }
+}

osu.Game/Skinning/SkinFileInfo.cs

@@ -0,0 +1,25 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using osu.Game.Database;
+using osu.Game.IO;
+
+namespace osu.Game.Skinning
+{
+    public class SkinFileInfo : INamedFileInfo
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int ID { get; set; }
+
+        public int SkinInfoID { get; set; }
+
+        public int FileInfoID { get; set; }
+
+        public FileInfo FileInfo { get; set; }
+
+        [Required]
+        public string Filename { get; set; }
+    }
+}

osu.Game/Skinning/SkinInfo.cs

@@ -0,0 +1,28 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using osu.Game.Database;
+
+namespace osu.Game.Skinning
+{
+    public class SkinInfo : IHasFiles<SkinFileInfo>, IEquatable<SkinInfo>, IHasPrimaryKey, ISoftDelete
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int ID { get; set; }
+
+        public string Name { get; set; }
+
+        public string Creator { get; set; }
+
+        public List<SkinFileInfo> Files { get; set; }
+
+        public bool DeletePending { get; set; }
+
+        public static SkinInfo Default { get; } = new SkinInfo { Name = "osu!lazer", Creator = "team osu!" };
+
+        public bool Equals(SkinInfo other) => other != null && ID == other.ID;
+    }
+}

osu.Game/Skinning/SkinManager.cs

@@ -0,0 +1,77 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore;
+using osu.Framework.Audio;
+using osu.Framework.Configuration;
+using osu.Framework.Platform;
+using osu.Game.Database;
+using osu.Game.IO.Archives;
+
+namespace osu.Game.Skinning
+{
+    public class SkinManager : ArchiveModelManager<SkinInfo, SkinFileInfo>
+    {
+        private readonly AudioManager audio;
+
+        public readonly Bindable<Skin> CurrentSkin = new Bindable<Skin>(new DefaultSkin());
+        public readonly Bindable<SkinInfo> CurrentSkinInfo = new Bindable<SkinInfo>(SkinInfo.Default) { Default = SkinInfo.Default };
+
+        public override string[] HandledExtensions => new[] { ".osk" };
+
+        /// <summary>
+        /// Returns a list of all usable <see cref="SkinInfo"/>s.
+        /// </summary>
+        /// <returns>A list of available <see cref="SkinInfo"/>.</returns>
+        public List<SkinInfo> GetAllUsableSkins()
+        {
+            var userSkins = ModelStore.ConsumableItems.Where(s => !s.DeletePending).ToList();
+            userSkins.Insert(0, SkinInfo.Default);
+            return userSkins;
+        }
+
+        protected override SkinInfo CreateModel(ArchiveReader archive) => new SkinInfo
+        {
+            Name = archive.Name
+        };
+
+        /// <summary>
+        /// Retrieve a <see cref="Skin"/> instance for the provided <see cref="SkinInfo"/>
+        /// </summary>
+        /// <param name="skinInfo">The skin to lookup.</param>
+        /// <returns>A <see cref="Skin"/> instance correlating to the provided <see cref="SkinInfo"/>.</returns>
+        public Skin GetSkin(SkinInfo skinInfo)
+        {
+            if (skinInfo == SkinInfo.Default)
+                return new DefaultSkin();
+
+            return new LegacySkin(skinInfo, Files.Store, audio);
+        }
+
+        private SkinStore store;
+
+        public SkinManager(Storage storage, DatabaseContextFactory contextFactory, IIpcHost importHost, AudioManager audio)
+            : base(storage, contextFactory, new SkinStore(contextFactory, storage), importHost)
+        {
+            this.audio = audio;
+
+            CurrentSkinInfo.ValueChanged += info => CurrentSkin.Value = GetSkin(info);
+            CurrentSkin.ValueChanged += skin =>
+            {
+                if (skin.SkinInfo != CurrentSkinInfo.Value)
+                    throw new InvalidOperationException($"Setting {nameof(CurrentSkin)}'s value directly is not supported. Use {nameof(CurrentSkinInfo)} instead.");
+            };
+        }
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="SkinInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public SkinInfo Query(Expression<Func<SkinInfo, bool>> query) => ModelStore.ConsumableItems.AsNoTracking().FirstOrDefault(query);
+    }
+}

osu.Game/Skinning/SkinReloadableDrawable.cs

@@ -0,0 +1,53 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// A drawable which has a callback when the skin changes.
+    /// </summary>
+    public abstract class SkinReloadableDrawable : CompositeDrawable
+    {
+        private Bindable<Skin> skin;
+
+        /// <summary>
+        /// Whether fallback to default skin should be allowed if the custom skin is missing this resource.
+        /// </summary>
+        private readonly bool allowDefaultFallback;
+
+        /// <summary>
+        /// Create a new <see cref="SkinReloadableDrawable"/>
+        /// </summary>
+        /// <param name="fallback">Whether fallback to default skin should be allowed if the custom skin is missing this resource.</param>
+        protected SkinReloadableDrawable(bool fallback = true)
+        {
+            allowDefaultFallback = fallback;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(SkinManager skinManager)
+        {
+            skin = skinManager.CurrentSkin.GetBoundCopy();
+            skin.ValueChanged += skin => SkinChanged(skin, allowDefaultFallback || skin.SkinInfo == SkinInfo.Default);
+        }
+
+        protected override void LoadAsyncComplete()
+        {
+            base.LoadAsyncComplete();
+            skin.TriggerChange();
+        }
+
+        /// <summary>
+        /// Called when a change is made to the skin.
+        /// </summary>
+        /// <param name="skin">The new skin.</param>
+        /// <param name="allowFallback">Whether fallback to default skin should be allowed if the custom skin is missing this resource.</param>
+        protected virtual void SkinChanged(Skin skin, bool allowFallback)
+        {
+        }
+    }
+}

osu.Game/Skinning/SkinStore.cs

@@ -0,0 +1,22 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+using osu.Framework.Platform;
+using osu.Game.Database;
+
+namespace osu.Game.Skinning
+{
+    public class SkinStore : MutableDatabaseBackedStore<SkinInfo>
+    {
+        public SkinStore(DatabaseContextFactory contextFactory, Storage storage = null)
+            : base(contextFactory, storage)
+        {
+        }
+
+        protected override IQueryable<SkinInfo> AddIncludesForConsumption(IQueryable<SkinInfo> query) =>
+            base.AddIncludesForConsumption(query)
+                .Include(s => s.Files).ThenInclude(f => f.FileInfo);
+    }
+}

osu.Game/Skinning/SkinnableDrawable.cs

@@ -0,0 +1,44 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Skinning
+{
+    public class SkinnableDrawable : SkinnableDrawable<Drawable>
+    {
+        public SkinnableDrawable(string name, Func<string, Drawable> defaultImplementation, bool fallback = true)
+            : base(name, defaultImplementation, fallback)
+        {
+        }
+    }
+
+    public class SkinnableDrawable<T> : SkinReloadableDrawable
+        where T : Drawable
+    {
+        private readonly Func<string, T> createDefault;
+
+        private readonly string componentName;
+
+        public SkinnableDrawable(string name, Func<string, T> defaultImplementation, bool fallback = true) : base(fallback)
+        {
+            componentName = name;
+            createDefault = defaultImplementation;
+
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        protected override void SkinChanged(Skin skin, bool allowFallback)
+        {
+            var drawable = skin.GetDrawableComponent(componentName);
+            if (drawable == null && allowFallback)
+                drawable = createDefault(componentName);
+
+            if (drawable != null)
+                InternalChild = drawable;
+            else
+                ClearInternal();
+        }
+    }
+}

osu.Game/Skinning/SkinnableSound.cs

@@ -0,0 +1,62 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Audio;
+
+namespace osu.Game.Skinning
+{
+    public class SkinnableSound : SkinReloadableDrawable
+    {
+        private readonly SampleInfo[] samples;
+        private SampleChannel[] channels;
+
+        private AudioManager audio;
+
+        public SkinnableSound(params SampleInfo[] samples)
+        {
+            this.samples = samples;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            this.audio = audio;
+        }
+
+        public void Play() => channels?.ForEach(c => c.Play());
+
+        protected override void SkinChanged(Skin skin, bool allowFallback)
+        {
+            channels = samples.Select(s =>
+            {
+                var ch = loadChannel(s, skin.GetSample);
+                if (ch == null && allowFallback)
+                    ch = loadChannel(s, audio.Sample.Get);
+                return ch;
+            }).ToArray();
+        }
+
+        private SampleChannel loadChannel(SampleInfo info, Func<string, SampleChannel> getSampleFunction)
+        {
+            SampleChannel ch = null;
+
+            if (info.Namespace != null)
+                ch = getSampleFunction($"Gameplay/{info.Namespace}/{info.Bank}-{info.Name}");
+
+            // try without namespace as a fallback.
+            if (ch == null)
+                ch = getSampleFunction($"Gameplay/{info.Bank}-{info.Name}");
+
+            if (ch != null)
+                ch.Volume.Value = info.Volume / 100.0;
+
+            return ch;
+        }
+    }
+}

osu.Game/osu.Game.csproj

@@ -322,6 +322,10 @@
     <Compile Include="Migrations\20171209034410_AddRulesetInfoShortName.Designer.cs">
       <DependentUpon>20171209034410_AddRulesetInfoShortName.cs</DependentUpon>
     </Compile>
+    <Compile Include="Migrations\20180219060912_AddSkins.cs" />
+    <Compile Include="Migrations\20180219060912_AddSkins.Designer.cs">
+      <DependentUpon>20180219060912_AddSkins.cs</DependentUpon>
+    </Compile>
     <Compile Include="Migrations\OsuDbContextModelSnapshot.cs" />
     <Compile Include="Online\API\Requests\GetBeatmapSetRequest.cs" />
     <Compile Include="Online\Chat\DrawableLinkCompiler.cs" />
@@ -850,6 +854,16 @@
     <Compile Include="Screens\Tournament\Teams\DrawingsTeam.cs" />
     <Compile Include="Screens\Tournament\Teams\ITeamList.cs" />
     <Compile Include="Screens\Tournament\Teams\StorageBackedTeamList.cs" />
+    <Compile Include="Skinning\DefaultSkin.cs" />
+    <Compile Include="Skinning\LegacySkin.cs" />
+    <Compile Include="Skinning\Skin.cs" />
+    <Compile Include="Skinning\SkinFileInfo.cs" />
+    <Compile Include="Skinning\SkinInfo.cs" />
+    <Compile Include="Skinning\SkinManager.cs" />
+    <Compile Include="Skinning\SkinnableDrawable.cs" />
+    <Compile Include="Skinning\SkinnableSound.cs" />
+    <Compile Include="Skinning\SkinReloadableDrawable.cs" />
+    <Compile Include="Skinning\SkinStore.cs" />
     <Compile Include="Storyboards\CommandLoop.cs" />
     <Compile Include="Storyboards\CommandTimeline.cs" />
     <Compile Include="Storyboards\CommandTimelineGroup.cs" />
@@ -922,4 +936,4 @@
   <Import Project="$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.osx.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.osx.targets" Condition="Exists('$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.osx.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.osx.targets')" />
   <Import Project="$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.linux.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.linux.targets" Condition="Exists('$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.linux.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.linux.targets')" />
   <Import Project="$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.v110_xp.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.v110_xp.targets" Condition="Exists('$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.v110_xp.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.v110_xp.targets')" />
-</Project>
+</Project>