/****************************************************************************
Copyright (C) 2007 Radon Labs GmbH
Copyright (c) 2011-2013,WebJet Business Division,CYOU
 
http://www.genesis-3d.com.cn

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/

//------------------------------------------------------------------------------
//  d3d9rendertarget.cc
//  (C) 2007 Radon Labs GmbH
//------------------------------------------------------------------------------
#if WIN32



#include "stdneb.h"
#include "profilesystem/ProfileSystem.h"
#include "RenderTargetD3D9.h"
#include "RenderDeviceD3D9.h"
#include "D3D9Types.h"

namespace D3D9
{
__ImplementClass(D3D9::RenderTargetD3D9, 'D9RT', RenderBase::RenderTarget);

//------------------------------------------------------------------------------
/**
*/
RenderTargetD3D9::RenderTargetD3D9() :
    d3d9RenderTarget(0),
    d3d9DepthStencil(0),
    d3d9ResolveTexture(0),
    d3d9CPUResolveTexture(0),
	d3d9swapChain(0),
    d3d9MultiSampleType(D3DMULTISAMPLE_NONE),
    d3d9MultiSampleQuality(0),
    d3d9ColorBufferFormat(D3DFMT_UNKNOWN),
    needsResolve(false),
	d3dpoolType(D3DPOOL_MANAGED)
{
    // empty
}

