bool TextureDX9Imp::acquireResource()
{
    if( NULL != textureDX9_ ) return true;

    LPDIRECT3DTEXTURE9 newTexDX9;
    if( isFromFile() )
    {
        const HRESULT hr = D3DXCreateTextureFromFileEx( getD3D9Device(), filename_.c_str(),
            D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0,
            D3DFMT_UNKNOWN, D3DPOOL_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
            0, NULL, NULL, & newTexDX9 );
        RETURN_FALSE_IF_FAILED( hr, L"TextureDX9Imp::acquireResource" );
    }
    else
    {
        const HRESULT hr = D3DXCreateTexture( getD3D9Device(),
            requiredWidth_, requiredHeight_, requiredMipLevels_, requiredUsage_,
            requiredFormat_, requiredPool_, & newTexDX9 );
        RETURN_FALSE_IF_FAILED( hr, L"TextureDX9Imp::acquireResource" );
    }

    textureDX9_ = IDirect3DTexture9Ptr( newTexDX9, ComReleaser< IDirect3DTexture9 >() );

    MY_FOR_EACH( Surfaces, iter, surfaces_ )
        acquireSurface( iter->level );
    return true;
}
    void D3D9RenderWindow::getCustomAttribute( const String& name, void* pData )
    {
        // Valid attributes and their equvalent native functions:
        // D3DDEVICE            : getD3DDevice
        // WINDOW               : getWindowHandle

        if( name == "D3DDEVICE" )
        {
            *(IDirect3DDevice9**)pData = getD3D9Device();
        }       
        else if( name == "WINDOW" )
        {
            *(HWND*)pData = getWindowHandle();
        }
        else if( name == "isTexture" )
        {
            *(bool*)pData = false;
        }
        else if( name == "D3DZBUFFER" )
        {
            *(IDirect3DSurface9**)pData = mDevice->getDepthBuffer(this);
        }
        else if( name == "DDBACKBUFFER" )
        {
            *(IDirect3DSurface9**)pData = mDevice->getBackBuffer(this);
        }
        else if( name == "DDFRONTBUFFER" )
        {
            *(IDirect3DSurface9**)pData = mDevice->getBackBuffer(this);
        }
    }
SurfaceDX9 * RenderWin32DX9Imp::acquireBackBuffer( size_t whichBackBuffer )
{
    IDirect3DSurface9 * newDXSurface;
    const HRESULT hr = getD3D9Device()->GetBackBuffer( 0, whichBackBuffer, D3DBACKBUFFER_TYPE_MONO, &newDXSurface );
    RETURN_NULL_IF_FAILED( hr, L"RenderWin32DX9Imp::acquireBackBuffer" );

    SurfaceDX9Ptr newSurface = SurfaceDX9Ptr( new SurfaceDX9Imp( IDirect3DSurface9Ptr( newDXSurface, ComReleaser< IDirect3DSurface9 >() ) ) );
    backBuffers_.push_back( newSurface );
    return newSurface.get();
}
D3DSURFACE_DESC RenderWin32DX9Imp::getRenderTargetDesc() {
    LPDIRECT3DSURFACE9 currentRenderTarget = NULL;
    const HRESULT hr = getD3D9Device()->GetRenderTarget( 0, & currentRenderTarget );
    if( FAILED( hr ) ) {
        DXUT_ERR( L"RenderWin32DX9Imp::getHeight", hr );
        throw exception();
    }

    D3DSURFACE_DESC desc;
    currentRenderTarget->GetDesc( & desc );
    SAFE_RELEASE( currentRenderTarget );

    return desc;
}
	void D3D9RenderWindow::getCustomAttribute( const String& name, void* pData )
	{
		// Valid attributes and their equvalent native functions:
		// D3DDEVICE			: getD3DDevice
		// WINDOW				: getWindowHandle

		if( name == "D3DDEVICE" )
		{
			IDirect3DDevice9* *pDev = (IDirect3DDevice9**)pData;
			*pDev = getD3D9Device();
			return;
		}		
		else if( name == "WINDOW" )
		{
			HWND *pHwnd = (HWND*)pData;
			*pHwnd = getWindowHandle();
			return;
		}
		else if( name == "isTexture" )
		{
			bool *b = reinterpret_cast< bool * >( pData );
			*b = false;

			return;
		}
		else if( name == "D3DZBUFFER" )
		{
			IDirect3DSurface9* *pSurf = (IDirect3DSurface9**)pData;
			*pSurf = mDevice->getDepthBuffer(this);
			return;
		}
		else if( name == "DDBACKBUFFER" )
		{
			IDirect3DSurface9* *pSurf = (IDirect3DSurface9**)pData;
			*pSurf = mDevice->getBackBuffer(this);
			return;
		}
		else if( name == "DDFRONTBUFFER" )
		{
			IDirect3DSurface9* *pSurf = (IDirect3DSurface9**)pData;
			*pSurf = mDevice->getBackBuffer(this);
			return;
		}
	}
void RenderWin32DX9Imp::clear_Z_Stencil( float z, NxU32 stencil ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0, z, stencil );
}
void RenderWin32DX9Imp::showCursor( bool val ) {
    getD3D9Device()->ShowCursor( val );
}
void RenderWin32DX9Imp::endScene() {
    getD3D9Device()->EndScene();
}
bool RenderWin32DX9Imp::isDeviceCreated() {
    return NULL != getD3D9Device();
}
void RenderWin32DX9Imp::setCursorPosition( int x, int y ) {
    getD3D9Device()->SetCursorPosition( x, y, 0 );
}
void RenderWin32DX9Imp::clear_Z( float z ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_ZBUFFER, 0, z, 0 );
}
void RenderWin32DX9Imp::clear_Color( NxU32 Color ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_TARGET, Color, 1.f, 0 );
}
void RenderWin32DX9Imp::clear_Color_Z_Stencil( NxU32 Color, float z, NxU32 stencil ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, Color, z, stencil );
}
bool RenderWin32DX9Imp::beginScene() {
    return D3D_OK == getD3D9Device()->BeginScene();
}
void RenderWin32DX9Imp::clear_Color_Stencil( NxU32 color, NxU32 stencil ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, color, 1.f, stencil );
}
void RenderWin32DX9Imp::clear_Color_Z( NxU32 color, float z ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, z, 0 );
}
void RenderWin32DX9Imp::clear_Stencil( NxU32 stencil ) {
    getD3D9Device()->Clear( 0, NULL, D3DCLEAR_STENCIL, 0, 1.f, stencil );
}