Texture.hpp

/******************************************************************************
 
  nomlib - C++11 cross-platform game engine
 
Copyright (c) 2013, 2014 Jeffrey Carpenter <i8degrees@gmail.com>
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
******************************************************************************/
#ifndef NOMLIB_SDL2_TEXTURE_HEADERS
#define NOMLIB_SDL2_TEXTURE_HEADERS
 
#include <iostream>
#include <string>
#include <memory>
 
#include <SDL.h>
 
#include "nomlib/config.hpp"
#include "nomlib/math/Color4.hpp"
#include "nomlib/math/Point2.hpp"
#include "nomlib/math/Size2.hpp"
#include "nomlib/math/Rect.hpp"
 
// Dump the rescaled Texture as a PNG file
//#define NOM_DEBUG_SDL2_RESIZE_PNG
 
namespace nom {
 
// Forward declarations
class Image;
class RenderWindow;
 
class Texture
{
  public:
    typedef Texture self_type;

    enum ResizeAlgorithm
    {
      None = 0, // No resizing is applied
      scale2x,
      scale3x, // Reserved for future implementation
      scale4x, // Reserved for future implementation
      hq2x,
      hq3x,
      hq4x
    };
 
    enum Access
    {
      Invalid = 0,
      Static = SDL_TEXTUREACCESS_STATIC,        // Changes rarely; not lockable
      Streaming = SDL_TEXTUREACCESS_STREAMING,  // Frequent changes; lockable, RW
      RenderTarget = SDL_TEXTUREACCESS_TARGET   // Render (texture) to target
    };

    Texture( void );

    ~Texture( void );

    Texture ( const Texture& copy );

    Texture& operator = ( const Texture& other );

    Texture* clone() const;

    bool initialize ( uint32 format, uint32 flags, int width, int height );

    bool initialize(uint32 format, uint32 flags, const Size2i& dims);

    bool create(SDL_Texture* source);

    bool create ( const Image& source );

    bool create( const Image& source, uint32 pixel_format, enum Texture::Access type );
 
    const Point2i& position() const;

    const Size2i& size() const;
 
    const IntRect& bounds() const;

    SDL_Texture* texture() const;

    bool valid() const;

    enum Texture::Access access ( void ) const;
 
    void set_position(const Point2i& pos);

    void set_size(const Size2i& size);

    void set_bounds(const IntRect& bounds);

    int32 width ( void ) const;

    int32 height ( void ) const;
 
    int pitch ( void ) const;
 
    void* pixels ( void ) const;
 
    uint8 bytes_per_pixel ( void ) const;
 
    uint32 pixel_format ( void ) const;

    uint8 bits_per_pixel ( void ) const;

    const SDL_BlendMode blend_mode ( void ) const;

    const Color4i& colorkey ( void ) const;

    uint8 alpha ( void ) const;

    const Color4i color_modulation ( void ) const;

    static const Point2i maximum_size ( void );

    bool locked() const;

    bool lock();

 
    bool lock(const IntRect& bounds);

    void unlock ( void );

    bool load ( const std::string& filename,
                bool use_cache = false,
                enum Texture::Access type = Access::Static
              );

    bool update_pixels(const void* source, uint16 pitch, const IntRect& bounds);

    void draw(SDL_Renderer* target) const;

    void draw(const RenderWindow& target) const;

    void draw(SDL_Renderer* target, const real64 angle) const;

    void draw(const RenderWindow& target, const real64 angle) const;

    bool set_alpha ( uint8 opacity );

    uint32 pixel ( int x, int y );

    bool resize( enum ResizeAlgorithm scaling_algorithm );

    int scale_factor( enum ResizeAlgorithm scaling_algorithm ) const;
    int scale_factor() const;

    bool set_blend_mode ( const SDL_BlendMode blend );

    bool set_colorkey(const Color4i& colorkey);

    bool set_color_modulation ( const Color4i& color );
 
    bool copy_pixels ( const void* source, int pitch );
 
  private:
    void set_scale_factor(int factor);
 
    std::shared_ptr<SDL_Texture> texture_;

    void* pixels_;

    int pitch_;

    Point2i position_; // This should probably be an IntRect. (Global bounds).
 
    Size2i size_;

    IntRect bounds_; // Local bounds

    Color4i colorkey_;
 
    int scale_factor_;
};
 
 
} // namespace nom
 
#endif // include guard defined