//------------------------------------------------------------------------------
/**
*/
RenderTargetD3D9::~RenderTargetD3D9()
{
	Discard();
    n_assert(!this->isValid);
    n_assert(0 == this->d3d9RenderTarget);
    n_assert(0 == this->d3d9DepthStencil);
    n_assert(0 == this->d3d9ResolveTexture);
}
//------------------------------------------------------------------------------
/**
*/
void
RenderTargetD3D9::LoadBuffers(SizeT _width, SizeT _height)
{
	//todo : need not to set width && height .must be set before here
    n_assert(0 == this->d3d9RenderTarget);
    n_assert(0 == this->d3d9DepthStencil);
    n_assert(0 == this->d3d9ResolveTexture);
    HRESULT hr;
    RenderDeviceD3D9* device = RenderDeviceD3D9::Instance();
	memorySize = 0;

    // if we're the default render target, query display device
    // for setup parameters
    if (this->isDefaultRenderTarget)
    {
        // NOTE: the default render target will never be anti-aliased!
        // this assumes a render pipeline where the actual rendering goes
        // into an offscreen render target and is then resolved to the back buffer
		this->SetWidth(_width);
        this->SetHeight(_height);
        this->SetAntiAliasQuality(AntiAliasQuality::None);
		this->SetColorBufferFormat(PixelFormat::X8R8G8B8);
    }

	if (!this->isDefaultRenderTarget && screenSizeRatio > 0.f)
	{
		if (this->resolveTextureDimensionsValid)
		{
			if ((this->resolveTextureWidth != this->width) || (this->resolveTextureHeight != this->height))
			{
				//do nothing
			}
			else
			{
				this->SetResolveTextureWidth(SizeT(_width*screenSizeRatio));
				this->SetResolveTextureHeight(SizeT(_height*screenSizeRatio));
				this->resolveRect.right = int(_width*screenSizeRatio);
				this->resolveRect.bottom = int(_height*screenSizeRatio);
			}
		}

 		this->SetWidth(int(_width*screenSizeRatio));
 		this->SetHeight(int(_height*screenSizeRatio));
	}

    // setup our pixel format and multisample parameters (order important!)
    this->d3d9ColorBufferFormat = D3D9Types::AsD3D9PixelFormat(this->colorBufferFormat);
    this->SetupMultiSampleType();

    // check if a resolve texture must be allocated
    if (this->mipMapsEnabled ||
        (D3DMULTISAMPLE_NONE != this->d3d9MultiSampleType) ||
        (this->resolveTextureDimensionsValid &&
         ((this->resolveTextureWidth != this->width) ||
          (this->resolveTextureHeight != this->height))))
    {
        this->needsResolve = true;
    }
    else
    {
        this->needsResolve = false;
    }

    // create the render target either as a texture, or as
    // a surface, or don't create it if rendering goes
    // into backbuffer
    if (!this->needsResolve)
    {
        if (!this->isDefaultRenderTarget)
        {
            DWORD usage = D3DUSAGE_RENDERTARGET;
            D3DPOOL d3dpoolType = D3DPOOL_DEFAULT;

            // inplace resolve texture can be used (render target == resolve texture)
            hr = device->CreateTexture(this->width,                    // Width
                                        this->height,                   // Height
                                        1,                              // Levels
                                        usage,                          // Usage
                                        this->d3d9ColorBufferFormat,    // Format
                                        d3dpoolType,                           // Pool
                                        &(this->d3d9ResolveTexture),    // ppTexture
                                        NULL);                          // pSharedHandle
            n_assert(SUCCEEDED(hr));
            n_assert(0 != this->d3d9ResolveTexture);
            
            // get the actual render target surface of the texture
            hr = this->d3d9ResolveTexture->GetSurfaceLevel(0, &(this->d3d9RenderTarget));
            n_assert(SUCCEEDED(hr));
			memorySize += PixelFormat::GetMemorySize( width, height, 1, GetColorBufferFormat() );

            // create extra cpu texture for cpu look up (read-only)
            if (this->resolveCpuAccess)
            {
                usage = D3DUSAGE_DYNAMIC;        
                d3dpoolType = D3DPOOL_SYSTEMMEM;
                hr = device->CreateTexture(this->width,    // Width
                    this->height,                           // Height
                    1,                                      // Levels
                    usage,                                  // Usage
                    this->d3d9ColorBufferFormat,            // Format
                    d3dpoolType,                                   // Pool
                    &(this->d3d9CPUResolveTexture),         // ppTexture
                    NULL);                                  // pSharedHandle

                n_assert(SUCCEEDED(hr));
                n_assert(0 != this->d3d9CPUResolveTexture);
				memorySize += PixelFormat::GetMemorySize( width, height, 1, GetColorBufferFormat() );
            }
        }
        else
        {
            // NOTE: if we are the default render target and not antialiased, 
            // rendering will go directly to the backbuffer, so there's no
            // need to allocate a render target
            D3DPRESENT_PARAMETERS displayPresentParams = device->GetDefaultPresentParamters();
			displayPresentParams.BackBufferWidth = _width;
			displayPresentParams.BackBufferHeight = _height;
			displayPresentParams.BackBufferFormat = D3D9Types::AsD3D9PixelFormat(GetColorBufferFormat());
            device->CreateAdditionalSwapChain(&displayPresentParams,&d3d9swapChain);
        }
    }
    else
    {
        // need to create an extra resolve texture, create the
        // actual render target directly as surface
        hr = device->CreateRenderTarget(this->width,                   // Width
                                         this->height,                  // Height
                                         this->d3d9ColorBufferFormat,   // Format
                                         this->d3d9MultiSampleType,     // MultiSample
                                         this->d3d9MultiSampleQuality,  // MultisampleQuality
                                         FALSE,                         // Lockable
                                         &(this->d3d9RenderTarget),     // ppSurface
                                         NULL);                         // pSharedHandle
        n_assert(SUCCEEDED(hr));
        n_assert(0 != this->d3d9RenderTarget);

        // create the resolve texture
        SizeT resolveWidth = this->resolveTextureDimensionsValid ? this->resolveTextureWidth : this->width;
        SizeT resolveHeight = this->resolveTextureDimensionsValid ? this->resolveTextureHeight : this->height;

		memorySize += PixelFormat::GetMemorySize( width, height, 1, GetColorBufferFormat() );

        DWORD usage = D3DUSAGE_RENDERTARGET;
        d3dpoolType = D3DPOOL_DEFAULT;
        if (this->mipMapsEnabled)
        {
            usage |= D3DUSAGE_AUTOGENMIPMAP;
        }
        hr = device->CreateTexture(resolveWidth,                   // Width
                                    resolveHeight,                  // Height
                                    1,                              // Levels
                                    usage,                          // Usage
                                    this->d3d9ColorBufferFormat,    // Format
                                    d3dpoolType,                    // Pool
                                    &(this->d3d9ResolveTexture),    // ppTexture
                                    NULL);                          // pSharedHandle
        
        n_assert(SUCCEEDED(hr));
        n_assert(0 != this->d3d9ResolveTexture);
		memorySize += PixelFormat::GetMemorySize( resolveWidth, resolveHeight, 1, GetColorBufferFormat() );
        // create extra cpu texture for cpu look up (read-only)
        if (this->resolveCpuAccess)
        {
            usage = D3DUSAGE_DYNAMIC;        
            d3dpoolType = D3DPOOL_SYSTEMMEM;
            hr = device->CreateTexture(resolveWidth,                   // Width
                resolveHeight,                  // Height
                1,                              // Levels
                usage,                          // Usage
                this->d3d9ColorBufferFormat,    // Format
                d3dpoolType,                    // Pool
                &(this->d3d9CPUResolveTexture), // ppTexture
                NULL);                          // pSharedHandle

            n_assert(SUCCEEDED(hr));
            n_assert(0 != this->d3d9CPUResolveTexture);
			memorySize += PixelFormat::GetMemorySize( resolveWidth, resolveHeight, 1, GetColorBufferFormat() );
        }
    }

    // create the depth/stencil buffer if needed
    if (this->HasDepthStencilBuffer())
    {
        if (sharedDepthStencilBufferTarget.isvalid())
        {
			GPtr<RenderTargetD3D9> pSharedDepthStencilBufferTarget = this->sharedDepthStencilBufferTarget.downcast<RenderTargetD3D9>();
            n_assert(0 != pSharedDepthStencilBufferTarget->d3d9DepthStencil);
            n_assert(this->width == pSharedDepthStencilBufferTarget->width);
            n_assert(this->height == pSharedDepthStencilBufferTarget->height);
            n_assert(this->antiAliasQuality == pSharedDepthStencilBufferTarget->antiAliasQuality);
            this->d3d9DepthStencil = pSharedDepthStencilBufferTarget->d3d9DepthStencil;
            this->d3d9DepthStencil->AddRef();
        }
        else
        {
			D3DFORMAT dephFormat = D3DFMT_D24S8;
            hr = device->CreateDepthStencilSurface(this->width,                   // Width
                                                    this->height,                  // Height
                                                    dephFormat,                  // Format
                                                    this->d3d9MultiSampleType,     // MultiSample
                                                    this->d3d9MultiSampleQuality,  // MultisampleQuality
                                                    TRUE,                          // Discard
                                                    &(this->d3d9DepthStencil),     // ppSurface
                                                    NULL);                         // pSharedHandle
            n_assert(SUCCEEDED(hr));
            n_assert(0 != this->d3d9DepthStencil);
			memorySize += PixelFormat::GetMemorySize( width, height, 1, D3D9Types::AsGenesisPixelFormat(dephFormat));
        }
    }

	Super::setup();
}

