ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreImage.h

@@ -0,0 +1,510 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef _Image_H__
+#define _Image_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreCommon.h"
+#include "OgrePixelFormat.h"
+#include "OgreDataStream.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Image
+	*  @{
+	*/
+
+    enum ImageFlags
+    {
+        IF_COMPRESSED = 0x00000001,
+        IF_CUBEMAP    = 0x00000002,
+        IF_3D_TEXTURE = 0x00000004
+    };
+    /** Class representing an image file.
+        @remarks
+            The Image class usually holds uncompressed image data and is the
+            only object that can be loaded in a texture. Image  objects handle 
+            image data decoding themselves by the means of locating the correct 
+            Codec object for each data type.
+        @par
+            Typically, you would want to use an Image object to load a texture
+            when extra processing needs to be done on an image before it is
+            loaded or when you want to blit to an existing texture.
+    */
+	class _OgreExport Image : public ImageAlloc
+    {
+    public:
+    	typedef Ogre::Box Box;
+    	typedef Ogre::Rect Rect;
+    public:
+        /** Standard constructor.
+        */
+        Image();
+        /** Copy-constructor - copies all the data from the target image.
+        */
+        Image( const Image &img );
+
+        /** Standard destructor.
+        */
+        virtual ~Image();
+
+        /** Assignment operator - copies all the data from the target image.
+        */
+        Image & operator = ( const Image & img );
+
+        /** Flips (mirrors) the image around the Y-axis. 
+            @remarks
+                An example of an original and flipped image:
+                <pre>                
+                originalimg
+                00000000000
+                00000000000
+                00000000000
+                00000000000
+                00000000000
+                ------------> flip axis
+                00000000000
+                00000000000
+                00000000000
+                00000000000
+                00000000000
+                originalimg
+                </pre>
+        */
+        Image & flipAroundY();
+
+        /** Flips (mirrors) the image around the X-axis.
+            @remarks
+                An example of an original and flipped image:
+                <pre>
+                        flip axis
+                            |
+                originalimg|gmilanigiro
+                00000000000|00000000000
+                00000000000|00000000000
+                00000000000|00000000000
+                00000000000|00000000000
+                00000000000|00000000000
+                </pre>
+        */                 
+        Image & flipAroundX();
+
+        /** Stores a pointer to raw data in memory. The pixel format has to be specified.
+            @remarks
+                This method loads an image into memory held in the object. The 
+                pixel format will be either greyscale or RGB with an optional
+                Alpha component.
+                The type can be determined by calling getFormat().             
+            @note
+				Whilst typically your image is likely to be a simple 2D image,
+				you can define complex images including cube maps, volume maps,
+				and images including custom mip levels. The layout of the 
+				internal memory should be:
+				<ul><li>face 0, mip 0 (top), width x height (x depth)</li>
+				<li>face 0, mip 1, width/2 x height/2 (x depth/2)</li>
+				<li>face 0, mip 2, width/4 x height/4 (x depth/4)</li>
+				<li>.. remaining mips for face 0 .. </li>
+				<li>face 1, mip 0 (top), width x height (x depth)</li
+				<li>.. and so on. </li>
+				</ul>
+				Of course, you will never have multiple faces (cube map) and
+				depth too.
+			@param
+                The data pointer
+            @param
+				Width of image
+            @param
+				Height of image
+			@param
+                Image Depth (in 3d images, numbers of layers, otherwise 1)
+            @param
+				Pixel Format
+            @param
+                if memory associated with this buffer is to be destroyed
+				with the Image object. Note: it's important that if you set
+				this option to true, that you allocated the memory using OGRE_ALLOC_T
+				with a category of MEMCATEGORY_GENERAL to ensure the freeing of memory 
+				matches up.
+			@param
+				the number of faces the image data has inside (6 for cubemaps, 1 otherwise)
+            @param
+                the number of mipmaps the image data has inside
+            @note
+                 The memory associated with this buffer is NOT destroyed with the
+                 Image object, unless autoDelete is set to true.
+			@remarks 
+				The size of the buffer must be numFaces*PixelUtil::getMemorySize(width, height, depth, format)
+         */
+		Image& loadDynamicImage( uchar* data, size_t width, size_t height, 
+							size_t depth,
+							 PixelFormat format, bool autoDelete = false, 
+							 size_t numFaces = 1, size_t numMipMaps = 0);
+		
+		/** Stores a pointer to raw data in memory. The pixel format has to be specified.
+            @remarks
+                This method loads an image into memory held in the object. The 
+                pixel format will be either greyscale or RGB with an optional
+                Alpha component.
+                The type can be determined by calling getFormat().             
+            @note
+				Whilst typically your image is likely to be a simple 2D image,
+				you can define complex images including cube maps
+				and images including custom mip levels. The layout of the 
+				internal memory should be:
+				<ul><li>face 0, mip 0 (top), width x height</li>
+				<li>face 0, mip 1, width/2 x height/2 </li>
+				<li>face 0, mip 2, width/4 x height/4 </li>
+				<li>.. remaining mips for face 0 .. </li>
+				<li>face 1, mip 0 (top), width x height (x depth)</li
+				<li>.. and so on. </li>
+				</ul>
+				Of course, you will never have multiple faces (cube map) and
+				depth too.
+            @param
+                The data pointer
+            @param
+				Width of image
+            @param
+				Height of image
+            @param
+				Pixel Format
+            @note
+                 The memory associated with this buffer is NOT destroyed with the
+                 Image object.
+			@remarks This function is deprecated; one should really use the
+				Image::loadDynamicImage(data, width, height, depth, format, ...) to be compatible
+				with future Ogre versions.
+         */
+ 		Image& loadDynamicImage( uchar* data, size_t width,
+								 size_t height, PixelFormat format)
+		{
+			return loadDynamicImage(data, width, height, 1, format);
+		}
+		/** Loads raw data from a stream. See the function
+			loadDynamicImage for a description of the parameters.
+			@remarks 
+				The size of the buffer must be numFaces*PixelUtil::getMemorySize(width, height, depth, format)
+            @note
+				Whilst typically your image is likely to be a simple 2D image,
+				you can define complex images including cube maps
+				and images including custom mip levels. The layout of the 
+				internal memory should be:
+				<ul><li>face 0, mip 0 (top), width x height (x depth)</li>
+				<li>face 0, mip 1, width/2 x height/2 (x depth/2)</li>
+				<li>face 0, mip 2, width/4 x height/4 (x depth/4)</li>
+				<li>.. remaining mips for face 0 .. </li>
+				<li>face 1, mip 0 (top), width x height (x depth)</li
+				<li>.. and so on. </li>
+				</ul>
+				Of course, you will never have multiple faces (cube map) and
+				depth too.
+        */
+        Image & loadRawData( 
+            DataStreamPtr& stream, 
+            size_t width, size_t height, size_t depth,
+            PixelFormat format,
+			size_t numFaces = 1, size_t numMipMaps = 0);
+        /** Loads raw data from a stream. The pixel format has to be specified. 
+			@remarks This function is deprecated; one should really use the
+				Image::loadRawData(stream, width, height, depth, format, ...) to be compatible
+				with future Ogre versions.
+            @note
+				Whilst typically your image is likely to be a simple 2D image,
+				you can define complex images including cube maps
+				and images including custom mip levels. The layout of the 
+				internal memory should be:
+				<ul><li>face 0, mip 0 (top), width x height</li>
+				<li>face 0, mip 1, width/2 x height/2 </li>
+				<li>face 0, mip 2, width/4 x height/4 </li>
+				<li>.. remaining mips for face 0 .. </li>
+				<li>face 1, mip 0 (top), width x height (x depth)</li
+				<li>.. and so on. </li>
+				</ul>
+				Of course, you will never have multiple faces (cube map) and
+				depth too.
+        */
+        Image & loadRawData( 
+            DataStreamPtr& stream, 
+            size_t width, size_t height, 
+            PixelFormat format )
+		{
+			return loadRawData(stream, width, height, 1, format);
+		}
+
+        /** Loads an image file.
+            @remarks
+                This method loads an image into memory. Any format for which 
+				an associated ImageCodec is registered can be loaded. 
+				This can include complex formats like DDS with embedded custom 
+				mipmaps, cube faces and volume textures.
+                The type can be determined by calling getFormat().             
+            @param
+                filename Name of an image file to load.
+            @param
+                groupName Name of the resource group to search for the image
+            @note
+                The memory associated with this buffer is destroyed with the
+                Image object.
+        */
+        Image & load( const String& filename, const String& groupName );
+
+        /** Loads an image file from a stream.
+            @remarks
+                This method works in the same way as the filename-based load 
+                method except it loads the image from a DataStream object. 
+				This DataStream is expected to contain the 
+                encoded data as it would be held in a file. 
+                Any format for which an associated ImageCodec is registered 
+				can be loaded. 
+				This can include complex formats like DDS with embedded custom 
+				mipmaps, cube faces and volume textures.
+                The type can be determined by calling getFormat().             
+            @param
+                stream The source data.
+            @param
+                type The type of the image. Used to decide what decompression
+                codec to use. Can be left blank if the stream data includes
+				a header to identify the data.
+            @see
+                Image::load( const String& filename )
+        */
+		Image & load(DataStreamPtr& stream, const String& type = StringUtil::BLANK );
+
+		/** Utility method to combine 2 separate images into this one, with the first
+		image source supplying the RGB channels, and the second image supplying the 
+		alpha channel (as luminance or separate alpha). 
+		@param rgbFilename Filename of image supplying the RGB channels (any alpha is ignored)
+		@param alphaFilename Filename of image supplying the alpha channel. If a luminance image the
+			single channel is used directly, if an RGB image then the values are
+			converted to greyscale.
+		@param groupName The resource group from which to load the images
+		@param format The destination format
+		*/
+		Image & loadTwoImagesAsRGBA(const String& rgbFilename, const String& alphaFilename,
+			const String& groupName, PixelFormat format = PF_BYTE_RGBA);
+
+		/** Utility method to combine 2 separate images into this one, with the first
+		image source supplying the RGB channels, and the second image supplying the 
+		alpha channel (as luminance or separate alpha). 
+		@param rgbStream Stream of image supplying the RGB channels (any alpha is ignored)
+		@param alphaStream Stream of image supplying the alpha channel. If a luminance image the
+			single channel is used directly, if an RGB image then the values are
+			converted to greyscale.
+		@param format The destination format
+		@param rgbType The type of the RGB image. Used to decide what decompression
+			codec to use. Can be left blank if the stream data includes
+			a header to identify the data.
+		@param alphaType The type of the alpha image. Used to decide what decompression
+			codec to use. Can be left blank if the stream data includes
+			a header to identify the data.
+		*/
+		Image & loadTwoImagesAsRGBA(DataStreamPtr& rgbStream, DataStreamPtr& alphaStream, PixelFormat = PF_BYTE_RGBA,
+			const String& rgbType = StringUtil::BLANK, const String& alphaType = StringUtil::BLANK);
+
+		/** Utility method to combine 2 separate images into this one, with the first
+			image source supplying the RGB channels, and the second image supplying the 
+			alpha channel (as luminance or separate alpha). 
+		@param rgb Image supplying the RGB channels (any alpha is ignored)
+		@param alpha Image supplying the alpha channel. If a luminance image the
+			single channel is used directly, if an RGB image then the values are
+			converted to greyscale.
+		@param format The destination format
+		*/
+		Image & combineTwoImagesAsRGBA(const Image& rgb, const Image& alpha, PixelFormat format = PF_BYTE_RGBA);
+
+        
+        /** Save the image as a file. 
+		@remarks
+			Saving and loading are implemented by back end (sometimes third 
+			party) codecs.  Implemented saving functionality is more limited
+			than loading in some cases.	Particularly DDS file format support 
+			is currently limited to true colour or single channel float32, 
+			square, power of two textures with no mipmaps.  Volumetric support
+			is currently limited to DDS files.
+		*/
+        void save(const String& filename);
+
+		/** Encode the image and return a stream to the data. 
+			@param formatextension An extension to identify the image format
+				to encode into, e.g. "jpg" or "png"
+		*/
+		DataStreamPtr encode(const String& formatextension);
+
+		/** Returns a pointer to the internal image buffer.
+		@remarks
+			Be careful with this method. You will almost certainly
+			prefer to use getPixelBox, especially with complex images
+			which include many faces or custom mipmaps.
+        */
+        uchar* getData(void);
+
+        /** Returns a const pointer to the internal image buffer.
+		@remarks
+			Be careful with this method. You will almost certainly
+			prefer to use getPixelBox, especially with complex images
+			which include many faces or custom mipmaps.
+        */
+        const uchar * getData() const;       
+
+        /** Returns the size of the data buffer.
+        */
+        size_t getSize() const;
+
+        /** Returns the number of mipmaps contained in the image.
+        */
+        size_t getNumMipmaps() const;
+
+        /** Returns true if the image has the appropriate flag set.
+        */
+        bool hasFlag(const ImageFlags imgFlag) const;
+
+        /** Gets the width of the image in pixels.
+        */
+        size_t getWidth(void) const;
+
+        /** Gets the height of the image in pixels.
+        */
+        size_t getHeight(void) const;
+
+        /** Gets the depth of the image.
+        */
+        size_t getDepth(void) const;
+		
+		/** Get the number of faces of the image. This is usually 6 for a cubemap, and
+		    1 for a normal image.
+		*/
+		size_t getNumFaces(void) const;
+
+        /** Gets the physical width in bytes of each row of pixels.
+        */
+        size_t getRowSpan(void) const;
+
+        /** Returns the image format.
+        */
+        PixelFormat getFormat() const;
+
+        /** Returns the number of bits per pixel.
+        */
+        uchar getBPP() const;
+
+        /** Returns true if the image has an alpha component.
+        */
+        bool getHasAlpha() const;
+		
+		/** Does gamma adjustment.
+            @note
+                Basic algo taken from Titan Engine, copyright (c) 2000 Ignacio 
+                Castano Iguado
+        */
+        static void applyGamma( uchar *buffer, Real gamma, size_t size, uchar bpp );
+
+        /**
+         * Get colour value from a certain location in the image. The z coordinate
+         * is only valid for cubemaps and volume textures. This uses the first (largest)
+         * mipmap.
+         */
+        ColourValue getColourAt(size_t x, size_t y, size_t z) const;
+        
+        /**
+         * Set colour value at a certain location in the image. The z coordinate
+         * is only valid for cubemaps and volume textures. This uses the first (largest)
+         * mipmap.
+         */
+        void setColourAt(ColourValue const &cv, size_t x, size_t y, size_t z);
+
+        /**
+         * Get a PixelBox encapsulating the image data of a mipmap
+         */
+        PixelBox getPixelBox(size_t face = 0, size_t mipmap = 0) const;
+
+		/// Delete all the memory held by this image, if owned by this image (not dynamic)
+		void freeMemory();
+
+		enum Filter
+		{
+			FILTER_NEAREST,
+			FILTER_LINEAR,
+			FILTER_BILINEAR,
+			FILTER_BOX,
+			FILTER_TRIANGLE,
+			FILTER_BICUBIC
+		};
+		/** Scale a 1D, 2D or 3D image volume. 
+			@param 	src			PixelBox containing the source pointer, dimensions and format
+			@param 	dst			PixelBox containing the destination pointer, dimensions and format
+			@param 	filter		Which filter to use
+			@remarks 	This function can do pixel format conversion in the process.
+			@note	dst and src can point to the same PixelBox object without any problem
+		*/
+		static void scale(const PixelBox &src, const PixelBox &dst, Filter filter = FILTER_BILINEAR);
+		
+		/** Resize a 2D image, applying the appropriate filter. */
+		void resize(ushort width, ushort height, Filter filter = FILTER_BILINEAR);
+		
+        // Static function to calculate size in bytes from the number of mipmaps, faces and the dimensions
+        static size_t calculateSize(size_t mipmaps, size_t faces, size_t width, size_t height, size_t depth, PixelFormat format);
+
+		/// Static function to get an image type string from a stream via magic numbers
+		static String getFileExtFromMagic(DataStreamPtr stream);
+
+    protected:
+        // The width of the image in pixels
+	size_t mWidth;
+        // The height of the image in pixels
+	size_t mHeight;
+        // The depth of the image
+	size_t mDepth;
+        // The size of the image buffer
+	size_t mBufSize;
+        // The number of mipmaps the image contains
+	size_t mNumMipmaps;
+        // Image specific flags.
+	int mFlags;
+
+        // The pixel format of the image
+	PixelFormat mFormat;
+
+        // The number of bytes per pixel
+	uchar mPixelSize;
+	uchar* mBuffer;
+
+		// A bool to determine if we delete the buffer or the calling app does
+		bool mAutoDelete;
+    };
+
+	typedef vector<Image*>::type ImagePtrList;
+	typedef vector<const Image*>::type ConstImagePtrList;
+
+	/** @} */
+	/** @} */
+
+} // namespace
+
+#endif

