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
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Fri May 25 2012 21:48:50