Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

texture.cpp

Go to the documentation of this file.
00001 /************************************************************************
00002         filename:       texture.cpp
00003         created:        10/4/2004
00004         author:         Paul D Turner
00005         
00006         purpose:        Implements texture class for D3D8.1 system
00007 *************************************************************************/
00008 /*************************************************************************
00009     Crazy Eddie's GUI System (http://www.cegui.org.uk)
00010     Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
00011 
00012     This library is free software; you can redistribute it and/or
00013     modify it under the terms of the GNU Lesser General Public
00014     License as published by the Free Software Foundation; either
00015     version 2.1 of the License, or (at your option) any later version.
00016 
00017     This library is distributed in the hope that it will be useful,
00018     but WITHOUT ANY WARRANTY; without even the implied warranty of
00019     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020     Lesser General Public License for more details.
00021 
00022     You should have received a copy of the GNU Lesser General Public
00023     License along with this library; if not, write to the Free Software
00024     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00025 *************************************************************************/
00026 #include "renderers/directx81GUIRenderer/texture.h"
00027 #include "renderers/directx81GUIRenderer/renderer.h"
00028 #include "CEGUIExceptions.h"
00029 #include "CEGUISystem.h"
00030 
00031 #include <d3dx8.h>
00032 #include <dxerr8.h>
00033 
00034 // remove Microsoft idiocy
00035 #undef max
00036 #undef min
00037 
00038 
00039 // Start of CEGUI namespace section
00040 namespace CEGUI
00041 {
00042 
00043 /*************************************************************************
00044         Constructor
00045 *************************************************************************/
00046 DirectX81Texture::DirectX81Texture(Renderer* owner) :
00047         Texture(owner)
00048 {
00049         d_d3dtexture = NULL;
00050 
00051         // do this mainly to indicate the lack of a filename.
00052         d_isMemoryTexture = true;
00053 }
00054 
00055 /*************************************************************************
00056         Destructor
00057 *************************************************************************/
00058 DirectX81Texture::~DirectX81Texture(void)
00059 {
00060         freeD3DTexture();
00061 }
00062 
00063 /*************************************************************************
00064         Load texture from file.  Texture is made to be same size as image in
00065         file.
00066 *************************************************************************/
00067 void DirectX81Texture::loadFromFile(const String& filename, const String& resourceGroup)
00068 {
00069         freeD3DTexture();
00070 
00071         // load the file via the resource provider
00072         RawDataContainer texFile;
00073         System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, texFile, resourceGroup);
00074         
00075         D3DXIMAGE_INFO texInfo;
00076         HRESULT hr = D3DXCreateTextureFromFileInMemoryEx(((DirectX81Renderer*)getRenderer())->getDevice(), texFile.getDataPtr(), texFile.getSize(),
00077                                                 D3DX_DEFAULT, D3DX_DEFAULT, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
00078                                                 0, &texInfo, NULL, &d_d3dtexture);
00079 
00080         if (SUCCEEDED(hr))
00081         {
00082                 d_width         = texInfo.Width;
00083                 d_height        = texInfo.Height;
00084 
00085                 d_filename = filename;
00086         d_resourceGroup = resourceGroup;
00087                 d_isMemoryTexture = false;
00088         }
00089         else
00090         {
00091                 throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'.  Additional Info: " + (const utf8*)DXGetErrorString8(hr));
00092         }
00093 
00094 }
00095 
00096 
00097 /*************************************************************************
00098         Load texture from raw memory.   
00099 *************************************************************************/
00100 void DirectX81Texture::loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight)
00101 {
00102         using namespace std;
00103 
00104         // release old texture
00105         freeD3DTexture();
00106 
00107         // calculate square size big enough for whole memory buffer
00108         uint tex_size = ceguimax(buffWidth, buffHeight);
00109 
00110         // create a texture
00111         // TODO: Check resulting pixel format and react appropriately.
00112         HRESULT hr = D3DXCreateTexture(((DirectX81Renderer*)getRenderer())->getDevice(), tex_size, tex_size, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &d_d3dtexture);
00113 
00114         if (FAILED(hr))
00115         {
00116                 throw RendererException((utf8*)"Failed to load texture from memory: D3D Texture creation failed.");
00117         }
00118         else
00119         {
00120                 D3DSURFACE_DESC texdesc;
00121                 d_d3dtexture->GetLevelDesc(0, &texdesc);
00122 
00123                 // store new size;
00124                 d_width         = texdesc.Width;
00125                 d_height        = texdesc.Height;
00126 
00127                 // lock the D3D texture
00128                 D3DLOCKED_RECT  rect;
00129                 hr = d_d3dtexture->LockRect(0, &rect, NULL, 0);
00130 
00131                 if (FAILED(hr))
00132                 {
00133                         d_d3dtexture->Release();
00134                         d_d3dtexture = NULL;
00135 
00136                         throw RendererException((utf8*)"Failed to load texture from memory: IDirect3DTexture8::LockRect failed.");
00137                 }
00138                 else
00139                 {
00140                         // copy data from buffer into texture
00141                         ulong* dst = (ulong*)rect.pBits;
00142                         ulong* src = (ulong*)buffPtr;
00143 
00144                         for (uint i = 0; i < buffHeight; ++i)
00145                         {
00146                                 for (uint j = 0; j < buffWidth; ++j)
00147                                 {
00148                                         dst[j] = src[j];
00149                                 }
00150 
00151                                 dst += rect.Pitch / sizeof(ulong);
00152                                 src += buffWidth;
00153                         }
00154 
00155                         d_d3dtexture->UnlockRect(0);
00156                 }
00157 
00158         }
00159 
00160 }
00161 
00162 
00163 /*************************************************************************
00164         safely release D3D texture associated with this Texture
00165 *************************************************************************/
00166 void DirectX81Texture::freeD3DTexture(void)
00167 {
00168         if (d_d3dtexture != NULL)
00169         {
00170                 d_d3dtexture->Release();
00171                 d_d3dtexture = NULL;
00172         }
00173 
00174         d_filename.clear();
00175         d_isMemoryTexture = true;
00176 }
00177 
00178 
00179 /*************************************************************************
00180         allocate a D3D texture >= 'size'.  Previous D3D texture is lost
00181 *************************************************************************/
00182 void DirectX81Texture::setD3DTextureSize(uint size)
00183 {
00184         freeD3DTexture();
00185 
00186         HRESULT hr = D3DXCreateTexture(((DirectX81Renderer*)getRenderer())->getDevice(), size, size, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &d_d3dtexture);
00187 
00188         if (FAILED(hr))
00189         {
00190                 throw RendererException((utf8*)"Failed to create texture of specified size: D3D Texture creation failed.");
00191         }
00192         else
00193         {
00194                 D3DSURFACE_DESC texdesc;
00195                 d_d3dtexture->GetLevelDesc(0, &texdesc);
00196 
00197                 // store new size;
00198                 d_width         = texdesc.Width;
00199                 d_height        = texdesc.Height;
00200         }
00201 
00202 }
00203 
00204 
00205 /*************************************************************************
00206         Direct3D support method that must be called prior to a Reset call
00207         on the Direct3DDevice.
00208 *************************************************************************/
00209 void DirectX81Texture::preD3DReset(void)
00210 {
00211         // textures not based on files are in the managed pool, so we do
00212         // not worry about those.
00213         if (!d_isMemoryTexture)
00214         {
00215                 // release the d3d texture
00216                 if (d_d3dtexture != NULL)
00217                 {
00218                         if (FAILED(d_d3dtexture->Release()))
00219                         {
00220                                 throw RendererException("DirectX81Texture::preD3DReset - failed to release the Direct3DTexture8 object for this texture.");
00221                         }
00222 
00223                         d_d3dtexture = NULL;
00224                 }
00225 
00226         }
00227 
00228 }
00229 
00230 
00231 /*************************************************************************
00232         Direct3D support method that must be called after a Reset call on the
00233         Direct3DDevice.
00234 *************************************************************************/
00235 void DirectX81Texture::postD3DReset(void)
00236 {
00237         // textures not based on files are in the managed pool, so we do
00238         // not worry about those.
00239         if (!d_isMemoryTexture)
00240         {
00241                 // The reason this copy is made is that d_filename will be reset once we
00242                 // call loadFromFile and loading would always fail due to invalid filenames.
00243                 String name(d_filename);
00244 
00245                 // re-load the texture
00246                 loadFromFile(name, d_resourceGroup);
00247         }
00248 
00249 }
00250 
00251 } // End of  CEGUI namespace section

Generated on Wed Feb 16 12:41:08 2005 for Crazy Eddies GUI System by  doxygen 1.3.9.1