OgreTexture.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 _Texture_H__
#define _Texture_H__

#include "OgrePrerequisites.h"
#include "OgreHardwareBuffer.h"
#include "OgreResource.h"
#include "OgreImage.h"

namespace Ogre {

    enum TextureUsage
    {
        TU_STATIC = HardwareBuffer::HBU_STATIC,
        TU_DYNAMIC = HardwareBuffer::HBU_DYNAMIC,
        TU_WRITE_ONLY = HardwareBuffer::HBU_WRITE_ONLY,
        TU_STATIC_WRITE_ONLY = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
        TU_DYNAMIC_WRITE_ONLY = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY,
        TU_DYNAMIC_WRITE_ONLY_DISCARDABLE = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
        TU_AUTOMIPMAP = 0x100,
        TU_RENDERTARGET = 0x200,
        TU_DEFAULT = TU_AUTOMIPMAP | TU_STATIC_WRITE_ONLY
        
    };

    enum TextureType
    {
        TEX_TYPE_1D = 1,
        TEX_TYPE_2D = 2,
        TEX_TYPE_3D = 3,
        TEX_TYPE_CUBE_MAP = 4
    };

    enum TextureMipmap
    {
        MIP_UNLIMITED = 0x7FFFFFFF
    };

    // Forward declaration
    class TexturePtr;

    class _OgreExport Texture : public Resource
    {
    public:
        Texture(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);

        virtual void setTextureType(TextureType ttype ) { mTextureType = ttype; }

        virtual TextureType getTextureType(void) const { return mTextureType; }

        virtual size_t getNumMipmaps(void) const {return mNumMipmaps;}

        virtual void setNumMipmaps(size_t num) {mNumRequestedMipmaps = mNumMipmaps = num;}

        virtual bool getMipmapsHardwareGenerated(void) const { return mMipmapsHardwareGenerated; }

        virtual float getGamma(void) const { return mGamma; }

        virtual void setGamma(float g) { mGamma = g; }

        virtual unsigned int getHeight(void) const { return mHeight; }

        virtual unsigned int getWidth(void) const { return mWidth; }

        virtual unsigned int getDepth(void) const { return mDepth; }

        virtual unsigned int getSrcHeight(void) const { return mSrcHeight; }

        virtual unsigned int getSrcWidth(void) const { return mSrcWidth; }

        virtual unsigned int getSrcDepth(void) const { return mSrcDepth; }

        virtual void setHeight(unsigned int h) { mHeight = mSrcHeight = h; }

        virtual void setWidth(unsigned int w) { mWidth = mSrcWidth = w; }

        virtual void setDepth(unsigned int d)  { mDepth = mSrcDepth = d; }

        virtual int getUsage() const
        {
            return mUsage;
        }

        virtual void setUsage(int u) { mUsage = u; }

        virtual void createInternalResources(void);

        virtual void freeInternalResources(void);
        virtual void copyToTexture( TexturePtr& target ) {}

        virtual void loadImage( const Image &img ) = 0;
            
        virtual void loadRawData( DataStreamPtr& stream, 
            ushort uWidth, ushort uHeight, PixelFormat eFormat);

        virtual void enable32Bit( bool setting = true ) 
        {
            setting ? mFinalBpp = 32 : mFinalBpp = 16;
        }

        virtual PixelFormat getFormat() const
        {
            return mFormat;
        }

        virtual void setFormat(PixelFormat pf);

        virtual bool hasAlpha(void) const
        {
            return mHasAlpha;
        }
        
        virtual size_t getNumFaces() const;

        virtual HardwarePixelBufferSharedPtr getBuffer(size_t face=0, size_t mipmap=0) = 0;

    protected:
        unsigned long mHeight;
        unsigned long mWidth;
        unsigned long mDepth;

        size_t mNumRequestedMipmaps;
        size_t mNumMipmaps;
        bool mMipmapsHardwareGenerated;
        float mGamma;

        TextureType mTextureType;
        PixelFormat mFormat;
        int mUsage; // Bit field, so this can't be TextureUsage

        unsigned short mSrcBpp;
        unsigned long mSrcWidth, mSrcHeight, mSrcDepth;
        unsigned short mFinalBpp;
        bool mHasAlpha;

        bool mInternalResourcesCreated;

        size_t calculateSize(void) const;
        
        virtual void _loadImages( const std::vector<const Image*>& images );


        virtual void createInternalResourcesImpl(void) = 0;

        virtual void freeInternalResourcesImpl(void) = 0;

        void unloadImpl(void);

    };

    class _OgreExport TexturePtr : public SharedPtr<Texture> 
    {
    public:
        TexturePtr() : SharedPtr<Texture>() {}
        explicit TexturePtr(Texture* rep) : SharedPtr<Texture>(rep) {}
        TexturePtr(const TexturePtr& r) : SharedPtr<Texture>(r) {} 
        TexturePtr(const ResourcePtr& r) : SharedPtr<Texture>()
        {
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Texture*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
        }

        TexturePtr& operator=(const ResourcePtr& r)
        {
            if (pRep == static_cast<Texture*>(r.getPointer()))
                return *this;
            release();
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Texture*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
            return *this;
        }
    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:54 2006