cDXSurface.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXSurface_H
#define _INC_cDXSurface_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cDXTexture.h"
#include "GrayLib/include/Geometry/cRectI.h"
 
#ifdef USE_DX9
 
namespace Gray3D
{
        class cDXTexture;
 
        class GRAY3D_LINK cDXSurface : public cDXBase
        {
                typedef cDXBase SUPER_t;
 
        public:
                cIUnkPtr<ID3DSurface> m_pDXSurf;        
                cDXTexture m_Tex;                                       
 
        public:
                cDXSurface(PIXELS_t nWidth, PIXELS_t nHeight, D3DFORMAT eFormat, DWORD dwUsage);
                virtual ~cDXSurface();
 
                void InitSurfaceSize(PIXELS_t cx, PIXELS_t cy);
 
                STDMETHOD_(cString, get_Name)() const
                {
                        return "DXTextureSurf";
                }
 
                virtual HRESULT InitDeviceObjects(cDXDevice* pDXDev);
                virtual HRESULT DeleteDeviceObjects();
 
                HRESULT LoadSurfaceFromFile(const FILECHAR_t* pszPath);
                HRESULT CreateSurface(PIXELS_t Width, PIXELS_t Height, D3DFORMAT eFormat, D3DPOOL ePool);
                HRESULT MakeBackBuffer(void);
                HRESULT PasteFromSurface(cDXSurface* Source, cRectI* pSourceRect, int x, int y);
 
        private:
                cDXSurface(const cDXSurface&);
        };
 
 
        template<D3DFORMAT _FMT> inline D3DCOLOR GetPixel(const D3DLOCKED_RECT& lr, int x, int y);
        template<> D3DCOLOR GetPixel<D3DFMT_DXT1>(const D3DLOCKED_RECT& lr, int x, int y);
 
        template<> inline D3DCOLOR GetPixel<D3DFMT_X8R8G8B8>(const D3DLOCKED_RECT& lr, int x, int y)
        {
                return *((D3DCOLOR*)((const BYTE*)lr.pBits + y * lr.Pitch) + x);
        }
        template<> inline D3DCOLOR GetPixel<D3DFMT_A8R8G8B8>(const D3DLOCKED_RECT& lr, int x, int y)
        {
                return *((D3DCOLOR*)((const BYTE*)lr.pBits + y * lr.Pitch) + x);
        }
 
        template< D3DFORMAT _FMT, bool _FORCE_CLONE = false >
        class cDXSurfaceLock // : public cLockerT<>
        {
 
        public:
                cIUnkPtr<ID3DTexture> m_pTexture;       
                cIUnkPtr<ID3DSurface> m_pSurface;       
                D3DSURFACE_DESC m_sSurfDesc;    
 
                                                                                                // Locking data.
                cRectI m_LockRect;                                      
                DWORD m_dwLockFlags;                            
                D3DLOCKED_RECT m_LockData;                      
 
        private:
                cRectI m_sTmpRect;              
                cIUnkPtr<ID3DSurface> m_pTmpSurface;    
 
        public:
                cDXSurfaceLock()
                {
                        m_LockData.pBits = nullptr;
                }
                cDXSurfaceLock(ID3DSurface* pSurf, const cRectI* pRect, DWORD dwFlags)
                        : m_pSurface(pSurf)
                {
                        ASSERT(m_pSurface != nullptr);
                        m_LockData.pBits = nullptr;
                        m_pSurface->GetDesc(&m_sSurfDesc);
                        Lock(pRect, dwFlags);
                }
 
                cDXSurfaceLock(ID3DTexture* pTex, const cRectI* pRect, DWORD dwFlags)
                        : m_pTexture(pTex)
                {
                        ASSERT(pTex != nullptr);
                        m_LockData.pBits = nullptr;
                        HRESULT hRes = pTex->GetSurfaceLevel(0, IUNK_GETPPTR(m_pSurface, IDirect3DSurface9));
                        m_pSurface->GetDesc(&m_sSurfDesc);
                        Lock(pRect, dwFlags);
                }
 
