SfmlLoaders.hpp

Go to the documentation of this file.

//
// Thor C++ Library
// Copyright (c) 2011-2016 Jan Haller
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//


#ifndef THOR_SFMLLOADERS_HPP
#define THOR_SFMLLOADERS_HPP

#include <Thor/Resources/ResourceLoader.hpp>
#include <Thor/Resources/Detail/ResourceLoaderHelpers.hpp>

#include <Aurora/Meta/Templates.hpp>


namespace thor
{


namespace Resources
{
    // Make _1, _2 etc. known within this namespace
    using namespace std::placeholders;

    template <class R>
    ResourceLoader<R> fromFile(const std::string& filename)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) { return resource.loadFromFile(filename); },
            detail::Tagger("File") << filename);
    }

    template <class R, typename T>
    ResourceLoader<R> fromFile(const std::string& filename, T arg1)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) { return resource.loadFromFile(filename, arg1); },
            detail::Tagger("File") << filename << arg1);
    }

    template <class R, typename T, typename U>
    ResourceLoader<R> fromMemory(T arg1, U arg2)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) { return resource.loadFromMemory(arg1, arg2); },
            detail::Tagger("Memory") << arg1 << arg2);
    }

    template <class R, typename T, typename U, typename V>
    ResourceLoader<R> fromMemory(T arg1, U arg2, V arg3)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) { return resource.loadFromMemory(arg1, arg2, arg3); },
            detail::Tagger("Memory") << arg1 << arg2 << arg3);
    }

    template <class R>
    ResourceLoader<R> fromStream(sf::InputStream& stream)
    {
        return detail::makeResourceLoader<R>(
            [&] (R& resource) { return resource.loadFromStream(stream); },
            detail::Tagger("Stream") << &stream);
    }

    template <class R>
    ResourceLoader<R> fromStream(sf::InputStream& vertexShaderStream, sf::InputStream& fragmentShaderStream)
    {
        return detail::makeResourceLoader<R>(
            [&] (R& resource) { return resource.loadFromStream(vertexShaderStream, fragmentShaderStream); },
            detail::Tagger("Stream") << &vertexShaderStream << &fragmentShaderStream);
    }

    template <class R, typename T>
    ResourceLoader<R> fromStream(sf::InputStream& stream, T arg1
        AURORA_ENABLE_IF(!std::is_base_of<sf::InputStream, T>::value))
    {
        return detail::makeResourceLoader<R>(
            [&stream, arg1] (R& resource) { return resource.loadFromStream(stream, arg1); },
            detail::Tagger("Stream") << &stream << arg1);
    }

    template <class R>
    ResourceLoader<R> fromSamples(const sf::Int16* samples, std::size_t sampleCount, unsigned int channelCount, unsigned int sampleRate)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) { return resource.loadFromSamples(samples, sampleCount, channelCount, sampleRate); },
            detail::Tagger("Samples") << samples << sampleCount << channelCount << sampleRate);
    }

    template <class R>
    ResourceLoader<R> fromPixels(unsigned int width, unsigned int height, const sf::Uint8* pixels)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) -> bool
            {
                resource.create(width, height, pixels);
                return true;
            },
            detail::Tagger("Pixels") << width << height << pixels);
    }

    template <class R>
    ResourceLoader<R> fromColor(unsigned int width, unsigned int height, const sf::Color& color)
    {
        return detail::makeResourceLoader<R>(
            [=] (R& resource) -> bool
            {
                resource.create(width, height, color);
                return true;
            },
            detail::Tagger("Color") << width << height << color);
    }

    template <class R>
    ResourceLoader<R> fromImage(const sf::Image& image, const sf::IntRect area = sf::IntRect())
    {
        return detail::makeResourceLoader<R>(
            [&image, area] (R& resource) { return resource.loadFromImage(image, area); },
            detail::Tagger("Image") << &image << area);
    }

} // namespace Resources


} // namespace thor

#endif // THOR_SFMLLOADERS_HPP