data/deps/include/OGRE/OgreImageCodec.h

@@ -0,0 +1,89 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef _ImageCodec_H__
+#define _ImageCodec_H__
+
+#include "OgreCodec.h"
+#include "OgrePixelFormat.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Image
+	*  @{
+	*/
+	/** Codec specialized in images.
+        @remarks
+            The users implementing subclasses of ImageCodec are required to return
+            a valid pointer to a ImageData class from the decode(...) function.
+    */
+    class _OgreExport ImageCodec : public Codec
+    {
+    public:
+        virtual ~ImageCodec();
+        /** Codec return class for images. Has information about the size and the
+            pixel format of the image. */
+        class _OgrePrivate ImageData : public Codec::CodecData
+        {
+        public:
+			ImageData():
+				height(0), width(0), depth(1), size(0),
+				num_mipmaps(0), flags(0), format(PF_UNKNOWN)
+			{
+			}
+            size_t height;
+            size_t width;
+			size_t depth;
+            size_t size;
+            
+            ushort num_mipmaps;
+            uint flags;
+
+            PixelFormat format;
+
+        public:
+            String dataType() const
+            {
+                return "ImageData";
+            }
+        };
+
+    public:
+        String getDataType() const
+        {
+            return "ImageData";
+        }
+    };
+
+	/** @} */
+	/** @} */
+} // namespace
+
+#endif