                ~cDXSurfaceLock()
                {
                        Unlock();
                }
 
                bool isLocked() const
                {
                        return m_LockData.pBits != nullptr;
                }
 
                HRESULT Attach(ID3DSurface* pSurf)
                {
                        ASSERT(!isLocked());
                        m_pSurface = pSurf;
                        m_pTexture.ReleasePtr();
                        if (pSurf == nullptr)
                        {
                                return S_FALSE;
                        }
                        return m_pSurface->GetDesc(&m_sSurfDesc);
                }
 
                HRESULT Attach(ID3DTexture* pTex, int iSurfaceLevel = 0)
                {
                        ASSERT(!isLocked());
                        m_pSurface.ReleasePtr();
                        m_pTexture = pTex;
                        if (pTex == nullptr)
                        {
                                return S_FALSE;
                        }
                        HRESULT hRes = pTex->GetSurfaceLevel(iSurfaceLevel, IUNK_GETPPTR(m_pSurface, IDirect3DSurface9));
                        if (FAILED(hRes))
                        {
                                return hRes;
                        }
                        return m_pSurface->GetDesc(&m_sSurfDesc);
                }
 
                void Detach()
                {
                        ASSERT(!isLocked());
                        m_pSurface.ReleasePtr();
                        m_pTexture.ReleasePtr();
                }
 
                HRESULT Lock(const cRectI* pRect, DWORD dwFlags)
                {
 
                        if (m_pSurface == nullptr)
                        {
                                DEBUG_CHECK(0);
                                return E_POINTER;
                        }
                        if (isLocked())
                        {
                                DEBUG_CHECK(0);
                                return E_FAIL;  // already Locked!
                        }
                        m_dwLockFlags = dwFlags;
                        if (pRect == nullptr) // all.
                        {
                                m_LockRect = cRectI(0, 0, m_sSurfDesc.Width, m_sSurfDesc.Height);
                        }
                        else
                        {
                                m_LockRect = *pRect;
                                ASSERT(m_LockRect.left >= 0);
                                ASSERT(m_LockRect.top >= 0);
                                ASSERT(m_LockRect.right <= (int)m_sSurfDesc.Width);
                                ASSERT(m_LockRect.bottom <= (int)m_sSurfDesc.Height);
                        }
 
                        HRESULT hRes;
                        if (!_FORCE_CLONE && _FMT == m_sSurfDesc.Format)
                        {
                                // use it directly.
                                if (!(m_sSurfDesc.Usage & D3DUSAGE_DYNAMIC))
                                        dwFlags &= ~D3DLOCK_DISCARD;
                                hRes = m_pSurface->LockRect(&m_LockData, (RECT*)pRect, dwFlags);
                                m_sTmpRect = cRectI(0, 0, m_sSurfDesc.Width, m_sSurfDesc.Height);
                        }
                        else
                        {
                                // Clone it to deal with format change.
                                m_sTmpRect = cRectI(0, 0, m_LockRect.Width(), m_LockRect.Height());
 
                                cIUnkPtr<ID3DDevice> pDev;
                                hRes = m_pSurface->GetDevice(IUNK_GETPPTR(pDev, ID3DDevice));
 
                                hRes = pDev->CreateOffscreenPlainSurface(m_sTmpRect.right, m_sTmpRect.bottom,
                                        _FMT, D3DPOOL_SCRATCH, IUNK_GETPPTR(m_pTmpSurface, IDirect3DSurface9), nullptr);
                                if (FAILED(hRes))
                                        return hRes;
                                if (!(dwFlags & D3DLOCK_DISCARD))
                                {
                                        hRes = ::D3DXLoadSurfaceFromSurface(m_pTmpSurface, nullptr, m_sTmpRect,
                                                m_pSurface, nullptr, m_LockRect, D3DX_FILTER_NONE, 0);
                                        if (FAILED(hRes))
                                        {
                                                return hRes;
                                        }
                                }
                                hRes = m_pTmpSurface->LockRect(&m_LockData, nullptr, dwFlags & ~D3DLOCK_DISCARD);
                        }
                        return hRes;
                }
 
