SFML/DSFML/import/dsfml/graphics/image.d

/*
*   DSFML - SFML Library wrapper for the D programming language.
*   Copyright (C) 2008 Julien Dagorn (sirjulio13@gmail.com)
*   Copyright (C) 2010 Andreas Hollandt
*
*   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.
*/


module dsfml.graphics.image;

import	dsfml.graphics.common,
		dsfml.graphics.color,
		dsfml.graphics.rect;

import	dsfml.system.common,
		dsfml.system.exception,
		dsfml.system.stringutil;


/**
*   Image is the low-level class for loading and
*   manipulating images
*/
class Image : DSFMLObject
{
    /**
    *   Default constructor
    */
    this()
	{
		super(sfImage_Create());
	}

    /**
    *   Construct an empty image
    *
    *   Params:    
    *       width = Image width
    *       height = Image height
    *       col = Image color (black by default)
    */
    this(uint width, uint height, Color col = Color.BLACK)
	{
		super(sfImage_CreateFromColor(width, height, col));
	}

    /**
    *   Construct the image from a file
    *
    *   Params: 
    *       filename = Path of the image file to load
    *       
    *   Throws:
    *       LoadingException if filename is empty or null.
    */
    this(string filename)
	{
	   if (filename is null || filename.length == 0)
	       throw new LoadingException("LoadingException : Filename is invalid.");

		super(sfImage_CreateFromFile(toStringz(filename))); 
	}

    /**
    *   Construct the image from a file in memory
    *
    *   Params:
    *       data = array of data in memory
    *   Throws:
    *       LoadingException if data is empty or null.
    */
    this(ubyte[] data)
	{
        if (data is null || data.length == 0)
            throw new LoadingException("LoadingException : Memory stream is invalid.");
            
		super(sfImage_CreateFromMemory(data.ptr, data.length));
	}

    /**
    *   Construct the image directly from an array of pixels
    *
    *   Params: 
    *       width = Image width
    *       height = Image height
    *       data = array of pixels in memory (assumed format is RGBA)
    *   
    *   Throws:
    *       LoadingException if data length doesn't match Width * Height * 4
    */
    this(uint width, uint height, ubyte[] data)
	{
        if (width * height * 4 != data.length)
            throw new LoadingException("LoadingException : Pixels array length doesn't match the specified size.");
            
		super(sfImage_CreateFromPixels(width, height, data.ptr));
	}

    override void dispose()
	{
		sfImage_Destroy(m_ptr);
	}

    /**
    *   Save the content of the image to a file
    *
    *   Params: 
    *       filename = Path of the file to save (overwritten if already exist)
    *
    *   Returns: 
    *       True if saving was successful
    */
    bool saveToFile(string filename)
	{
		return cast(bool)sfImage_SaveToFile(m_ptr, toStringz(filename));
	}

    /**
    *   Create an empty image
    *   
    *   Params:    
    *       width = Image width
    *       height = Image height
    *       col = Image color (black by default)
    *
    *   Returns: 
    *       True if creation was successful
    */
    bool create(uint width, uint height, Color col = Color.BLACK)
	{
		m_ptr = sfImage_CreateFromColor(width, height, col);
		return (m_ptr !is null); 
	}

    /**
    *   Create transparency mask from a specified colorkey
    *
    *   Params: 
    *       colorKey = Color to become transparent
    *       alpha = Alpha value to use for transparent pixels (0 by default)
    */
    void createMaskFromColor(Color colorKey, ubyte alpha = 0)
	{
		sfImage_CreateMaskFromColor(m_ptr, colorKey, alpha);
	}
    
//     /**
//     *   Create the image from the current contents of the
//     *   given window
//     *
//     *   Params:    
//     *       window = Window to capture
//     *       sourceRect = Sub-rectangle of the screen to copy (empty by default - entire image)
//     *
//     *   Returns:
//     *       True if copy was successful
//     */
//     void copyScreen(RenderWindow window, IntRect sourceRect = new IntRect())
//     {
//         return cast(bool)sfImage_CopyScreen(m_ptr, window.getNativePointer, sourceRect.toCIntRect());
//     }
    
