OgreImage.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _Image_H__
#define _Image_H__

#include "OgrePrerequisites.h"
#include "OgreCommon.h"
#include "OgrePixelFormat.h"
#include "OgreDataStream.h"

namespace Ogre {

    enum ImageFlags
    {
        IF_COMPRESSED = 0x00000001,
        IF_CUBEMAP    = 0x00000002,
        IF_3D_TEXTURE = 0x00000004
    };
    class _OgreExport Image
    {
    public:
        typedef Ogre::Box Box;
        typedef Ogre::Rect Rect;
    public:
        Image();
        Image( const Image &img );

        virtual ~Image();

        Image & operator = ( const Image & img );

        Image & flipAroundY();

        Image & flipAroundX();

        Image& loadDynamicImage( uchar* pData, size_t uWidth, size_t uHeight, 
                            size_t depth,
                             PixelFormat eFormat, bool autoDelete = false, 
                             size_t numFaces = 1, size_t numMipMaps = 0);
        
        Image& loadDynamicImage( uchar* pData, size_t uWidth,
                                 size_t uHeight, PixelFormat eFormat)
        {
            return loadDynamicImage(pData, uWidth, uHeight, 1, eFormat);
        }
        Image & loadRawData( 
            DataStreamPtr& stream, 
            size_t uWidth, size_t uHeight, size_t uDepth,
            PixelFormat eFormat,
            size_t numFaces = 1, size_t numMipMaps = 0);
        Image & loadRawData( 
            DataStreamPtr& stream, 
            size_t uWidth, size_t uHeight, 
            PixelFormat eFormat )
        {
            return loadRawData(stream, uWidth, uHeight, 1, eFormat);
        }

        Image & load( const String& strFileName, const String& groupName );

        Image & load(DataStreamPtr& stream, const String& type );
        
        void save(const String& filename);

        uchar* getData(void);

        const uchar * getData() const;       

        size_t getSize() const;

        size_t getNumMipmaps() const;

        bool hasFlag(const ImageFlags imgFlag) const;

        size_t getWidth(void) const;

        size_t getHeight(void) const;

        size_t getDepth(void) const;
        
        size_t getNumFaces(void) const;

        size_t getRowSpan(void) const;

        PixelFormat getFormat() const;

        uchar getBPP() const;

        bool getHasAlpha() const;
        
        static void applyGamma( uchar *buffer, Real gamma, size_t size, uchar bpp );

        ColourValue getColourAt(int x, int y, int z);
        
        PixelBox getPixelBox(size_t face = 0, size_t mipmap = 0) const;

        enum Filter
        {
            FILTER_NEAREST,
            FILTER_LINEAR,
            FILTER_BILINEAR,
            FILTER_BOX,
            FILTER_TRIANGLE,
            FILTER_BICUBIC
        };
        static void scale(const PixelBox &src, const PixelBox &dst, Filter filter = FILTER_BILINEAR);
        
        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);
    private:
        // The width of the image in pixels
        size_t m_uWidth;
        // The height of the image in pixels
        size_t m_uHeight;
        // The depth of the image
        size_t m_uDepth;
        // The size of the image buffer
        size_t m_uSize;
        // The number of mipmaps the image contains
        size_t m_uNumMipmaps;
        // Image specific flags.
        int m_uFlags;

        // The pixel format of the image
        PixelFormat m_eFormat;

        // The number of bytes per pixel
        uchar m_ucPixelSize;
        uchar* m_pBuffer;

        // A bool to determine if we delete the buffer or the calling app does
        bool m_bAutoDelete;
    };

} // namespace

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:42 2006