Resources/GraphicsKeys.hpp

Go to the documentation of this file.

//
// Thor C++ Library
// Copyright (c) 2011-2012 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_GRAPHICSKEYS_HPP
#define THOR_GRAPHICSKEYS_HPP

#include <Thor/Resources/ResourceKeyTraits.hpp>
#include <Thor/SmartPtr/MovedPtr.hpp>
#include <Thor/Detail/Swap.hpp>
#include <Thor/Config.hpp>

#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/Config.hpp>

#include THOR_TR1_HEADER(functional)
#include <string>


namespace thor
{


namespace Resources
{

    class THOR_API ImageKey
    {
        // ---------------------------------------------------------------------------------------------------------------------------
        // Public member functions
        public:
            static ImageKey             FromSize(unsigned int width, unsigned int height, const sf::Color& fillColor = sf::Color(0, 0, 0),
                                            const std::string& tag = "");

            static ImageKey             FromFile(const std::string& fileName, const std::string& tag = "");

            static ImageKey             FromMemory(const void* data, std::size_t size, const std::string& tag = "");

            static ImageKey             FromPixels(unsigned int width, unsigned int height, const sf::Uint8* pixels,
                                            const std::string& tag = "");

            static ImageKey             FromStream(sf::InputStream& stream, const std::string& tag = "");

            MovedPtr<sf::Image, NoCopy> Load() const;

            void                        Swap(ImageKey& other);


        // ---------------------------------------------------------------------------------------------------------------------------
        // Private member functions
        private:
            // Make default constructor private
                                        ImageKey();

        
        // ---------------------------------------------------------------------------------------------------------------------------
        // Private variables
        private:
            std::tr1::function<bool(sf::Image&)>    mLoader;
            std::string                             mKey;

    
        // ---------------------------------------------------------------------------------------------------------------------------
        // Friends
        friend struct detail::KeyInfoAccessor;
    };


    class THOR_API TextureKey
    {
        // ---------------------------------------------------------------------------------------------------------------------------
        // Public member functions
        public:
            static TextureKey           FromSize(unsigned int width, unsigned int height, const std::string& tag = "");

            static TextureKey           FromFile(const std::string& fileName, const sf::IntRect& area = sf::IntRect(),
                                            const std::string& tag = "");

            static TextureKey           FromMemory(const void* data, std::size_t size, const sf::IntRect& area = sf::IntRect(),
                                            const std::string& tag = "");

            static TextureKey           FromImage(const sf::Image& image, const sf::IntRect& area = sf::IntRect(),
                                            const std::string& tag = "");

            static TextureKey           FromStream(sf::InputStream& stream, const sf::IntRect& area = sf::IntRect(), 
                                            const std::string& tag = "");

            MovedPtr<sf::Texture, NoCopy>   Load() const;

            void                        Swap(TextureKey& other);


        // ---------------------------------------------------------------------------------------------------------------------------
        // Private member functions
        private:
            // Make default constructor private
                                        TextureKey();

        
        // ---------------------------------------------------------------------------------------------------------------------------
        // Private variables
        private:
            std::tr1::function<bool(sf::Texture&)>  mLoader;
            std::string                             mKey;

    
        // ---------------------------------------------------------------------------------------------------------------------------
        // Friends
        friend struct detail::KeyInfoAccessor;
    };


    class THOR_API FontKey
    {
        // ---------------------------------------------------------------------------------------------------------------------------
        // Public member functions
        public:
            static FontKey              FromFile(const std::string& fileName, const std::string& tag = "");

            static FontKey              FromMemory(const void* data, std::size_t size, const std::string& tag = "");

            static FontKey              FromStream(sf::InputStream& stream, const std::string& tag = "");

            MovedPtr<sf::Font, NoCopy>  Load() const;

            void                        Swap(FontKey& other);


        // ---------------------------------------------------------------------------------------------------------------------------
        // Private member functions
        private:
            // Make default constructor private
                                        FontKey();

        
        // ---------------------------------------------------------------------------------------------------------------------------
        // Private variables
        private:
            std::tr1::function<bool(sf::Font&)>     mLoader;
            std::string                             mKey;

    
        // ---------------------------------------------------------------------------------------------------------------------------
        // Friends
        friend struct detail::KeyInfoAccessor;
    };


    class THOR_API ShaderKey
    {
        // ---------------------------------------------------------------------------------------------------------------------------
        // Public member functions
        public:
            static ShaderKey            FromFile(const std::string& fileName, THOR_FAKE_DOC(unsigned int, sf::Shader::Type) shaderType, const std::string& tag = "");

            static ShaderKey            FromFile(const std::string& vertexShaderFilename, const std::string& fragmentShaderFilename, const std::string& tag = "");

            static ShaderKey            FromMemory(const std::string& shaderCode, THOR_FAKE_DOC(unsigned int, sf::Shader::Type) shaderType, const std::string& tag = "");

            static ShaderKey            FromMemory(const std::string& vertexShaderCode, const std::string& fragmentShaderCode, const std::string& tag = "");
            
            static ShaderKey            FromStream(sf::InputStream& stream, THOR_FAKE_DOC(unsigned int, sf::Shader::Type) shaderType, const std::string& tag = "");

            static ShaderKey            FromStream(sf::InputStream& vertexShaderStream, sf::InputStream& fragmentShaderStream, const std::string& tag = "");

            MovedPtr<sf::Shader, NoCopy> Load() const;

            void                        Swap(ShaderKey& other);


        // ---------------------------------------------------------------------------------------------------------------------------
        // Private member functions
        private:
            // Make default constructor private
                                        ShaderKey();

        
        // ---------------------------------------------------------------------------------------------------------------------------
        // Private variables
        private:
            std::tr1::function<bool(sf::Shader&)>   mLoader;
            std::string                             mKey;

    
        // ---------------------------------------------------------------------------------------------------------------------------
        // Friends
        friend struct detail::KeyInfoAccessor;
    };


    bool THOR_API               operator< (const ImageKey& lhs, const ImageKey& rhs);

    bool THOR_API               operator< (const TextureKey& lhs, const TextureKey& rhs);

    bool THOR_API               operator< (const FontKey& lhs, const FontKey& rhs);

    bool THOR_API               operator< (const ShaderKey& lhs, const ShaderKey& rhs);


    THOR_GLOBAL_SWAP(ImageKey)

    

    THOR_GLOBAL_SWAP(TextureKey)

    THOR_GLOBAL_SWAP(FontKey)

    THOR_GLOBAL_SWAP(ShaderKey)

} // namespace Resources


} // namespace thor

#endif // THOR_GRAPHICSKEYS_HPP