    /**
    *   Copy pixels from another image onto this one.
    *   This function does a slow pixel copy and should only
    *   be used at initialization time
    *
    *   Params:
    *       source = Source image to copy
    *       destX = X coordinate of the destination position
    *       destY = Y coordinate of the destination position
    *       sourceRect = Sub-rectangle of the source image to copy
    */
    void copy(Image source, uint destX, uint destY, IntRect sourceRect = new IntRect())
    {
        sfImage_Copy(m_ptr, source.getNativePointer, destX, destY, sourceRect.toCIntRect());
    } 

    /**
    *   Change the color of a pixel
    *   Don't forget to call Update when you end modifying pixels
    *   
    *   Params:    
    *       x = X coordinate of pixel in the image
    *       y = Y coordinate of pixel in the image
    *       col = New color for pixel (X, Y)
    */
    void setPixel(uint x, uint y, Color col)
	{
		sfImage_SetPixel(m_ptr, x, y, col);
	}

    /**
    *   Get a pixel from the image
    *
    *   Params:    
    *       x = X coordinate of pixel in the image
    *       y = Y coordinate of pixel in the image
    *
    *   Returns: 
    *       Color of pixel (x, y)
    */
    Color getPixel(uint x, uint y)
	{
		return sfImage_GetPixel(m_ptr, x, y);
	}

    /**
    *   Get an array of pixels (8 bits integers RGBA)
    *   Array size is GetWidth() x GetHeight() x 4
    *   This array becomes invalid if you reload or resize the image
    *
    *   Returns:
    *       array of pixels
    */
    ubyte[] getPixelsArray()
	{
		return sfImage_GetPixelsPtr(m_ptr)[0..getWidth() * getHeight() * 4];
	}

    /**
    *   Bind the image for rendering
    */
    void bind()
	{
		sfImage_Bind(m_ptr);
	}

    /**
    *   Enable or disable image smooth filter.
    *   This parameter is enabled by default
    *
    *   Params: 
    *       smooth = True to enable smoothing filter, false to disable it
    */
    void setSmooth(bool smooth)
	{
		sfImage_SetSmooth(m_ptr, smooth);
	}

    /**
    *   Return the width of the image
    *
    *   Returns: 
    *       Width in pixels
    */
    uint getWidth()
	{
		return sfImage_GetWidth(m_ptr);
	}

    /**
    *   Return the height of the image
    *
    *   Returns: 
    *       Height in pixels
    */
    uint getHeight()
	{
		return sfImage_GetHeight(m_ptr);
	}
    
    /**
    *   Tells whether the smooth filtering is enabled or not
    *
    *   Returns:
    *       True if image smoothing is enabled
    */
    bool isSmooth()
    {
        return cast(bool)sfImage_IsSmooth(m_ptr);
    }
    
package:
    this(void* ptr)
    {
        super(ptr);
    }

private:
    extern (C)
    {
        typedef void* function() pf_sfImage_Create;
    	typedef void* function(uint, uint, Color) pf_sfImage_CreateFromColor;
    	typedef void* function(uint, uint, ubyte*) pf_sfImage_CreateFromPixels;
    	typedef void* function(cchar*) pf_sfImage_CreateFromFile;
    	typedef void* function(ubyte* ,size_t) pf_sfImage_CreateFromMemory;
    	typedef void function(void*) pf_sfImage_Destroy;
    	typedef int function(void*, cchar*) pf_sfImage_SaveToFile;
    	typedef void function(void*, Color, ubyte) pf_sfImage_CreateMaskFromColor;
        typedef int function(void*, void*, sfIntRect) pf_sfImage_CopyScreen;
    	typedef void function(void*, void*, uint, uint, sfIntRect) pf_sfImage_Copy;
    	typedef void function(void*, uint, uint, Color) pf_sfImage_SetPixel;
    	typedef Color function(void*, uint, uint) pf_sfImage_GetPixel;
    	typedef ubyte* function(void*) pf_sfImage_GetPixelsPtr;
    	typedef void function(void*) pf_sfImage_Bind;
    	typedef void function(void*, int) pf_sfImage_SetSmooth;
    	typedef uint function(void*) pf_sfImage_GetWidth;
    	typedef uint function(void*) pf_sfImage_GetHeight;
    	typedef int function(void*) pf_sfImage_IsSmooth;
    
    	static pf_sfImage_Create sfImage_Create;
    	static pf_sfImage_CreateFromColor sfImage_CreateFromColor;
    	static pf_sfImage_CreateFromPixels sfImage_CreateFromPixels;
    	static pf_sfImage_CreateFromFile sfImage_CreateFromFile;
    	static pf_sfImage_CreateFromMemory sfImage_CreateFromMemory;
    	static pf_sfImage_Destroy sfImage_Destroy;
    	static pf_sfImage_SaveToFile sfImage_SaveToFile;
    	static pf_sfImage_CreateMaskFromColor sfImage_CreateMaskFromColor;
    	static pf_sfImage_CopyScreen sfImage_CopyScreen;
    	static pf_sfImage_Copy sfImage_Copy;
    	static pf_sfImage_SetPixel sfImage_SetPixel;
    	static pf_sfImage_GetPixel sfImage_GetPixel;
    	static pf_sfImage_GetPixelsPtr sfImage_GetPixelsPtr;
    	static pf_sfImage_Bind sfImage_Bind;
    	static pf_sfImage_SetSmooth sfImage_SetSmooth;
    	static pf_sfImage_GetWidth sfImage_GetWidth;
    	static pf_sfImage_GetHeight sfImage_GetHeight;
    	static pf_sfImage_IsSmooth sfImage_IsSmooth;
    }

