mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-09-22 20:31:50 +02:00
3bdf7d3711
implemented donko's xfb in D3D: the bad things: *is solower in some cases, slower as opengl *it do not work in dual core mode, it seems direct3d has serious synchronization problems, to the other devs please if you can take a look and help me :) *real xfb still not working i have to give it more time to make it work. the good: *games that uses multiples xfbs will work now using the virtual XFB. *implemented a more hardware like approach to scaling, now to calculate the pixel scaling i use the xfb size not the efb so the screen pixels relation is more correct now. *simplified a little donko's virtual xfb to make it less memory consuming as xfb textures are the exact size of the scaled xfb and not full target width. * when it works even real xfb will let us use super sampling. I repeat this commit is totally unstable and in dual core mode it will for sure hang the emulator or at best give totally incorrect results. Other devs please help as thread sync is not one of my strong points :) i'll keep waiting for the comments an the -1 :) git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5195 8ced0084-cf51-0410-be5f-012b33b47a6e
519 lines
No EOL
16 KiB
C++
519 lines
No EOL
16 KiB
C++
// Copyright (C) 2003 Dolphin Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
#include "D3DBase.h"
|
|
#include "Render.h"
|
|
#include "FramebufferManager.h"
|
|
#include "VideoConfig.h"
|
|
#include "PixelShaderCache.h"
|
|
#include "VertexShaderCache.h"
|
|
#include "TextureConverter.h"
|
|
|
|
#undef CHECK
|
|
#define CHECK(hr,Message) if (FAILED(hr)) { PanicAlert(__FUNCTION__ " FAIL: %s" ,Message); }
|
|
|
|
FramebufferManager FBManager;
|
|
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBColorRTSurface()
|
|
{
|
|
return s_efb_color_surface;
|
|
}
|
|
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBDepthRTSurface()
|
|
{
|
|
return s_efb_depth_surface;
|
|
}
|
|
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBColorOffScreenRTSurface()
|
|
{
|
|
return s_efb_color_OffScreenReadBuffer;
|
|
}
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBDepthOffScreenRTSurface()
|
|
{
|
|
return s_efb_depth_OffScreenReadBuffer;
|
|
}
|
|
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBColorReadSurface()
|
|
{
|
|
return s_efb_color_ReadBuffer;
|
|
}
|
|
|
|
LPDIRECT3DSURFACE9 FramebufferManager::GetEFBDepthReadSurface()
|
|
{
|
|
return s_efb_depth_ReadBuffer;
|
|
}
|
|
|
|
D3DFORMAT FramebufferManager::GetEFBDepthRTSurfaceFormat(){return s_efb_depth_surface_Format;}
|
|
D3DFORMAT FramebufferManager::GetEFBDepthReadSurfaceFormat(){return s_efb_depth_ReadBuffer_Format;}
|
|
D3DFORMAT FramebufferManager::GetEFBColorRTSurfaceFormat(){return s_efb_color_surface_Format;}
|
|
|
|
|
|
LPDIRECT3DTEXTURE9 FramebufferManager::GetEFBColorTexture(const EFBRectangle& sourceRc)
|
|
{
|
|
return s_efb_color_texture;
|
|
}
|
|
|
|
|
|
LPDIRECT3DTEXTURE9 FramebufferManager::GetEFBDepthTexture(const EFBRectangle &sourceRc)
|
|
{
|
|
return s_efb_depth_texture;
|
|
}
|
|
|
|
|
|
|
|
void FramebufferManager::Create()
|
|
{
|
|
// Simplest possible setup to start with.
|
|
int target_width = Renderer::GetFullTargetWidth();
|
|
int target_height = Renderer::GetFullTargetHeight();
|
|
|
|
s_efb_color_surface_Format = D3DFMT_A8R8G8B8;
|
|
//get the framebuffer texture
|
|
HRESULT hr = D3D::dev->CreateTexture(target_width, target_height, 1, D3DUSAGE_RENDERTARGET, s_efb_color_surface_Format,
|
|
D3DPOOL_DEFAULT, &s_efb_color_texture, NULL);
|
|
if(s_efb_color_texture)
|
|
{
|
|
hr = s_efb_color_texture->GetSurfaceLevel(0,&s_efb_color_surface);
|
|
}
|
|
CHECK(hr,"Create Color Texture");
|
|
hr = D3D::dev->CreateTexture(1, 1, 1, D3DUSAGE_RENDERTARGET, s_efb_color_surface_Format,
|
|
D3DPOOL_DEFAULT, &s_efb_colorRead_texture, NULL);
|
|
CHECK(hr,"Create Color Read Texture");
|
|
if(s_efb_colorRead_texture)
|
|
{
|
|
s_efb_colorRead_texture->GetSurfaceLevel(0,&s_efb_color_ReadBuffer);
|
|
}
|
|
//create an offscreen surface that we can lock to retrieve the data
|
|
hr = D3D::dev->CreateOffscreenPlainSurface(1, 1, s_efb_color_surface_Format, D3DPOOL_SYSTEMMEM, &s_efb_color_OffScreenReadBuffer, NULL );
|
|
CHECK(hr,"Create Color offScreen Surface");
|
|
|
|
//Select Zbuffer format supported by hadware.
|
|
if (g_ActiveConfig.bEFBAccessEnable)
|
|
{
|
|
D3DFORMAT *DepthTexFormats = new D3DFORMAT[5];
|
|
DepthTexFormats[0] = FOURCC_INTZ;
|
|
DepthTexFormats[1] = FOURCC_DF24;
|
|
DepthTexFormats[2] = FOURCC_RAWZ;
|
|
DepthTexFormats[3] = FOURCC_DF16;
|
|
DepthTexFormats[4] = D3DFMT_D24X8;
|
|
|
|
for(int i = 0;i<5;i++)
|
|
{
|
|
s_efb_depth_surface_Format = DepthTexFormats[i];
|
|
//get the framebuffer Depth texture
|
|
hr = D3D::dev->CreateTexture(target_width, target_height, 1, D3DUSAGE_DEPTHSTENCIL, s_efb_depth_surface_Format,
|
|
D3DPOOL_DEFAULT, &s_efb_depth_texture, NULL);
|
|
if (!FAILED(hr)) break;
|
|
}
|
|
CHECK(hr,"Depth Color Texture");
|
|
//get the Surface
|
|
if(s_efb_depth_texture)
|
|
{
|
|
s_efb_depth_texture->GetSurfaceLevel(0,&s_efb_depth_surface);
|
|
}
|
|
//create a 4x4 pixel texture to work as a buffer for peeking
|
|
if(s_efb_depth_surface_Format == FOURCC_RAWZ || s_efb_depth_surface_Format == D3DFMT_D24X8)
|
|
{
|
|
DepthTexFormats[0] = D3DFMT_A8R8G8B8;
|
|
}
|
|
else
|
|
{
|
|
DepthTexFormats[0] = D3DFMT_R32F;
|
|
}
|
|
DepthTexFormats[1] = D3DFMT_A8R8G8B8;
|
|
|
|
for(int i = 0;i<2;i++)
|
|
{
|
|
s_efb_depth_ReadBuffer_Format = DepthTexFormats[i];
|
|
//get the framebuffer Depth texture
|
|
hr = D3D::dev->CreateTexture(4, 4, 1, D3DUSAGE_RENDERTARGET, s_efb_depth_ReadBuffer_Format,
|
|
D3DPOOL_DEFAULT, &s_efb_depthRead_texture, NULL);
|
|
if (!FAILED(hr)) break;
|
|
}
|
|
|
|
CHECK(hr,"Create Depth Read texture");
|
|
if(s_efb_depthRead_texture)
|
|
{
|
|
s_efb_depthRead_texture->GetSurfaceLevel(0,&s_efb_depth_ReadBuffer);
|
|
}
|
|
//create an offscreen surface that we can lock to retrieve the data
|
|
hr = D3D::dev->CreateOffscreenPlainSurface(4, 4, s_efb_depth_ReadBuffer_Format, D3DPOOL_SYSTEMMEM, &s_efb_depth_OffScreenReadBuffer, NULL );
|
|
CHECK(hr,"Create Depth offScreen Surface");
|
|
delete [] DepthTexFormats;
|
|
}
|
|
else
|
|
{
|
|
s_efb_depth_surface_Format = D3DFMT_D24X8;
|
|
hr = D3D::dev->CreateDepthStencilSurface(target_width, target_height, s_efb_depth_surface_Format,
|
|
D3DMULTISAMPLE_NONE, 0, FALSE, &s_efb_depth_surface, NULL);
|
|
CHECK(hr,"CreateDepthStencilSurface");
|
|
}
|
|
}
|
|
|
|
void FramebufferManager::Destroy()
|
|
{
|
|
if (s_efb_depth_surface)
|
|
s_efb_depth_surface->Release();
|
|
s_efb_depth_surface=NULL;
|
|
|
|
if (s_efb_color_surface)
|
|
s_efb_color_surface->Release();
|
|
s_efb_color_surface=NULL;
|
|
|
|
if (s_efb_color_ReadBuffer)
|
|
s_efb_color_ReadBuffer->Release();
|
|
s_efb_color_ReadBuffer=NULL;
|
|
|
|
if (s_efb_depth_ReadBuffer)
|
|
s_efb_depth_ReadBuffer->Release();
|
|
s_efb_depth_ReadBuffer=NULL;
|
|
|
|
if (s_efb_color_OffScreenReadBuffer)
|
|
s_efb_color_OffScreenReadBuffer->Release();
|
|
s_efb_color_OffScreenReadBuffer=NULL;
|
|
|
|
if (s_efb_depth_OffScreenReadBuffer)
|
|
s_efb_depth_OffScreenReadBuffer->Release();
|
|
s_efb_depth_OffScreenReadBuffer=NULL;
|
|
|
|
if (s_efb_color_texture)
|
|
s_efb_color_texture->Release();
|
|
s_efb_color_texture=NULL;
|
|
|
|
if (s_efb_colorRead_texture)
|
|
s_efb_colorRead_texture->Release();
|
|
s_efb_colorRead_texture=NULL;
|
|
|
|
if (s_efb_depth_texture)
|
|
s_efb_depth_texture->Release();
|
|
s_efb_depth_texture=NULL;
|
|
|
|
if (s_efb_depthRead_texture)
|
|
s_efb_depthRead_texture->Release();
|
|
s_efb_depthRead_texture=NULL;
|
|
|
|
for (VirtualXFBListType::iterator it = m_virtualXFBList.begin(); it != m_virtualXFBList.end(); ++it)
|
|
{
|
|
it->xfbSource.texture->Release();
|
|
}
|
|
m_virtualXFBList.clear();
|
|
if(m_realXFBSource.texture)
|
|
m_realXFBSource.texture->Release();
|
|
m_realXFBSource.texture = NULL;
|
|
|
|
}
|
|
|
|
void FramebufferManager::CopyToXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc)
|
|
{
|
|
if (g_ActiveConfig.bUseRealXFB)
|
|
copyToRealXFB(xfbAddr, fbWidth, fbHeight, sourceRc);
|
|
else
|
|
copyToVirtualXFB(xfbAddr, fbWidth, fbHeight, sourceRc);
|
|
}
|
|
|
|
const XFBSource** FramebufferManager::GetXFBSource(u32 xfbAddr, u32 fbWidth, u32 fbHeight, u32 &xfbCount)
|
|
{
|
|
if (g_ActiveConfig.bUseRealXFB)
|
|
return getRealXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
|
|
else
|
|
return getVirtualXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
|
|
}
|
|
|
|
FramebufferManager::VirtualXFBListType::iterator FramebufferManager::findVirtualXFB(u32 xfbAddr, u32 width, u32 height)
|
|
{
|
|
u32 srcLower = xfbAddr;
|
|
u32 srcUpper = xfbAddr + 2 * width * height;
|
|
|
|
VirtualXFBListType::iterator it;
|
|
for (it = m_virtualXFBList.begin(); it != m_virtualXFBList.end(); ++it)
|
|
{
|
|
u32 dstLower = it->xfbAddr;
|
|
u32 dstUpper = it->xfbAddr + 2 * it->xfbWidth * it->xfbHeight;
|
|
|
|
if (dstLower >= srcLower && dstUpper <= srcUpper)
|
|
return it;
|
|
}
|
|
|
|
// That address is not in the Virtual XFB list.
|
|
return m_virtualXFBList.end();
|
|
}
|
|
|
|
void FramebufferManager::replaceVirtualXFB()
|
|
{
|
|
VirtualXFBListType::iterator it = m_virtualXFBList.begin();
|
|
|
|
s32 srcLower = it->xfbAddr;
|
|
s32 srcUpper = it->xfbAddr + 2 * it->xfbWidth * it->xfbHeight;
|
|
s32 lineSize = 2 * it->xfbWidth;
|
|
|
|
it++;
|
|
|
|
while (it != m_virtualXFBList.end())
|
|
{
|
|
s32 dstLower = it->xfbAddr;
|
|
s32 dstUpper = it->xfbAddr + 2 * it->xfbWidth * it->xfbHeight;
|
|
|
|
if (dstLower >= srcLower && dstUpper <= srcUpper)
|
|
{
|
|
// invalidate the data
|
|
it->xfbAddr = 0;
|
|
it->xfbHeight = 0;
|
|
it->xfbWidth = 0;
|
|
}
|
|
else if (addrRangesOverlap(srcLower, srcUpper, dstLower, dstUpper))
|
|
{
|
|
s32 upperOverlap = (srcUpper - dstLower) / lineSize;
|
|
s32 lowerOverlap = (dstUpper - srcLower) / lineSize;
|
|
|
|
if (upperOverlap > 0 && lowerOverlap < 0)
|
|
{
|
|
it->xfbAddr += lineSize * upperOverlap;
|
|
it->xfbHeight -= upperOverlap;
|
|
}
|
|
else if (lowerOverlap > 0)
|
|
{
|
|
it->xfbHeight -= lowerOverlap;
|
|
}
|
|
}
|
|
|
|
it++;
|
|
}
|
|
}
|
|
|
|
void FramebufferManager::copyToRealXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc)
|
|
{
|
|
u8* xfb_in_ram = Memory_GetPtr(xfbAddr);
|
|
if (!xfb_in_ram)
|
|
{
|
|
WARN_LOG(VIDEO, "Tried to copy to invalid XFB address");
|
|
return;
|
|
}
|
|
|
|
TargetRectangle targetRc = Renderer::ConvertEFBRectangle(sourceRc);
|
|
TextureConverter::EncodeToRamYUYV(GetEFBColorTexture(sourceRc), targetRc, xfb_in_ram, fbWidth, fbHeight);
|
|
}
|
|
|
|
void FramebufferManager::copyToVirtualXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc)
|
|
{
|
|
LPDIRECT3DTEXTURE9 xfbTexture;
|
|
|
|
VirtualXFBListType::iterator it = findVirtualXFB(xfbAddr, fbWidth, fbHeight);
|
|
|
|
if (it == m_virtualXFBList.end() && (int)m_virtualXFBList.size() >= MAX_VIRTUAL_XFB)
|
|
{
|
|
// replace the last virtual XFB
|
|
it--;
|
|
}
|
|
|
|
float MultiSampleCompensation = 1.0f;
|
|
if(g_ActiveConfig.iMultisampleMode > 0 && g_ActiveConfig.iMultisampleMode < 4)
|
|
{
|
|
switch (g_ActiveConfig.iMultisampleMode)
|
|
{
|
|
case 1:
|
|
MultiSampleCompensation = 2.0f/3.0f;
|
|
break;
|
|
case 2:
|
|
MultiSampleCompensation = 0.5f;
|
|
break;
|
|
case 3:
|
|
MultiSampleCompensation = 1.0f/3.0f;
|
|
break;
|
|
default:
|
|
break;
|
|
};
|
|
}
|
|
|
|
float scaleX = Renderer::GetTargetScaleX() * MultiSampleCompensation ;
|
|
float scaleY = Renderer::GetTargetScaleY() * MultiSampleCompensation;
|
|
TargetRectangle targetSource,efbSource;
|
|
efbSource = Renderer::ConvertEFBRectangle(sourceRc);
|
|
targetSource.top = (sourceRc.top *scaleY);
|
|
targetSource.bottom = (sourceRc.bottom *scaleY);
|
|
targetSource.left = (sourceRc.left *scaleX);
|
|
targetSource.right = (sourceRc.right * scaleX);
|
|
int target_width = targetSource.right - targetSource.left;
|
|
int target_height = targetSource.bottom - targetSource.top;
|
|
if (it != m_virtualXFBList.end())
|
|
{
|
|
// Overwrite an existing Virtual XFB.
|
|
|
|
it->xfbAddr = xfbAddr;
|
|
it->xfbWidth = fbWidth;
|
|
it->xfbHeight = fbHeight;
|
|
|
|
it->xfbSource.srcAddr = xfbAddr;
|
|
it->xfbSource.srcWidth = fbWidth;
|
|
it->xfbSource.srcHeight = fbHeight;
|
|
|
|
if(it->xfbSource.texWidth != target_width || it->xfbSource.texHeight != target_height || !it->xfbSource.texture)
|
|
{
|
|
if(it->xfbSource.texture)
|
|
it->xfbSource.texture->Release();
|
|
D3D::dev->CreateTexture(target_width, target_height, 1, D3DUSAGE_RENDERTARGET, s_efb_color_surface_Format,
|
|
D3DPOOL_DEFAULT, &it->xfbSource.texture, NULL);
|
|
}
|
|
|
|
xfbTexture = it->xfbSource.texture;
|
|
|
|
it->xfbSource.texWidth = target_width;
|
|
it->xfbSource.texHeight = target_height;
|
|
|
|
// Move this Virtual XFB to the front of the list.
|
|
m_virtualXFBList.splice(m_virtualXFBList.begin(), m_virtualXFBList, it);
|
|
|
|
// Keep stale XFB data from being used
|
|
replaceVirtualXFB();
|
|
}
|
|
else
|
|
{
|
|
// Create a new Virtual XFB and place it at the front of the list.
|
|
|
|
D3D::dev->CreateTexture(target_width, target_height, 1, D3DUSAGE_RENDERTARGET, s_efb_color_surface_Format,
|
|
D3DPOOL_DEFAULT, &xfbTexture, NULL);
|
|
VirtualXFB newVirt;
|
|
|
|
newVirt.xfbAddr = xfbAddr;
|
|
newVirt.xfbWidth = fbWidth;
|
|
newVirt.xfbHeight = fbHeight;
|
|
|
|
newVirt.xfbSource.texture = xfbTexture;
|
|
newVirt.xfbSource.texWidth = target_width;
|
|
newVirt.xfbSource.texHeight = target_height;
|
|
|
|
// Add the new Virtual XFB to the list
|
|
|
|
if ((int)m_virtualXFBList.size() >= MAX_VIRTUAL_XFB)
|
|
{
|
|
// List overflowed; delete the oldest.
|
|
m_virtualXFBList.back().xfbSource.texture->Release();
|
|
m_virtualXFBList.pop_back();
|
|
}
|
|
|
|
m_virtualXFBList.push_front(newVirt);
|
|
}
|
|
|
|
// Copy EFB to XFB texture
|
|
|
|
if(!xfbTexture)
|
|
return;
|
|
// Make sure to resolve anything we need to read from.
|
|
LPDIRECT3DTEXTURE9 read_texture = GetEFBColorTexture(sourceRc);
|
|
|
|
// We have to run a pixel shader, for color conversion.
|
|
Renderer::ResetAPIState(); // reset any game specific settings
|
|
LPDIRECT3DSURFACE9 Rendersurf = NULL;
|
|
|
|
xfbTexture->GetSurfaceLevel(0,&Rendersurf);
|
|
D3D::dev->SetDepthStencilSurface(NULL);
|
|
D3D::dev->SetRenderTarget(0, Rendersurf);
|
|
|
|
D3DVIEWPORT9 vp;
|
|
|
|
// Stretch picture with increased internal resolution
|
|
vp.X = 0;
|
|
vp.Y = 0;
|
|
vp.Width = target_width;
|
|
vp.Height = target_height;
|
|
vp.MinZ = 0.0f;
|
|
vp.MaxZ = 1.0f;
|
|
D3D::dev->SetViewport(&vp);
|
|
RECT sourcerect;
|
|
sourcerect.bottom = efbSource.bottom;
|
|
sourcerect.left = efbSource.left;
|
|
sourcerect.right = efbSource.right;
|
|
sourcerect.top = efbSource.top;
|
|
|
|
D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
|
|
D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
|
|
|
|
|
|
int SSAAMode = ( g_ActiveConfig.iMultisampleMode > 3 )? 0 : g_ActiveConfig.iMultisampleMode;
|
|
D3D::drawShadedTexQuad(
|
|
read_texture,
|
|
&sourcerect,
|
|
Renderer::GetFullTargetWidth() ,
|
|
Renderer::GetFullTargetHeight(),
|
|
PixelShaderCache::GetColorCopyProgram(SSAAMode),
|
|
(SSAAMode != 0)? VertexShaderCache::GetFSAAVertexShader() : VertexShaderCache::GetSimpleVertexShader());
|
|
|
|
|
|
D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
|
|
D3D::RefreshSamplerState(0, D3DSAMP_MAGFILTER);
|
|
D3D::SetTexture(0,NULL);
|
|
D3D::dev->SetRenderTarget(0, GetEFBColorRTSurface());
|
|
D3D::dev->SetDepthStencilSurface(GetEFBDepthRTSurface());
|
|
Renderer::RestoreAPIState();
|
|
Rendersurf->Release();
|
|
|
|
}
|
|
|
|
const XFBSource** FramebufferManager::getRealXFBSource(u32 xfbAddr, u32 fbWidth, u32 fbHeight, u32 &xfbCount)
|
|
{
|
|
xfbCount = 1;
|
|
|
|
m_realXFBSource.texWidth = fbWidth;
|
|
m_realXFBSource.texHeight = fbHeight;
|
|
|
|
m_realXFBSource.srcAddr = xfbAddr;
|
|
m_realXFBSource.srcWidth = fbWidth;
|
|
m_realXFBSource.srcHeight = fbHeight;
|
|
|
|
if (!m_realXFBSource.texture)
|
|
{
|
|
D3D::dev->CreateTexture(fbWidth, fbHeight, 1, D3DUSAGE_RENDERTARGET, s_efb_color_surface_Format,
|
|
D3DPOOL_DEFAULT, &m_realXFBSource.texture, NULL);
|
|
}
|
|
|
|
// Decode YUYV data from GameCube RAM
|
|
TextureConverter::DecodeToTexture(xfbAddr, fbWidth, fbHeight, m_realXFBSource.texture);
|
|
|
|
m_overlappingXFBArray[0] = &m_realXFBSource;
|
|
|
|
return &m_overlappingXFBArray[0];
|
|
}
|
|
|
|
const XFBSource** FramebufferManager::getVirtualXFBSource(u32 xfbAddr, u32 fbWidth, u32 fbHeight, u32 &xfbCount)
|
|
{
|
|
xfbCount = 0;
|
|
|
|
if (m_virtualXFBList.size() == 0)
|
|
{
|
|
// No Virtual XFBs available.
|
|
return NULL;
|
|
}
|
|
|
|
u32 srcLower = xfbAddr;
|
|
u32 srcUpper = xfbAddr + 2 * fbWidth * fbHeight;
|
|
|
|
VirtualXFBListType::iterator it;
|
|
for (it = m_virtualXFBList.end(); it != m_virtualXFBList.begin();)
|
|
{
|
|
--it;
|
|
|
|
u32 dstLower = it->xfbAddr;
|
|
u32 dstUpper = it->xfbAddr + 2 * it->xfbWidth * it->xfbHeight;
|
|
|
|
if (addrRangesOverlap(srcLower, srcUpper, dstLower, dstUpper))
|
|
{
|
|
m_overlappingXFBArray[xfbCount] = &(it->xfbSource);
|
|
xfbCount++;
|
|
}
|
|
}
|
|
|
|
return &m_overlappingXFBArray[0];
|
|
} |