void RenderTargetD3D9::AssignD3D9Textures(bool bIsLostDevice)
{
	// if a resolve texture exists, create a shared texture resource, so that
	// the texture is publicly visible
	if ((0 != this->d3d9ResolveTexture))
	{
		if (!bIsLostDevice)
		{
			this->resolveTexture = TextureD3D9::Create();
		}
		n_assert(this->resolveTexture.isvalid())
		this->resolveTexture->Setup();
		this->resolveTexture.downcast<TextureD3D9>()->SetupFromD3D9Texture(this->d3d9ResolveTexture);
		this->d3d9ResolveTexture->AddRef();
	}
	// if a cpu resolve texture exists, create a shared texture resource, so that
	// the texture is usable for a cpu lockup
	if ((0 != this->d3d9CPUResolveTexture)/* && this->resolveTextureResId.IsValid()*/)
	{
		if (!bIsLostDevice)
		{
			this->resolveCPUTexture = TextureD3D9::Create(); 
		}
		n_assert(this->resolveCPUTexture.isvalid())
		this->resolveCPUTexture->SetUsage(Texture::UsageDynamic);
		this->resolveCPUTexture->SetAccess(Texture::AccessRead);               
		this->resolveCPUTexture.downcast<TextureD3D9>()->SetupFromD3D9Texture(this->d3d9CPUResolveTexture);
		this->d3d9CPUResolveTexture->AddRef();
	}
}