                void Unlock()
                {
                        if (!isLocked())
                                return;
                        if (m_pTmpSurface != nullptr)
                        {
                                m_pTmpSurface->UnlockRect();
                                if (!(m_dwLockFlags & D3DLOCK_READONLY))
                                {
                                        HRESULT hRes = ::D3DXLoadSurfaceFromSurface(m_pSurface, nullptr, m_LockRect,
                                                m_pTmpSurface, nullptr, m_sTmpRect, D3DX_FILTER_DITHER, 0);
                                        UNREFERENCED_PARAMETER(hRes);
                                }
                                m_pTmpSurface.ReleasePtr();
                        }
                        else
                        {
                                m_pSurface->UnlockRect();
                        }
                        m_LockData.pBits = nullptr;
                }
 
                D3DCOLOR GetPixel(PIXELS_t x, PIXELS_t y) const
                {
                        ASSERT(isLocked());
                        return Gray3D::GetPixel<_FMT>(m_LockData, x, y);
                }
 
                template<bool _BWRAP> D3DCOLOR GetPixel(PIXELS_t x, PIXELS_t y)
                {
                        ASSERT(isLocked());
                        if (_BWRAP)
                        {
                                x %= m_sTmpRect.right;
                                if (x < 0)
                                        x += m_sTmpRect.right;
                                y %= m_sTmpRect.bottom;
                                if (y < 0)
                                        y += m_sTmpRect.bottom;
                        }
                        else // clamp
                        {
                                if (x < 0)
                                        x = 0;
                                else if (x >= m_sTmpRect.right)
                                        x = m_sTmpRect.right - 1;
                                if (y < 0)
                                        y = 0;
                                else if (y >= m_sTmpRect.bottom)
                                        y = m_sTmpRect.bottom - 1;
                        }
 
                        return GetPixel(x, y);
                }
 
                template<bool _BWRAP, bool _BILERP> D3DCOLOR GetPixelFC(float tx, float ty)
                {
                        // ASSERT( isLocked());
                        if (_BILERP)
                        {
                                tx -= 0.5f;
                                ty -= 0.5f;
 
                                int cx = cFloat32::ifloor(tx); tx -= cx;
                                int cy = cFloat32::ifloor(ty); ty -= cy;
 
                                cColorf c00 = GetPixel<_BWRAP>(cx, cy);
                                cColorf c01 = GetPixel<_BWRAP>(cx + 1, cy);
                                cColorf c10 = GetPixel<_BWRAP>(cx, cy + 1);
                                cColorf c11 = GetPixel<_BWRAP>(cx + 1, cy + 1);
 
                                float itx = 1 - tx;
                                float ity = 1 - ty;
 
                                c00.DoScale(itx * ity);
                                c01.DoScale(tx * ity);
                                c10.DoScale(itx * ty);
                                c11.DoScale(tx * ty);
 
                                return cColorf(c00 + c01 + c10 + c11);
                        }
                        else
                        {
                                return GetPixel<_BWRAP>(cFloat32::ifloor(tx), cFloat32::ifloor(ty));
                        }
                }
 
                template<bool _BWRAP, bool _BILERP> D3DCOLOR GetPixelTC(float x, float y)
                {
                        // ASSERT( isLocked());
                        float tx = x * m_sTmpRect.right;
                        float ty = y * m_sTmpRect.bottom;
                        return GetPixelFC< _BWRAP, _BILERP >(tx, ty);
                }
        };
}
#endif // USE_DX9
#endif