OgreGLESTexture.h
Go to the documentation of this file.

    00001 /*
    00002 -----------------------------------------------------------------------------
    00003 This source file is part of OGRE
    00004     (Object-oriented Graphics Rendering Engine)
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2008 Renato Araujo Oliveira Filho <renatox@gmail.com>
    00008 Copyright (c) 2000-2012 Torus Knot Software Ltd
    00009
    00010 Permission is hereby granted, free of charge, to any person obtaining a copy
    00011 of this software and associated documentation files (the "Software"), to deal
    00012 in the Software without restriction, including without limitation the rights
    00013 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    00014 copies of the Software, and to permit persons to whom the Software is
    00015 furnished to do so, subject to the following conditions:
    00016
    00017 The above copyright notice and this permission notice shall be included in
    00018 all copies or substantial portions of the Software.
    00019
    00020 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    00021 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00022 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    00023 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00024 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    00025 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    00026 THE SOFTWARE.
    00027 -----------------------------------------------------------------------------
    00028 */
    00029
    00030 #ifndef __GLESTexture_H__
    00031 #define __GLESTexture_H__
    00032
    00033 #include "OgreGLESPrerequisites.h"
    00034 #include "OgreGLESSupport.h"
    00035 #include "OgrePlatform.h"
    00036 #include "OgreRenderTexture.h"
    00037 #include "OgreTexture.h"
    00038 #include "OgreHardwarePixelBuffer.h"
    00039
    00040 namespace Ogre {
    00041     class _OgreGLESExport GLESTexture : public Texture
    00042     {
    00043         public:
    00044             // Constructor
    00045             GLESTexture(ResourceManager* creator, const String& name, ResourceHandle handle,
    00046                 const String& group, bool isManual, ManualResourceLoader* loader,
    00047                 GLESSupport& support);
    00048
    00049             virtual ~GLESTexture();
    00050
    00051             void createRenderTexture();
    00053             HardwarePixelBufferSharedPtr getBuffer(size_t face, size_t mipmap);
    00054
    00055             // Takes the OGRE texture type (1d/2d/3d/cube) and returns the appropriate GL one
    00056             GLenum getGLESTextureTarget(void) const;
    00057
    00058             GLuint getGLID() const
    00059             {
    00060                 return mTextureID;
    00061             }
    00062
    00063         protected:
    00065             void createInternalResourcesImpl(void);
    00067             void prepareImpl(void);
    00069             void unprepareImpl(void);
    00071             void loadImpl(void);
    00073             void freeInternalResourcesImpl(void);
    00074
    00080             void _createSurfaceList();
    00081
    00083             typedef SharedPtr<std::vector<Image> > LoadedImages;
    00084
    00089             LoadedImages mLoadedImages;
    00090
    00091         private:
    00092             GLuint mTextureID;
    00093             GLESSupport& mGLSupport;
    00094
    00096             typedef std::vector<HardwarePixelBufferSharedPtr> SurfaceList;
    00097             SurfaceList mSurfaceList;
    00098
    00099     };
    00100
    00107     class _OgreGLESExport GLESTexturePtr : public SharedPtr<GLESTexture>
    00108     {
    00109         public:
    00110             GLESTexturePtr() : SharedPtr<GLESTexture>() {}
    00111             explicit GLESTexturePtr(GLESTexture* rep) : SharedPtr<GLESTexture>(rep) {}
    00112             GLESTexturePtr(const GLESTexturePtr& r) : SharedPtr<GLESTexture>(r) {}
    00113
    00114             GLESTexturePtr(const ResourcePtr& r) : SharedPtr<GLESTexture>()
    00115             {
    00116                 // lock & copy other mutex pointer
    00117                 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
    00118                 {
    00119                     OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
    00120                     OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
    00121                     pRep = static_cast<GLESTexture*>(r.getPointer());
    00122                     pUseCount = r.useCountPointer();
    00123                     if (pUseCount)
    00124                     {
    00125                         ++(*pUseCount);
    00126                     }
    00127                 }
    00128             }
    00129
    00130             GLESTexturePtr(const TexturePtr& r) : SharedPtr<GLESTexture>()
    00131             {
    00132                 *this = r;
    00133             }
    00134
    00136             GLESTexturePtr& operator=(const ResourcePtr& r)
    00137             {
    00138                 if (pRep == static_cast<GLESTexture*>(r.getPointer()))
    00139                 {
    00140                     return *this;
    00141                 }
    00142                 release();
    00143                 // lock & copy other mutex pointer
    00144                 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
    00145                 {
    00146                     OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
    00147                     OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
    00148                     pRep = static_cast<GLESTexture*>(r.getPointer());
    00149                     pUseCount = r.useCountPointer();
    00150                     if (pUseCount)
    00151                     {
    00152                         ++(*pUseCount);
    00153                     }
    00154                 }
    00155                 else
    00156                 {
    00157                     // RHS must be a null pointer
    00158                     assert(r.isNull() && "RHS must be null if it has no mutex!");
    00159                     setNull();
    00160                 }
    00161                 return *this;
    00162             }
    00163
    00165             GLESTexturePtr& operator=(const TexturePtr& r)
    00166             {
    00167                 if (pRep == static_cast<GLESTexture*>(r.getPointer()))
    00168                     return *this;
    00169                 release();
    00170                 // lock & copy other mutex pointer
    00171                 OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
    00172                 {
    00173                     OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
    00174                     OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
    00175                     pRep = static_cast<GLESTexture*>(r.getPointer());
    00176                     pUseCount = r.useCountPointer();
    00177                     if (pUseCount)
    00178                     {
    00179                         ++(*pUseCount);
    00180                     }
    00181                 }
    00182                 else
    00183                 {
    00184                     // RHS must be a null pointer
    00185                     assert(r.isNull() && "RHS must be null if it has no mutex!");
    00186                     setNull();
    00187                 }
    00188                 return *this;
    00189             }
    00190     };
    00191 }
    00192
    00193 #endif

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun Sep 2 2012 07:27:21