//------------------------------------------------------------------------------
/**
*/
void
RenderTargetD3D9::Discard()
{
    if (0 != this->d3d9RenderTarget)
    {
        this->d3d9RenderTarget->Release();
        this->d3d9RenderTarget = 0;
    }
    if (0 != this->d3d9DepthStencil)
    {
        this->d3d9DepthStencil->Release();
        this->d3d9DepthStencil = 0;
    }
    if (0 != this->d3d9ResolveTexture)
    {
        this->d3d9ResolveTexture->Release();
        this->d3d9ResolveTexture = 0;
    }
    if (0 != this->d3d9CPUResolveTexture)
    {
        this->d3d9CPUResolveTexture->Release();
        this->d3d9CPUResolveTexture = 0;
    }
	if (0 != this->d3d9swapChain)
	{
		this->d3d9swapChain->Release();
		this->d3d9swapChain = 0;
	}
    Super::Discard();
}

//------------------------------------------------------------------------------
/**
    Select the antialias parameters that most closely resembly 
    the preferred settings in the DisplayDevice object.
*/

void
RenderTargetD3D9::SetupMultiSampleType()
{
    n_assert(D3DFMT_UNKNOWN != this->d3d9ColorBufferFormat);
    RenderDeviceD3D9* renderDevice = RenderDeviceD3D9::Instance();

    #if NEBULA3_DIRECT3D_DEBUG
        this->d3d9MultiSampleType = D3DMULTISAMPLE_NONE;
        this->d3d9MultiSampleQuality = 0;
    #else
        // convert Nebula3 antialias quality into D3D type
        this->d3d9MultiSampleType = D3D9Types::AsD3D9MultiSampleType(this->antiAliasQuality);
        
        // check if the multisample type is compatible with the selected display mode
        DWORD availableQualityLevels = 0;
        HRESULT renderTargetResult = renderDevice->CheckDeviceMultiSampleType(0, 
                                     D3DDEVTYPE_HAL,
                                     this->d3d9ColorBufferFormat,
                                     FALSE,
                                     this->d3d9MultiSampleType,
                                     &availableQualityLevels);
        HRESULT depthBufferResult = renderDevice->CheckDeviceMultiSampleType(0,
                                    D3DDEVTYPE_HAL,
                                    D3DFMT_D24S8,
                                    FALSE,
                                    this->d3d9MultiSampleType,
                                    NULL);
        if ((D3DERR_NOTAVAILABLE == renderTargetResult) || (D3DERR_NOTAVAILABLE == depthBufferResult))
        {
            // reset to no multisampling
            this->d3d9MultiSampleType = D3DMULTISAMPLE_NONE;
            this->d3d9MultiSampleQuality = 0;
        }
        else
        {
            n_assert(SUCCEEDED(renderTargetResult) && SUCCEEDED(depthBufferResult));
        }

        // clamp multisample quality to the available quality levels
        if (availableQualityLevels > 0)
        {
            this->d3d9MultiSampleQuality = availableQualityLevels - 1;
        }
        else
        {
            this->d3d9MultiSampleQuality = 0;
        }
    #endif
}  
//------------------------------------------------------------------------------
/**
*/

void
RenderTargetD3D9::EndPass()
{
    HRESULT hr;
    RenderDeviceD3D9* renderDevice = RenderDeviceD3D9::Instance();

    // if necessary need to resolve the render target, either
    // into our resolve texture, or into the back buffer
    if (this->needsResolve)
    {        
        RECT destRect;
        CONST RECT* pDestRect = NULL;
        if (this->resolveRectValid)
        {
            destRect.left   = this->resolveRect.left;
            destRect.right  = this->resolveRect.right;
            destRect.top    = this->resolveRect.top;
            destRect.bottom = this->resolveRect.bottom;
            pDestRect = &destRect;
        }
        IDirect3DSurface9* resolveSurface = 0;
        hr = this->d3d9ResolveTexture->GetSurfaceLevel(0, &resolveSurface);
        hr = renderDevice->StretchRect(this->d3d9RenderTarget, NULL, resolveSurface, pDestRect, D3DTEXF_NONE);
        n_assert(SUCCEEDED(hr));
        
        // need cpu access, copy from gpu mem to sys mem
        if (this->resolveCpuAccess)
        {
            HRESULT hr;   
            D3DLOCKED_RECT dstLockRect;
            D3DLOCKED_RECT srcLockRect;
            IDirect3DSurface9* dstSurface = 0;
            hr = this->d3d9CPUResolveTexture->GetSurfaceLevel(0, &dstSurface);
            n_assert(SUCCEEDED(hr));
            hr = dstSurface->LockRect(&dstLockRect, 0, 0);
            n_assert(SUCCEEDED(hr));
            hr = resolveSurface->LockRect(&srcLockRect, 0, D3DLOCK_READONLY);
            n_assert(SUCCEEDED(hr));
            Memory::Copy(srcLockRect.pBits, dstLockRect.pBits, dstLockRect.Pitch * this->resolveCPUTexture->GetWidth());
            dstSurface->Release();
        }
        resolveSurface->Release();
    }
    else if (this->resolveCpuAccess)
    {
        HRESULT hr;
        // copy data
        IDirect3DSurface9* resolveSurface = 0;
        hr = this->d3d9CPUResolveTexture->GetSurfaceLevel(0, &resolveSurface);
        n_assert(SUCCEEDED(hr));
        hr = renderDevice->GetRenderTargetData(this->d3d9RenderTarget, resolveSurface);
        n_assert(SUCCEEDED(hr));
        resolveSurface->Release();
    }
    // unset multiple rendertargets
    if (this->mrtIndex > 0)
    {
        renderDevice->SetRenderTarget(this->mrtIndex, 0);
    }    
}