    static this()
    {
	debug
		DllLoader dll = DllLoader.load("csfml-graphics-d");
	else
		DllLoader dll = DllLoader.load("csfml-graphics");
        
        sfImage_Create = cast(pf_sfImage_Create)dll.getSymbol("sfImage_Create");
        sfImage_CreateFromColor = cast(pf_sfImage_CreateFromColor)dll.getSymbol("sfImage_CreateFromColor");
        sfImage_CreateFromPixels = cast(pf_sfImage_CreateFromPixels)dll.getSymbol("sfImage_CreateFromPixels");
        sfImage_CreateFromFile = cast(pf_sfImage_CreateFromFile)dll.getSymbol("sfImage_CreateFromFile");
        sfImage_CreateFromMemory = cast(pf_sfImage_CreateFromMemory)dll.getSymbol("sfImage_CreateFromMemory");
        sfImage_Destroy = cast(pf_sfImage_Destroy)dll.getSymbol("sfImage_Destroy");
        sfImage_SaveToFile = cast(pf_sfImage_SaveToFile)dll.getSymbol("sfImage_SaveToFile");
        sfImage_CreateMaskFromColor = cast(pf_sfImage_CreateMaskFromColor)dll.getSymbol("sfImage_CreateMaskFromColor");
        sfImage_CopyScreen = cast(pf_sfImage_CopyScreen)dll.getSymbol("sfImage_CopyScreen");
        sfImage_Copy = cast(pf_sfImage_Copy)dll.getSymbol("sfImage_Copy");
        sfImage_SetPixel = cast(pf_sfImage_SetPixel)dll.getSymbol("sfImage_SetPixel");
        sfImage_GetPixel = cast(pf_sfImage_GetPixel)dll.getSymbol("sfImage_GetPixel");
        sfImage_GetPixelsPtr = cast(pf_sfImage_GetPixelsPtr)dll.getSymbol("sfImage_GetPixelsPtr");
        sfImage_Bind = cast(pf_sfImage_Bind)dll.getSymbol("sfImage_Bind");
        sfImage_SetSmooth = cast(pf_sfImage_SetSmooth)dll.getSymbol("sfImage_SetSmooth");
        sfImage_GetWidth = cast(pf_sfImage_GetWidth)dll.getSymbol("sfImage_GetWidth");
        sfImage_GetHeight = cast(pf_sfImage_GetHeight)dll.getSymbol("sfImage_GetHeight");
        sfImage_IsSmooth = cast(pf_sfImage_IsSmooth)dll.getSymbol("sfImage_IsSmooth");
    }
}