//------------------------------------------------------------------------------
/**
*/
void
RenderTargetD3D9::GenerateMipLevels()
{
    n_assert(0 != this->d3d9ResolveTexture);
    n_assert(this->mipMapsEnabled);
    this->d3d9ResolveTexture->GenerateMipSubLevels();
}

//------------------------------------------------------------------------------
/**
*/
void
RenderTargetD3D9::OnDeviceLost()
{
	if (this->sharedDepthStencilBufferTarget.isvalid())
	{
		this->sharedDepthStencilBufferTarget.downcast<RenderTargetD3D9>()->OnDeviceLost();
	}
	if (this->resolveTexture.isvalid())
	{
		this->resolveTexture.downcast<TextureD3D9>()->OnDeviceLost();
	}
	if (this->resolveCPUTexture.isvalid())
	{
		resolveCPUTexture.downcast<TextureD3D9>()->OnDeviceLost();
	}
	if (this->resolveDepthTexture.isvalid())
	{
		resolveDepthTexture.downcast<TextureD3D9>()->OnDeviceLost();
	}
	if (0 != this->d3d9RenderTarget)
	{
		this->d3d9RenderTarget->Release();
		this->d3d9RenderTarget = 0;
	}
	if (0 != this->d3d9DepthStencil)
	{
		this->d3d9DepthStencil->Release();
		this->d3d9DepthStencil = 0;
	}
	if (0 != this->d3d9ResolveTexture)
	{
		this->d3d9ResolveTexture->Release();
		this->d3d9ResolveTexture = 0;
	}
	if (0 != this->d3d9CPUResolveTexture)
	{
		this->d3d9CPUResolveTexture->Release();
		this->d3d9CPUResolveTexture = 0;
	}
	if (0 != this->d3d9swapChain)
	{
		this->d3d9swapChain->Release();
		this->d3d9swapChain = 0;
	}
	this->isValid = false;
}
//------------------------------------------------------------------------------
/**
*/
void
RenderTargetD3D9::OnDeviceReset()
{
	LoadBuffers(GetWidth(),GetHeight());
	AssignD3D9Textures(true);
}

//------------------------------------------------------------------------------
/**
*/
void
	RenderTargetD3D9::CopyFrom(const Math::float4& srcRect, const GPtr<RenderTarget>srcRT, const Math::float4& desRect)
{
	GPtr<RenderTargetD3D9> srt = srcRT.downcast<RenderTargetD3D9>();
	n_assert(srt);
	HRESULT hr;
	RenderDeviceD3D9* renderDevice = RenderDeviceD3D9::Instance();

	RECT srcRECT;
	srcRECT.left = LONG(srcRect.x());
	srcRECT.top = LONG(srcRect.y());
	srcRECT.right = LONG(srcRect.z());
	srcRECT.bottom = LONG(srcRect.w());

	RECT desRECT;
	desRECT.left = LONG(desRect.x());
	desRECT.top = LONG(desRect.y());
	desRECT.right = LONG(desRect.z());
	desRECT.bottom = LONG(desRect.w());
	hr = renderDevice->StretchRect(srt->GetD3DRT(),&srcRECT,d3d9RenderTarget,&desRECT,D3DTEXF_NONE);
	n_assert(SUCCEEDED(hr));
}


} // namespace D3D9

#endif