2013-06-01 13:10:30 +00:00
|
|
|
#include <assert.h>
|
2015-01-28 13:58:55 +00:00
|
|
|
#include <math.h>
|
2016-02-03 15:17:53 +00:00
|
|
|
#include <algorithm>
|
|
|
|
#include <vector>
|
2013-04-05 06:13:26 +00:00
|
|
|
#include "OpenGL.h"
|
|
|
|
#include "FrameBuffer.h"
|
2013-06-01 13:10:30 +00:00
|
|
|
#include "DepthBuffer.h"
|
2013-11-27 10:08:48 +00:00
|
|
|
#include "N64.h"
|
2013-04-05 06:13:26 +00:00
|
|
|
#include "RSP.h"
|
|
|
|
#include "RDP.h"
|
2013-06-29 11:52:57 +00:00
|
|
|
#include "gDP.h"
|
2013-08-10 11:12:17 +00:00
|
|
|
#include "VI.h"
|
2013-04-05 06:13:26 +00:00
|
|
|
#include "Textures.h"
|
|
|
|
#include "Combiner.h"
|
2014-09-02 13:05:53 +00:00
|
|
|
#include "GLSLCombiner.h"
|
2013-04-05 06:13:26 +00:00
|
|
|
#include "Types.h"
|
2014-04-05 02:57:00 +00:00
|
|
|
#include "Config.h"
|
2013-06-01 13:10:30 +00:00
|
|
|
#include "Debug.h"
|
2015-01-30 13:59:52 +00:00
|
|
|
#include "PostProcessor.h"
|
2015-11-23 12:36:03 +00:00
|
|
|
#include "FrameBufferInfo.h"
|
2016-06-20 09:16:15 +00:00
|
|
|
#include "FBOTextureFormats.h"
|
2016-05-24 05:18:56 +00:00
|
|
|
#include "Log.h"
|
|
|
|
|
2016-05-28 15:37:20 +00:00
|
|
|
#include "BufferCopy/ColorBufferToRDRAM.h"
|
|
|
|
#include "BufferCopy/DepthBufferToRDRAM.h"
|
|
|
|
#include "BufferCopy/RDRAMtoColorBuffer.h"
|
2013-06-01 13:10:30 +00:00
|
|
|
|
2014-09-20 17:34:07 +00:00
|
|
|
using namespace std;
|
|
|
|
|
2015-10-10 16:36:25 +00:00
|
|
|
FrameBuffer::FrameBuffer() :
|
|
|
|
m_startAddress(0), m_endAddress(0), m_size(0), m_width(0), m_height(0), m_fillcolor(0), m_validityChecked(0),
|
|
|
|
m_scaleX(0), m_scaleY(0),
|
|
|
|
m_copiedToRdram(false), m_fingerprint(false), m_cleared(false), m_changed(false), m_cfb(false),
|
|
|
|
m_isDepthBuffer(false), m_isPauseScreen(false), m_isOBScreen(false), m_needHeightCorrection(false),
|
2016-06-10 06:06:06 +00:00
|
|
|
m_loadType(LOADTYPE_BLOCK), m_pDepthBuffer(nullptr),
|
|
|
|
m_resolveFBO(0), m_pResolveTexture(nullptr), m_resolved(false),
|
|
|
|
m_SubFBO(0), m_pSubTexture(nullptr)
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2016-05-10 04:52:12 +00:00
|
|
|
m_loadTileOrigin.uls = m_loadTileOrigin.ult = 0;
|
2014-09-08 11:01:22 +00:00
|
|
|
m_pTexture = textureCache().addFrameBufferTexture();
|
|
|
|
glGenFramebuffers(1, &m_FBO);
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
FrameBuffer::FrameBuffer(FrameBuffer && _other) :
|
|
|
|
m_startAddress(_other.m_startAddress), m_endAddress(_other.m_endAddress),
|
|
|
|
m_size(_other.m_size), m_width(_other.m_width), m_height(_other.m_height), m_fillcolor(_other.m_fillcolor),
|
2016-05-08 09:58:19 +00:00
|
|
|
m_validityChecked(_other.m_validityChecked), m_scaleX(_other.m_scaleX), m_scaleY(_other.m_scaleY), m_copiedToRdram(_other.m_copiedToRdram),
|
|
|
|
m_fingerprint(_other.m_fingerprint), m_cleared(_other.m_cleared), m_changed(_other.m_changed),
|
|
|
|
m_cfb(_other.m_cfb), m_isDepthBuffer(_other.m_isDepthBuffer), m_isPauseScreen(_other.m_isPauseScreen),
|
2016-05-10 04:52:12 +00:00
|
|
|
m_isOBScreen(_other.m_isOBScreen), m_needHeightCorrection(_other.m_needHeightCorrection),
|
2016-05-12 18:06:25 +00:00
|
|
|
m_loadTileOrigin(_other.m_loadTileOrigin), m_loadType(_other.m_loadType),
|
2016-05-10 04:52:12 +00:00
|
|
|
m_FBO(_other.m_FBO), m_pTexture(_other.m_pTexture), m_pDepthBuffer(_other.m_pDepthBuffer),
|
2016-05-08 09:58:19 +00:00
|
|
|
m_resolveFBO(_other.m_resolveFBO), m_pResolveTexture(_other.m_pResolveTexture), m_resolved(_other.m_resolved),
|
|
|
|
m_SubFBO(_other.m_SubFBO), m_pSubTexture(_other.m_pSubTexture),
|
|
|
|
m_RdramCopy(_other.m_RdramCopy)
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2014-09-08 11:01:22 +00:00
|
|
|
_other.m_FBO = 0;
|
2016-06-10 06:06:06 +00:00
|
|
|
_other.m_pTexture = nullptr;
|
|
|
|
_other.m_pDepthBuffer = nullptr;
|
|
|
|
_other.m_pResolveTexture = nullptr;
|
2015-02-09 12:27:39 +00:00
|
|
|
_other.m_resolveFBO = 0;
|
2015-04-29 13:58:06 +00:00
|
|
|
_other.m_RdramCopy.clear();
|
2016-05-08 09:58:19 +00:00
|
|
|
_other.m_SubFBO = 0;
|
2016-06-10 06:06:06 +00:00
|
|
|
_other.m_pSubTexture = nullptr;
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
FrameBuffer::~FrameBuffer()
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2014-09-08 11:01:22 +00:00
|
|
|
if (m_FBO != 0)
|
|
|
|
glDeleteFramebuffers(1, &m_FBO);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pTexture != nullptr)
|
2014-09-08 11:01:22 +00:00
|
|
|
textureCache().removeFrameBufferTexture(m_pTexture);
|
2015-02-09 12:27:39 +00:00
|
|
|
if (m_resolveFBO != 0)
|
|
|
|
glDeleteFramebuffers(1, &m_resolveFBO);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pResolveTexture != nullptr)
|
2015-02-09 12:27:39 +00:00
|
|
|
textureCache().removeFrameBufferTexture(m_pResolveTexture);
|
2016-05-08 09:58:19 +00:00
|
|
|
if (m_SubFBO != 0)
|
|
|
|
glDeleteFramebuffers(1, &m_SubFBO);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pSubTexture != nullptr)
|
2016-05-08 09:58:19 +00:00
|
|
|
textureCache().removeFrameBufferTexture(m_pSubTexture);
|
2015-02-09 12:27:39 +00:00
|
|
|
}
|
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
void FrameBuffer::_initTexture(u16 _width, u16 _height, u16 _format, u16 _size, CachedTexture *_pTexture)
|
2015-02-09 12:27:39 +00:00
|
|
|
{
|
2016-05-08 09:58:19 +00:00
|
|
|
_pTexture->width = (u32)(_width * m_scaleX);
|
|
|
|
_pTexture->height = (u32)(_height * m_scaleY);
|
2015-02-09 12:27:39 +00:00
|
|
|
_pTexture->format = _format;
|
|
|
|
_pTexture->size = _size;
|
|
|
|
_pTexture->clampS = 1;
|
|
|
|
_pTexture->clampT = 1;
|
|
|
|
_pTexture->address = m_startAddress;
|
2016-05-08 09:58:19 +00:00
|
|
|
_pTexture->clampWidth = _width;
|
|
|
|
_pTexture->clampHeight = _height;
|
2015-05-06 13:47:12 +00:00
|
|
|
_pTexture->frameBufferTexture = CachedTexture::fbOneSample;
|
2015-02-09 12:27:39 +00:00
|
|
|
_pTexture->maskS = 0;
|
|
|
|
_pTexture->maskT = 0;
|
|
|
|
_pTexture->mirrorS = 0;
|
|
|
|
_pTexture->mirrorT = 0;
|
|
|
|
_pTexture->realWidth = _pTexture->width;
|
|
|
|
_pTexture->realHeight = _pTexture->height;
|
|
|
|
_pTexture->textureBytes = _pTexture->realWidth * _pTexture->realHeight;
|
|
|
|
if (_size > G_IM_SIZ_8b)
|
2015-06-02 12:57:24 +00:00
|
|
|
_pTexture->textureBytes *= fboFormats.colorFormatBytes;
|
|
|
|
else
|
|
|
|
_pTexture->textureBytes *= fboFormats.monochromeFormatBytes;
|
2015-02-09 12:27:39 +00:00
|
|
|
textureCache().addFrameBufferTextureSize(_pTexture->textureBytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
void FrameBuffer::_setAndAttachTexture(u16 _size, CachedTexture *_pTexture)
|
|
|
|
{
|
|
|
|
glBindTexture(GL_TEXTURE_2D, _pTexture->glName);
|
2015-05-16 08:56:42 +00:00
|
|
|
if (_size > G_IM_SIZ_8b)
|
2016-06-10 06:06:06 +00:00
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, fboFormats.colorInternalFormat, _pTexture->realWidth, _pTexture->realHeight, 0, fboFormats.colorFormat, fboFormats.colorType, nullptr);
|
2015-05-16 08:56:42 +00:00
|
|
|
else
|
2016-06-10 06:06:06 +00:00
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, fboFormats.monochromeInternalFormat, _pTexture->realWidth, _pTexture->realHeight, 0, fboFormats.monochromeFormat, fboFormats.monochromeType, nullptr);
|
2015-02-09 12:27:39 +00:00
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
|
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _pTexture->glName, 0);
|
|
|
|
}
|
|
|
|
|
2015-05-06 13:16:46 +00:00
|
|
|
bool FrameBuffer::_isMarioTennisScoreboard() const
|
|
|
|
{
|
|
|
|
if ((config.generalEmulation.hacks&hack_scoreboard) != 0) {
|
|
|
|
if (VI.PAL)
|
|
|
|
return m_startAddress == 0x13b480 || m_startAddress == 0x26a530;
|
|
|
|
else
|
|
|
|
return m_startAddress == 0x13ba50 || m_startAddress == 0x264430;
|
|
|
|
}
|
|
|
|
return (config.generalEmulation.hacks&hack_scoreboardJ) != 0 && (m_startAddress == 0x134080 || m_startAddress == 0x1332f8);
|
|
|
|
}
|
|
|
|
|
2016-02-14 11:25:07 +00:00
|
|
|
bool FrameBuffer::isAuxiliary() const
|
|
|
|
{
|
|
|
|
return m_width != VI.width;
|
|
|
|
}
|
|
|
|
|
2015-02-09 12:27:39 +00:00
|
|
|
void FrameBuffer::init(u32 _address, u32 _endAddress, u16 _format, u16 _size, u16 _width, u16 _height, bool _cfb)
|
|
|
|
{
|
|
|
|
OGLVideo & ogl = video();
|
|
|
|
m_startAddress = _address;
|
|
|
|
m_endAddress = _endAddress;
|
|
|
|
m_width = _width;
|
|
|
|
m_height = _height;
|
|
|
|
m_size = _size;
|
2016-02-14 11:25:07 +00:00
|
|
|
if (isAuxiliary() && config.frameBufferEmulation.copyAuxToRDRAM != 0) {
|
2015-10-31 02:27:34 +00:00
|
|
|
m_scaleX = 1.0f;
|
|
|
|
m_scaleY = 1.0f;
|
2016-02-09 17:33:31 +00:00
|
|
|
} else if (config.frameBufferEmulation.nativeResFactor != 0) {
|
|
|
|
m_scaleX = m_scaleY = static_cast<float>(config.frameBufferEmulation.nativeResFactor);
|
2015-10-31 02:27:34 +00:00
|
|
|
} else {
|
|
|
|
m_scaleX = ogl.getScaleX();
|
|
|
|
m_scaleY = ogl.getScaleY();
|
|
|
|
}
|
2015-02-09 12:27:39 +00:00
|
|
|
m_fillcolor = 0;
|
|
|
|
m_cfb = _cfb;
|
2015-03-19 14:17:35 +00:00
|
|
|
m_needHeightCorrection = _width != VI.width && _width != *REG.VI_WIDTH;
|
2015-03-17 13:36:17 +00:00
|
|
|
m_cleared = false;
|
2015-08-02 19:01:02 +00:00
|
|
|
m_fingerprint = false;
|
2015-02-09 12:27:39 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
_initTexture(_width, _height, _format, _size, m_pTexture);
|
2015-02-09 12:27:39 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
|
|
|
|
|
2015-05-04 14:32:58 +00:00
|
|
|
#ifdef GL_MULTISAMPLING_SUPPORT
|
2015-02-09 12:27:39 +00:00
|
|
|
if (config.video.multisampling != 0) {
|
|
|
|
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_pTexture->glName);
|
2015-05-04 14:32:58 +00:00
|
|
|
#if defined(GLES3_1)
|
2015-04-23 08:51:35 +00:00
|
|
|
if (_size > G_IM_SIZ_8b)
|
|
|
|
glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, config.video.multisampling, GL_RGBA8, m_pTexture->realWidth, m_pTexture->realHeight, false);
|
|
|
|
else
|
2015-06-02 12:57:24 +00:00
|
|
|
glTexStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, config.video.multisampling, fboFormats.monochromeInternalFormat, m_pTexture->realWidth, m_pTexture->realHeight, false);
|
2015-05-04 14:32:58 +00:00
|
|
|
#else
|
|
|
|
if (_size > G_IM_SIZ_8b)
|
|
|
|
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, config.video.multisampling, GL_RGBA8, m_pTexture->realWidth, m_pTexture->realHeight, false);
|
|
|
|
else
|
2015-06-02 12:57:24 +00:00
|
|
|
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, config.video.multisampling, fboFormats.monochromeInternalFormat, m_pTexture->realWidth, m_pTexture->realHeight, false);
|
2015-04-23 08:51:35 +00:00
|
|
|
#endif
|
2015-05-06 13:47:12 +00:00
|
|
|
m_pTexture->frameBufferTexture = CachedTexture::fbMultiSample;
|
2015-05-04 14:32:58 +00:00
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_pTexture->glName, 0);
|
2015-02-09 12:27:39 +00:00
|
|
|
|
|
|
|
m_pResolveTexture = textureCache().addFrameBufferTexture();
|
2016-05-08 09:58:19 +00:00
|
|
|
_initTexture(_width, _height, _format, _size, m_pResolveTexture);
|
2015-02-09 12:27:39 +00:00
|
|
|
glGenFramebuffers(1, &m_resolveFBO);
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_resolveFBO);
|
|
|
|
_setAndAttachTexture(_size, m_pResolveTexture);
|
|
|
|
assert(checkFBO());
|
|
|
|
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_FBO);
|
|
|
|
} else
|
2015-05-04 14:32:58 +00:00
|
|
|
#endif // GL_MULTISAMPLING_SUPPORT
|
2015-02-09 12:27:39 +00:00
|
|
|
_setAndAttachTexture(_size, m_pTexture);
|
2016-03-04 04:58:52 +00:00
|
|
|
|
|
|
|
ogl.getRender().clearColorBuffer(nullptr);
|
2015-02-09 12:27:39 +00:00
|
|
|
}
|
|
|
|
|
2015-03-11 10:59:42 +00:00
|
|
|
void FrameBuffer::reinit(u16 _height)
|
|
|
|
{
|
|
|
|
const u16 format = m_pTexture->format;
|
2015-09-25 06:21:20 +00:00
|
|
|
const u32 endAddress = m_startAddress + ((m_width * _height) << m_size >> 1) - 1;
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pTexture != nullptr)
|
2015-03-11 10:59:42 +00:00
|
|
|
textureCache().removeFrameBufferTexture(m_pTexture);
|
|
|
|
if (m_resolveFBO != 0)
|
|
|
|
glDeleteFramebuffers(1, &m_resolveFBO);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pResolveTexture != nullptr)
|
2015-03-11 10:59:42 +00:00
|
|
|
textureCache().removeFrameBufferTexture(m_pResolveTexture);
|
|
|
|
m_pTexture = textureCache().addFrameBufferTexture();
|
|
|
|
init(m_startAddress, endAddress, format, m_size, m_width, _height, m_cfb);
|
|
|
|
}
|
|
|
|
|
2015-04-29 13:58:06 +00:00
|
|
|
inline
|
|
|
|
u32 _cutHeight(u32 _address, u32 _height, u32 _stride)
|
|
|
|
{
|
2015-11-15 09:26:03 +00:00
|
|
|
if (_address > RDRAMSize)
|
|
|
|
return 0;
|
2016-01-26 17:03:44 +00:00
|
|
|
if (_address + _stride * _height > (RDRAMSize + 1))
|
|
|
|
return (RDRAMSize + 1 - _address) / _stride;
|
2015-04-29 13:58:06 +00:00
|
|
|
return _height;
|
|
|
|
}
|
|
|
|
|
2016-05-28 15:37:20 +00:00
|
|
|
u32 cutHeight(u32 _address, u32 _height, u32 _stride)
|
|
|
|
{
|
|
|
|
return _cutHeight(_address, _height, _stride);
|
|
|
|
}
|
|
|
|
|
2015-04-29 13:58:06 +00:00
|
|
|
void FrameBuffer::copyRdram()
|
|
|
|
{
|
|
|
|
const u32 stride = m_width << m_size >> 1;
|
|
|
|
const u32 height = _cutHeight(m_startAddress, m_height, stride);
|
2015-11-15 09:26:03 +00:00
|
|
|
if (height == 0)
|
|
|
|
return;
|
2015-04-29 13:58:06 +00:00
|
|
|
const u32 dataSize = stride * height;
|
|
|
|
|
|
|
|
// Auxiliary frame buffer
|
2016-02-14 11:25:07 +00:00
|
|
|
if (isAuxiliary() && config.frameBufferEmulation.copyAuxToRDRAM == 0) {
|
2015-08-19 17:50:40 +00:00
|
|
|
// Write small amount of data to the start of the buffer.
|
|
|
|
// This is necessary for auxilary buffers: game can restore content of RDRAM when buffer is not needed anymore
|
|
|
|
// Thus content of RDRAM on moment of buffer creation will be the same as when buffer becomes obsolete.
|
|
|
|
// Validity check will see that the RDRAM is the same and thus the buffer is valid, which is false.
|
2016-05-07 17:20:10 +00:00
|
|
|
const u32 twoPercent = max(4U, dataSize / 200);
|
2015-08-19 17:50:40 +00:00
|
|
|
u32 start = m_startAddress >> 2;
|
|
|
|
u32 * pData = (u32*)RDRAM;
|
|
|
|
for (u32 i = 0; i < twoPercent; ++i) {
|
|
|
|
if (i < 4)
|
|
|
|
pData[start++] = fingerprint[i];
|
|
|
|
else
|
|
|
|
pData[start++] = 0;
|
2015-04-29 13:58:06 +00:00
|
|
|
}
|
2015-08-19 17:50:40 +00:00
|
|
|
m_cleared = false;
|
|
|
|
m_fingerprint = true;
|
|
|
|
return;
|
2015-04-29 13:58:06 +00:00
|
|
|
}
|
|
|
|
m_RdramCopy.resize(dataSize);
|
|
|
|
memcpy(m_RdramCopy.data(), RDRAM + m_startAddress, dataSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FrameBuffer::isValid() const
|
|
|
|
{
|
2015-10-16 15:42:35 +00:00
|
|
|
if (m_validityChecked == video().getBuffersSwapCount())
|
2015-04-29 13:58:06 +00:00
|
|
|
return true; // Already checked
|
|
|
|
|
|
|
|
const u32 * const pData = (const u32*)RDRAM;
|
|
|
|
|
|
|
|
if (m_cleared) {
|
|
|
|
const u32 color = m_fillcolor & 0xFFFEFFFE;
|
|
|
|
const u32 start = m_startAddress >> 2;
|
|
|
|
const u32 end = m_endAddress >> 2;
|
|
|
|
u32 wrongPixels = 0;
|
|
|
|
for (u32 i = start; i < end; ++i) {
|
|
|
|
if ((pData[i] & 0xFFFEFFFE) != color)
|
|
|
|
++wrongPixels;
|
|
|
|
}
|
2015-12-14 18:27:53 +00:00
|
|
|
return wrongPixels < (m_endAddress - m_startAddress) / 400; // threshold level 1% of dwords
|
2015-08-17 15:45:08 +00:00
|
|
|
} else if (m_fingerprint) {
|
2015-07-21 11:32:52 +00:00
|
|
|
//check if our fingerprint is still there
|
|
|
|
u32 start = m_startAddress >> 2;
|
2015-07-21 15:26:35 +00:00
|
|
|
for (u32 i = 0; i < 4; ++i)
|
|
|
|
if ((pData[start++] & 0xFFFEFFFE) != (fingerprint[i] & 0xFFFEFFFE))
|
2015-07-21 11:32:52 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
2015-08-17 15:45:08 +00:00
|
|
|
} else if (!m_RdramCopy.empty()) {
|
2015-04-29 13:58:06 +00:00
|
|
|
const u32 * const pCopy = (const u32*)m_RdramCopy.data();
|
|
|
|
const u32 size = m_RdramCopy.size();
|
|
|
|
const u32 size_dwords = size >> 2;
|
|
|
|
u32 start = m_startAddress >> 2;
|
|
|
|
u32 wrongPixels = 0;
|
|
|
|
for (u32 i = 0; i < size_dwords; ++i) {
|
|
|
|
if ((pData[start++] & 0xFFFEFFFE) != (pCopy[i] & 0xFFFEFFFE))
|
|
|
|
++wrongPixels;
|
|
|
|
}
|
2015-12-14 18:27:53 +00:00
|
|
|
return wrongPixels < size / 400; // threshold level 1% of dwords
|
2015-04-29 13:58:06 +00:00
|
|
|
}
|
|
|
|
return true; // No data to decide
|
|
|
|
}
|
2015-03-11 10:59:42 +00:00
|
|
|
|
2016-03-19 14:18:39 +00:00
|
|
|
void FrameBuffer::resolveMultisampledTexture(bool _bForce)
|
2015-02-09 12:27:39 +00:00
|
|
|
{
|
2015-05-14 13:47:25 +00:00
|
|
|
#ifdef GL_MULTISAMPLING_SUPPORT
|
2016-03-19 14:18:39 +00:00
|
|
|
if (m_resolved && !_bForce)
|
2015-02-09 12:27:39 +00:00
|
|
|
return;
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_FBO);
|
|
|
|
glReadBuffer(GL_COLOR_ATTACHMENT0);
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolveFBO);
|
2016-05-14 12:15:54 +00:00
|
|
|
glDisable(GL_SCISSOR_TEST);
|
2015-02-09 12:27:39 +00:00
|
|
|
glBlitFramebuffer(
|
|
|
|
0, 0, m_pTexture->realWidth, m_pTexture->realHeight,
|
|
|
|
0, 0, m_pResolveTexture->realWidth, m_pResolveTexture->realHeight,
|
|
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST
|
|
|
|
);
|
2016-05-14 12:15:54 +00:00
|
|
|
glEnable(GL_SCISSOR_TEST);
|
2015-02-09 12:27:39 +00:00
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
2016-05-08 07:35:17 +00:00
|
|
|
frameBufferList().setCurrentDrawBuffer();
|
2015-02-09 12:27:39 +00:00
|
|
|
m_resolved = true;
|
2015-05-14 13:47:25 +00:00
|
|
|
#endif
|
2015-02-09 12:27:39 +00:00
|
|
|
}
|
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
bool FrameBuffer::_initSubTexture(u32 _t)
|
2015-02-09 12:27:39 +00:00
|
|
|
{
|
2016-05-08 09:58:19 +00:00
|
|
|
if (m_SubFBO == 0)
|
|
|
|
glGenFramebuffers(1, &m_SubFBO);
|
|
|
|
|
|
|
|
gDPTile * pTile = gSP.textureTile[_t];
|
|
|
|
if (pTile->lrs < pTile->uls || pTile->lrt < pTile->ult)
|
|
|
|
return false;
|
|
|
|
const u32 width = pTile->lrs - pTile->uls + 1;
|
|
|
|
const u32 height = pTile->lrt - pTile->ult + 1;
|
|
|
|
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pSubTexture != nullptr) {
|
2016-05-08 09:58:19 +00:00
|
|
|
if (m_pSubTexture->size == m_pTexture->size &&
|
|
|
|
m_pSubTexture->clampWidth == width &&
|
|
|
|
m_pSubTexture->clampHeight == height)
|
|
|
|
return true;
|
|
|
|
textureCache().removeFrameBufferTexture(m_pSubTexture);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_pSubTexture = textureCache().addFrameBufferTexture();
|
|
|
|
_initTexture(width, height, m_pTexture->format, m_pTexture->size, m_pSubTexture);
|
|
|
|
|
|
|
|
m_pSubTexture->clampS = pTile->clamps;
|
|
|
|
m_pSubTexture->clampT = pTile->clampt;
|
|
|
|
m_pSubTexture->offsetS = 0.0f;
|
|
|
|
m_pSubTexture->offsetT = m_pSubTexture->clampHeight;
|
|
|
|
|
|
|
|
glActiveTexture(GL_TEXTURE0 + _t);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, m_pSubTexture->glName);
|
|
|
|
if (m_pSubTexture->size > G_IM_SIZ_8b)
|
2016-06-10 06:06:06 +00:00
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, fboFormats.colorInternalFormat, m_pSubTexture->realWidth, m_pSubTexture->realHeight, 0, fboFormats.colorFormat, fboFormats.colorType, nullptr);
|
2016-05-08 09:58:19 +00:00
|
|
|
else
|
2016-06-10 06:06:06 +00:00
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, fboFormats.monochromeInternalFormat, m_pSubTexture->realWidth, m_pSubTexture->realHeight, 0, fboFormats.monochromeFormat, fboFormats.monochromeType, nullptr);
|
2016-05-08 09:58:19 +00:00
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
|
|
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_SubFBO);
|
|
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_pSubTexture->glName, 0);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
CachedTexture * FrameBuffer::_getSubTexture(u32 _t)
|
|
|
|
{
|
|
|
|
if (!_initSubTexture(_t))
|
2015-02-09 12:27:39 +00:00
|
|
|
return m_pTexture;
|
2016-05-08 09:58:19 +00:00
|
|
|
GLint x0 = (GLint)(m_pTexture->offsetS * m_scaleX);
|
|
|
|
GLint y0 = (GLint)(m_pTexture->offsetT * m_scaleY) - m_pSubTexture->realHeight;
|
|
|
|
GLint copyWidth = m_pSubTexture->realWidth;
|
|
|
|
if (x0 + copyWidth > m_pTexture->realWidth)
|
|
|
|
copyWidth = m_pTexture->realWidth - x0;
|
|
|
|
GLint copyHeight = m_pSubTexture->realHeight;
|
|
|
|
if (y0 + copyHeight > m_pTexture->realHeight)
|
|
|
|
copyHeight = m_pTexture->realHeight - y0;
|
|
|
|
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_FBO);
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_SubFBO);
|
2016-06-23 10:12:50 +00:00
|
|
|
video().getRender().copyTexturedRect(x0, y0, x0 + copyWidth, y0 + copyHeight,
|
|
|
|
m_pTexture->realWidth,m_pTexture->realHeight, m_pTexture->glName,
|
|
|
|
0, 0, copyWidth, copyHeight,
|
|
|
|
m_pSubTexture->realWidth, m_pSubTexture->realHeight, GL_NEAREST);
|
2016-05-08 09:58:19 +00:00
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
|
|
|
frameBufferList().setCurrentDrawBuffer();
|
|
|
|
|
|
|
|
return m_pSubTexture;
|
|
|
|
}
|
|
|
|
|
|
|
|
CachedTexture * FrameBuffer::getTexture(u32 _t)
|
|
|
|
{
|
|
|
|
const u32 shift = (gSP.textureTile[_t]->imageAddress - m_startAddress) >> (m_size - 1);
|
|
|
|
const u32 factor = m_width;
|
2016-05-10 04:52:12 +00:00
|
|
|
if (m_loadType == LOADTYPE_TILE) {
|
|
|
|
m_pTexture->offsetS = (float)(m_loadTileOrigin.uls + (shift % factor));
|
|
|
|
m_pTexture->offsetT = (float)(m_height - (m_loadTileOrigin.ult + shift / factor));
|
2016-05-08 09:58:19 +00:00
|
|
|
} else {
|
|
|
|
m_pTexture->offsetS = (float)(shift % factor);
|
|
|
|
m_pTexture->offsetT = (float)(m_height - shift / factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
CachedTexture *pTexture = m_pTexture;
|
|
|
|
// if (gSP.textureTile[_t]->loadType == LOADTYPE_TILE && pTexture->size > 1)
|
|
|
|
if (gSP.textureTile[_t]->clamps == 0 || gSP.textureTile[_t]->clampt == 0)
|
|
|
|
pTexture = _getSubTexture(_t);
|
|
|
|
|
|
|
|
pTexture->scaleS = m_scaleX / (float)pTexture->realWidth;
|
|
|
|
pTexture->scaleT = m_scaleY / (float)pTexture->realHeight;
|
|
|
|
|
|
|
|
if (gSP.textureTile[_t]->shifts > 10)
|
|
|
|
pTexture->shiftScaleS = (float)(1 << (16 - gSP.textureTile[_t]->shifts));
|
|
|
|
else if (gSP.textureTile[_t]->shifts > 0)
|
|
|
|
pTexture->shiftScaleS = 1.0f / (float)(1 << gSP.textureTile[_t]->shifts);
|
|
|
|
else
|
|
|
|
pTexture->shiftScaleS = 1.0f;
|
|
|
|
|
|
|
|
if (gSP.textureTile[_t]->shiftt > 10)
|
|
|
|
pTexture->shiftScaleT = (float)(1 << (16 - gSP.textureTile[_t]->shiftt));
|
|
|
|
else if (gSP.textureTile[_t]->shiftt > 0)
|
|
|
|
pTexture->shiftScaleT = 1.0f / (float)(1 << gSP.textureTile[_t]->shiftt);
|
|
|
|
else
|
|
|
|
pTexture->shiftScaleT = 1.0f;
|
|
|
|
|
|
|
|
return pTexture;
|
|
|
|
}
|
2015-02-09 12:27:39 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
CachedTexture * FrameBuffer::getTextureBG(u32 _t)
|
|
|
|
{
|
2016-05-09 11:37:23 +00:00
|
|
|
m_pTexture->scaleS = m_scaleX / (float)m_pTexture->realWidth;
|
|
|
|
m_pTexture->scaleT = m_scaleY / (float)m_pTexture->realHeight;
|
2016-05-08 09:58:19 +00:00
|
|
|
|
|
|
|
m_pTexture->shiftScaleS = 1.0f;
|
|
|
|
m_pTexture->shiftScaleT = 1.0f;
|
|
|
|
|
|
|
|
m_pTexture->offsetS = gSP.bgImage.imageX;
|
|
|
|
m_pTexture->offsetT = (float)m_height - gSP.bgImage.imageY;
|
|
|
|
return m_pTexture;
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2015-03-31 12:44:41 +00:00
|
|
|
FrameBufferList & FrameBufferList::get()
|
|
|
|
{
|
|
|
|
static FrameBufferList frameBufferList;
|
|
|
|
return frameBufferList;
|
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
void FrameBufferList::init()
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
|
|
|
m_pCopy = nullptr;
|
2015-09-24 12:06:07 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
2016-02-14 11:25:07 +00:00
|
|
|
m_prevColorImageHeight = 0;
|
2014-09-08 11:01:22 +00:00
|
|
|
}
|
2013-04-05 06:13:26 +00:00
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
void FrameBufferList::destroy() {
|
|
|
|
m_list.clear();
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
|
|
|
m_pCopy = nullptr;
|
2015-09-24 12:06:07 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2015-03-01 11:52:59 +00:00
|
|
|
void FrameBufferList::setBufferChanged()
|
|
|
|
{
|
|
|
|
gDP.colorImage.changed = TRUE;
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent != nullptr) {
|
2015-03-01 11:52:59 +00:00
|
|
|
m_pCurrent->m_changed = true;
|
2015-04-29 13:58:06 +00:00
|
|
|
m_pCurrent->m_copiedToRdram = false;
|
2015-03-09 11:17:20 +00:00
|
|
|
}
|
2015-03-01 11:52:59 +00:00
|
|
|
}
|
|
|
|
|
2015-03-01 06:53:15 +00:00
|
|
|
void FrameBufferList::correctHeight()
|
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent == nullptr)
|
2015-03-01 06:53:15 +00:00
|
|
|
return;
|
|
|
|
if (m_pCurrent->m_changed) {
|
|
|
|
m_pCurrent->m_needHeightCorrection = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (m_pCurrent->m_needHeightCorrection && m_pCurrent->m_width == gDP.scissor.lrx) {
|
2015-09-20 14:09:59 +00:00
|
|
|
if (m_pCurrent->m_height != gDP.scissor.lry) {
|
|
|
|
m_pCurrent->reinit((u32)gDP.scissor.lry);
|
2015-03-15 05:31:43 +00:00
|
|
|
|
2015-09-20 14:09:59 +00:00
|
|
|
if (m_pCurrent->_isMarioTennisScoreboard())
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().copyFromRDRAM(m_pCurrent->m_startAddress + 4, true);
|
2015-09-20 14:09:59 +00:00
|
|
|
gSP.changed |= CHANGED_VIEWPORT;
|
|
|
|
}
|
2015-03-01 06:53:15 +00:00
|
|
|
m_pCurrent->m_needHeightCorrection = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-01 11:52:59 +00:00
|
|
|
void FrameBufferList::clearBuffersChanged()
|
|
|
|
{
|
|
|
|
gDP.colorImage.changed = FALSE;
|
2015-03-30 12:06:21 +00:00
|
|
|
FrameBuffer * pBuffer = frameBufferList().findBuffer(*REG.VI_ORIGIN);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pBuffer != nullptr)
|
2015-03-30 12:06:21 +00:00
|
|
|
pBuffer->m_changed = false;
|
2015-03-01 11:52:59 +00:00
|
|
|
}
|
|
|
|
|
2016-05-08 07:35:17 +00:00
|
|
|
void FrameBufferList::setCurrentDrawBuffer() const
|
|
|
|
{
|
|
|
|
if (m_pCurrent != nullptr)
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_pCurrent->m_FBO);
|
|
|
|
}
|
|
|
|
|
2014-10-22 07:49:55 +00:00
|
|
|
FrameBuffer * FrameBufferList::findBuffer(u32 _startAddress)
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2014-09-08 11:01:22 +00:00
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter)
|
2014-10-22 07:49:55 +00:00
|
|
|
if (iter->m_startAddress <= _startAddress && iter->m_endAddress >= _startAddress) // [ { ]
|
|
|
|
return &(*iter);
|
2016-06-10 06:06:06 +00:00
|
|
|
return nullptr;
|
2014-10-22 07:49:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FrameBuffer * FrameBufferList::_findBuffer(u32 _startAddress, u32 _endAddress, u32 _width)
|
|
|
|
{
|
|
|
|
if (m_list.empty())
|
2016-06-10 06:06:06 +00:00
|
|
|
return nullptr;
|
2014-10-22 07:49:55 +00:00
|
|
|
|
|
|
|
FrameBuffers::iterator iter = m_list.end();
|
|
|
|
do {
|
|
|
|
--iter;
|
|
|
|
if ((iter->m_startAddress <= _startAddress && iter->m_endAddress >= _startAddress) || // [ { ]
|
|
|
|
(_startAddress <= iter->m_startAddress && _endAddress >= iter->m_startAddress)) { // { [ }
|
|
|
|
|
|
|
|
if (_startAddress != iter->m_startAddress || _width != iter->m_width) {
|
|
|
|
m_list.erase(iter);
|
|
|
|
return _findBuffer(_startAddress, _endAddress, _width);
|
|
|
|
}
|
|
|
|
|
|
|
|
return &(*iter);
|
|
|
|
}
|
|
|
|
} while (iter != m_list.begin());
|
2016-06-10 06:06:06 +00:00
|
|
|
return nullptr;
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
FrameBuffer * FrameBufferList::findTmpBuffer(u32 _address)
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2014-09-08 11:01:22 +00:00
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter)
|
|
|
|
if (iter->m_startAddress > _address || iter->m_endAddress < _address)
|
|
|
|
return &(*iter);
|
2016-06-10 06:06:06 +00:00
|
|
|
return nullptr;
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2014-09-28 06:09:03 +00:00
|
|
|
void FrameBufferList::saveBuffer(u32 _address, u16 _format, u16 _size, u16 _width, u16 _height, bool _cfb)
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent != nullptr && config.frameBufferEmulation.copyAuxToRDRAM != 0) {
|
2016-02-14 11:25:07 +00:00
|
|
|
if (m_pCurrent->isAuxiliary()) {
|
2015-10-31 03:11:33 +00:00
|
|
|
FrameBuffer_CopyToRDRAM(m_pCurrent->m_startAddress, true);
|
2015-10-31 02:39:14 +00:00
|
|
|
removeBuffer(m_pCurrent->m_startAddress);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-20 14:12:52 +00:00
|
|
|
if (VI.width == 0 || _height == 0) {
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2015-09-20 14:12:52 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
2014-09-27 06:17:01 +00:00
|
|
|
return;
|
2015-09-20 14:12:52 +00:00
|
|
|
}
|
2015-03-15 05:31:43 +00:00
|
|
|
|
2014-09-21 12:15:22 +00:00
|
|
|
OGLVideo & ogl = video();
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent != nullptr) {
|
2016-02-14 11:25:07 +00:00
|
|
|
// Correct buffer's end address
|
|
|
|
if (!m_pCurrent->isAuxiliary()) {
|
2016-03-19 13:19:10 +00:00
|
|
|
if (gDP.colorImage.height > 200)
|
2016-02-14 11:25:07 +00:00
|
|
|
m_prevColorImageHeight = gDP.colorImage.height;
|
2016-03-19 13:19:10 +00:00
|
|
|
else if (gDP.colorImage.height == 0)
|
2016-02-14 11:25:07 +00:00
|
|
|
gDP.colorImage.height = m_prevColorImageHeight;
|
2016-04-11 13:31:44 +00:00
|
|
|
|
2016-02-14 11:25:07 +00:00
|
|
|
gDP.colorImage.height = min(gDP.colorImage.height, VI.height);
|
2016-04-11 13:31:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//Non-auxiliary buffers are always corrected, auxiliary buffers are correct only if they need correction.
|
|
|
|
//Also, before making any adjustments, make sure gDP.colorImage.height has a valid value.
|
|
|
|
if((!m_pCurrent->isAuxiliary() || m_pCurrent->m_needHeightCorrection) && gDP.colorImage.height != 0)
|
|
|
|
{
|
2016-05-24 05:18:56 +00:00
|
|
|
m_pCurrent->m_endAddress = min(RDRAMSize, m_pCurrent->m_startAddress + (((m_pCurrent->m_width * gDP.colorImage.height) << m_pCurrent->m_size >> 1) - 1));
|
2016-02-14 11:25:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!m_pCurrent->_isMarioTennisScoreboard() && !m_pCurrent->m_isDepthBuffer && !m_pCurrent->m_copiedToRdram && !m_pCurrent->m_cfb && !m_pCurrent->m_cleared && m_pCurrent->m_RdramCopy.empty() && gDP.colorImage.height > 1) {
|
|
|
|
m_pCurrent->copyRdram();
|
2015-03-19 14:42:09 +00:00
|
|
|
}
|
2016-02-14 11:25:07 +00:00
|
|
|
|
2015-03-11 14:59:06 +00:00
|
|
|
m_pCurrent = _findBuffer(m_pCurrent->m_startAddress, m_pCurrent->m_endAddress, m_pCurrent->m_width);
|
2013-08-10 11:10:44 +00:00
|
|
|
}
|
|
|
|
|
2015-09-20 14:02:22 +00:00
|
|
|
const u32 endAddress = _address + ((_width * _height) << _size >> 1) - 1;
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent == nullptr || m_pCurrent->m_startAddress != _address || m_pCurrent->m_width != _width)
|
2015-03-11 14:59:06 +00:00
|
|
|
m_pCurrent = findBuffer(_address);
|
2016-02-09 17:33:31 +00:00
|
|
|
const float scaleX = config.frameBufferEmulation.nativeResFactor == 0 ? ogl.getScaleX() : static_cast<float>(config.frameBufferEmulation.nativeResFactor);
|
|
|
|
const float scaleY = config.frameBufferEmulation.nativeResFactor == 0 ? ogl.getScaleY() : scaleX;
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent != nullptr) {
|
2014-09-08 11:01:22 +00:00
|
|
|
if ((m_pCurrent->m_startAddress != _address) ||
|
|
|
|
(m_pCurrent->m_width != _width) ||
|
2013-09-04 02:15:05 +00:00
|
|
|
//(current->height != height) ||
|
2016-08-28 09:00:50 +00:00
|
|
|
(m_pCurrent->m_size < _size) ||
|
2016-02-09 17:33:31 +00:00
|
|
|
(m_pCurrent->m_scaleX != scaleX) ||
|
|
|
|
(m_pCurrent->m_scaleY != scaleY))
|
2013-04-05 06:13:26 +00:00
|
|
|
{
|
2014-09-08 11:01:22 +00:00
|
|
|
removeBuffer(m_pCurrent->m_startAddress);
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2013-09-05 15:53:49 +00:00
|
|
|
} else {
|
2015-02-09 12:27:39 +00:00
|
|
|
m_pCurrent->m_resolved = false;
|
2016-07-07 20:37:47 +00:00
|
|
|
#ifdef VC
|
|
|
|
const GLenum discards[] = {GL_DEPTH_ATTACHMENT};
|
|
|
|
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
|
|
|
|
#endif
|
2014-09-08 11:01:22 +00:00
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_pCurrent->m_FBO);
|
|
|
|
if (m_pCurrent->m_size != _size) {
|
2013-09-05 15:53:49 +00:00
|
|
|
f32 fillColor[4];
|
|
|
|
gDPGetFillColor(fillColor);
|
2014-09-21 12:15:22 +00:00
|
|
|
ogl.getRender().clearColorBuffer(fillColor);
|
2014-09-08 11:01:22 +00:00
|
|
|
m_pCurrent->m_size = _size;
|
|
|
|
m_pCurrent->m_pTexture->format = _format;
|
|
|
|
m_pCurrent->m_pTexture->size = _size;
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent->m_pResolveTexture != nullptr) {
|
2015-02-21 14:20:32 +00:00
|
|
|
m_pCurrent->m_pResolveTexture->format = _format;
|
|
|
|
m_pCurrent->m_pResolveTexture->size = _size;
|
|
|
|
}
|
2015-04-29 13:58:06 +00:00
|
|
|
if (m_pCurrent->m_copiedToRdram)
|
|
|
|
m_pCurrent->copyRdram();
|
2013-09-05 15:53:49 +00:00
|
|
|
}
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
2013-09-05 15:53:49 +00:00
|
|
|
}
|
2016-06-10 06:06:06 +00:00
|
|
|
const bool bNew = m_pCurrent == nullptr;
|
2013-10-19 13:32:39 +00:00
|
|
|
if (bNew) {
|
2013-09-05 15:53:49 +00:00
|
|
|
// Wasn't found or removed, create a new one
|
2014-09-08 11:01:22 +00:00
|
|
|
m_list.emplace_front();
|
|
|
|
FrameBuffer & buffer = m_list.front();
|
2015-02-09 12:27:39 +00:00
|
|
|
buffer.init(_address, endAddress, _format, _size, _width, _height, _cfb);
|
2014-09-08 11:01:22 +00:00
|
|
|
m_pCurrent = &buffer;
|
2015-04-27 10:40:25 +00:00
|
|
|
|
2016-04-02 08:15:22 +00:00
|
|
|
if (m_pCurrent->_isMarioTennisScoreboard() || ((config.generalEmulation.hacks & hack_legoRacers) != 0 && _width == VI.width))
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().copyFromRDRAM(m_pCurrent->m_startAddress + 4, true);
|
2013-06-04 16:05:09 +00:00
|
|
|
}
|
2013-06-01 13:10:30 +00:00
|
|
|
|
2015-04-08 17:06:17 +00:00
|
|
|
if (_address == gDP.depthImageAddress)
|
|
|
|
depthBufferList().saveBuffer(_address);
|
|
|
|
else
|
|
|
|
attachDepthBuffer();
|
2013-06-01 13:10:30 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
DebugMsg( DEBUG_HIGH | DEBUG_HANDLED, "FrameBuffer_SaveBuffer( 0x%08X ); depth buffer is 0x%08X\n",
|
2016-06-10 06:06:06 +00:00
|
|
|
address, (depthBuffer.top != nullptr && depthBuffer.top->renderbuf > 0) ? depthBuffer.top->address : 0
|
2013-06-01 13:10:30 +00:00
|
|
|
);
|
|
|
|
#endif
|
2015-03-15 05:31:43 +00:00
|
|
|
|
2015-03-09 11:17:52 +00:00
|
|
|
m_pCurrent->m_isDepthBuffer = _address == gDP.depthImageAddress;
|
2015-03-09 12:17:45 +00:00
|
|
|
m_pCurrent->m_isPauseScreen = m_pCurrent->m_isOBScreen = false;
|
2013-04-05 06:13:26 +00:00
|
|
|
}
|
|
|
|
|
2015-10-31 02:36:16 +00:00
|
|
|
void FrameBufferList::copyAux()
|
|
|
|
{
|
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter) {
|
|
|
|
if (iter->m_width != VI.width && iter->m_height != VI.height)
|
2015-10-31 03:11:33 +00:00
|
|
|
FrameBuffer_CopyToRDRAM(iter->m_startAddress, true);
|
2015-10-31 02:36:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void FrameBufferList::removeAux()
|
|
|
|
{
|
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter) {
|
|
|
|
while (iter->m_width != VI.width && iter->m_height != VI.height) {
|
|
|
|
if (&(*iter) == m_pCurrent) {
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2015-10-31 02:36:16 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
|
|
|
}
|
|
|
|
iter = m_list.erase(iter);
|
|
|
|
if (iter == m_list.end())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
void FrameBufferList::removeBuffer(u32 _address )
|
|
|
|
{
|
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter)
|
|
|
|
if (iter->m_startAddress == _address) {
|
2015-09-24 12:06:07 +00:00
|
|
|
if (&(*iter) == m_pCurrent) {
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2015-09-24 12:06:07 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
|
|
|
}
|
2014-09-08 11:01:22 +00:00
|
|
|
m_list.erase(iter);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-11 14:46:00 +00:00
|
|
|
void FrameBufferList::removeBuffers(u32 _width)
|
2015-03-11 11:33:47 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2015-03-11 11:33:47 +00:00
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter) {
|
2015-03-11 14:46:00 +00:00
|
|
|
while (iter->m_width == _width) {
|
2015-09-24 12:06:07 +00:00
|
|
|
if (&(*iter) == m_pCurrent) {
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent = nullptr;
|
2015-09-24 12:06:07 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
|
|
|
}
|
2015-03-11 11:33:47 +00:00
|
|
|
iter = m_list.erase(iter);
|
|
|
|
if (iter == m_list.end())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-27 05:58:56 +00:00
|
|
|
void FrameBufferList::fillBufferInfo(void * _pinfo, u32 _size)
|
2015-11-23 12:36:03 +00:00
|
|
|
{
|
2016-02-27 05:58:56 +00:00
|
|
|
FBInfo::FrameBufferInfo* pInfo = reinterpret_cast<FBInfo::FrameBufferInfo*>(_pinfo);
|
|
|
|
|
2015-11-23 12:36:03 +00:00
|
|
|
u32 idx = 0;
|
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter) {
|
2016-01-17 10:07:45 +00:00
|
|
|
if (iter->m_width == VI.width && !iter->m_cfb && !iter->m_isDepthBuffer) {
|
2016-02-27 05:58:56 +00:00
|
|
|
pInfo[idx].addr = iter->m_startAddress;
|
|
|
|
pInfo[idx].width = iter->m_width;
|
|
|
|
pInfo[idx].height = iter->m_height;
|
|
|
|
pInfo[idx++].size = iter->m_size;
|
2015-11-23 12:36:03 +00:00
|
|
|
if (idx >= _size)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
void FrameBufferList::attachDepthBuffer()
|
2013-10-30 06:07:24 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent == nullptr)
|
2015-01-27 16:00:06 +00:00
|
|
|
return;
|
|
|
|
|
2016-07-18 18:58:40 +00:00
|
|
|
#ifdef VC
|
|
|
|
const GLenum discards[] = {GL_DEPTH_ATTACHMENT};
|
|
|
|
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
|
|
|
|
#endif
|
2014-09-08 11:00:13 +00:00
|
|
|
DepthBuffer * pDepthBuffer = depthBufferList().getCurrent();
|
2016-06-10 06:06:06 +00:00
|
|
|
if (m_pCurrent->m_FBO > 0 && pDepthBuffer != nullptr) {
|
2015-01-27 16:00:06 +00:00
|
|
|
pDepthBuffer->initDepthImageTexture(m_pCurrent);
|
|
|
|
pDepthBuffer->initDepthBufferTexture(m_pCurrent);
|
2016-06-21 18:57:18 +00:00
|
|
|
#ifndef USE_DEPTH_RENDERBUFFER
|
2015-06-02 12:57:54 +00:00
|
|
|
#ifdef GLES2
|
|
|
|
if (pDepthBuffer->m_pDepthBufferTexture->realWidth == m_pCurrent->m_pTexture->realWidth) {
|
|
|
|
#else
|
2015-04-11 17:17:38 +00:00
|
|
|
if (pDepthBuffer->m_pDepthBufferTexture->realWidth >= m_pCurrent->m_pTexture->realWidth) {
|
2016-06-21 18:57:18 +00:00
|
|
|
#endif // GLES2
|
|
|
|
#else
|
|
|
|
if (pDepthBuffer->m_depthRenderbufferWidth == m_pCurrent->m_pTexture->realWidth) {
|
|
|
|
#endif // USE_DEPTH_RENDERBUFFER
|
2015-04-11 17:17:38 +00:00
|
|
|
m_pCurrent->m_pDepthBuffer = pDepthBuffer;
|
|
|
|
pDepthBuffer->setDepthAttachment(GL_DRAW_FRAMEBUFFER);
|
|
|
|
if (video().getRender().isImageTexturesSupported() && config.frameBufferEmulation.N64DepthCompare != 0)
|
|
|
|
pDepthBuffer->bindDepthImageTexture();
|
|
|
|
} else
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent->m_pDepthBuffer = nullptr;
|
2015-01-27 16:00:06 +00:00
|
|
|
} else
|
2016-06-10 06:06:06 +00:00
|
|
|
m_pCurrent->m_pDepthBuffer = nullptr;
|
2015-01-27 16:00:06 +00:00
|
|
|
|
2014-04-08 11:53:25 +00:00
|
|
|
#ifndef GLES2
|
2015-01-27 16:00:06 +00:00
|
|
|
GLuint attachments[1] = { GL_COLOR_ATTACHMENT0 };
|
|
|
|
glDrawBuffers(1, attachments);
|
2014-04-08 11:53:25 +00:00
|
|
|
#endif
|
2015-01-27 16:00:06 +00:00
|
|
|
assert(checkFBO());
|
2013-10-30 06:07:24 +00:00
|
|
|
}
|
2013-06-01 13:13:04 +00:00
|
|
|
|
2016-03-06 15:12:23 +00:00
|
|
|
void FrameBufferList::clearDepthBuffer(DepthBuffer * _pDepthBuffer)
|
|
|
|
{
|
|
|
|
for (FrameBuffers::iterator iter = m_list.begin(); iter != m_list.end(); ++iter) {
|
|
|
|
if (iter->m_pDepthBuffer == _pDepthBuffer) {
|
2016-06-10 06:06:06 +00:00
|
|
|
iter->m_pDepthBuffer = nullptr;
|
2016-03-06 15:12:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-08 11:01:22 +00:00
|
|
|
void FrameBuffer_Init()
|
|
|
|
{
|
|
|
|
frameBufferList().init();
|
2015-05-04 08:46:14 +00:00
|
|
|
if (config.frameBufferEmulation.enable != 0) {
|
2016-05-28 15:37:20 +00:00
|
|
|
ColorBufferToRDRAM::get().init();
|
2016-06-23 10:15:27 +00:00
|
|
|
#ifndef GLES2
|
2016-05-28 15:37:20 +00:00
|
|
|
DepthBufferToRDRAM::get().init();
|
2014-09-08 11:01:22 +00:00
|
|
|
#endif
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().init();
|
2015-05-04 08:46:14 +00:00
|
|
|
}
|
2014-09-08 11:01:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void FrameBuffer_Destroy()
|
|
|
|
{
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().destroy();
|
2014-09-08 11:01:22 +00:00
|
|
|
#ifndef GLES2
|
2016-05-28 15:37:20 +00:00
|
|
|
DepthBufferToRDRAM::get().destroy();
|
|
|
|
ColorBufferToRDRAM::get().destroy();
|
2014-09-08 11:01:22 +00:00
|
|
|
#endif
|
|
|
|
frameBufferList().destroy();
|
|
|
|
}
|
|
|
|
|
|
|
|
void FrameBufferList::renderBuffer(u32 _address)
|
2013-06-01 13:13:04 +00:00
|
|
|
{
|
2014-10-10 10:22:10 +00:00
|
|
|
static s32 vStartPrev = 0;
|
2014-09-26 12:19:23 +00:00
|
|
|
|
2015-04-13 16:37:11 +00:00
|
|
|
if (VI.width == 0 || *REG.VI_WIDTH == 0 || *REG.VI_H_START == 0) // H width is zero. Don't draw
|
2013-09-29 15:02:50 +00:00
|
|
|
return;
|
2014-09-27 15:27:32 +00:00
|
|
|
|
2014-10-22 07:49:55 +00:00
|
|
|
FrameBuffer *pBuffer = findBuffer(_address);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pBuffer == nullptr)
|
2013-09-04 02:15:05 +00:00
|
|
|
return;
|
2014-09-27 15:27:32 +00:00
|
|
|
|
2014-09-21 12:15:22 +00:00
|
|
|
OGLVideo & ogl = video();
|
2015-08-27 13:20:26 +00:00
|
|
|
OGLRender & render = ogl.getRender();
|
2013-09-29 15:02:50 +00:00
|
|
|
GLint srcY0, srcY1, dstY0, dstY1;
|
2015-02-18 12:59:20 +00:00
|
|
|
GLint X0, X1, Xwidth;
|
2016-08-28 11:22:44 +00:00
|
|
|
GLint Xoffset = 0;
|
2016-08-29 11:32:16 +00:00
|
|
|
GLint Xdivot = 0;
|
2014-10-10 10:22:10 +00:00
|
|
|
GLint srcPartHeight = 0;
|
|
|
|
GLint dstPartHeight = 0;
|
|
|
|
|
|
|
|
const f32 yScale = _FIXED2FLOAT(_SHIFTR(*REG.VI_Y_SCALE, 0, 12), 10);
|
|
|
|
s32 vEnd = _SHIFTR(*REG.VI_V_START, 0, 10);
|
|
|
|
s32 vStart = _SHIFTR(*REG.VI_V_START, 16, 10);
|
2015-02-18 12:59:20 +00:00
|
|
|
const s32 hEnd = _SHIFTR(*REG.VI_H_START, 0, 10);
|
|
|
|
const s32 hStart = _SHIFTR(*REG.VI_H_START, 16, 10);
|
2014-10-10 10:22:10 +00:00
|
|
|
const s32 vSync = (*REG.VI_V_SYNC) & 0x03FF;
|
|
|
|
const bool interlaced = (*REG.VI_STATUS & 0x40) != 0;
|
|
|
|
const bool isPAL = vSync > 550;
|
|
|
|
const s32 vShift = (isPAL ? 47 : 37);
|
|
|
|
dstY0 = vStart - vShift;
|
|
|
|
dstY0 >>= 1;
|
|
|
|
dstY0 &= -(dstY0 >= 0);
|
|
|
|
vStart >>= 1;
|
|
|
|
vEnd >>= 1;
|
|
|
|
const u32 vFullHeight = isPAL ? 288 : 240;
|
|
|
|
const u32 vCurrentHeight = vEnd - vStart;
|
|
|
|
const float dstScaleY = (float)ogl.getHeight() / float(vFullHeight);
|
|
|
|
|
2014-09-26 12:19:23 +00:00
|
|
|
bool isLowerField = false;
|
2014-10-13 12:33:19 +00:00
|
|
|
if (interlaced)
|
2014-09-28 06:44:03 +00:00
|
|
|
isLowerField = vStart > vStartPrev;
|
2014-09-26 12:19:23 +00:00
|
|
|
vStartPrev = vStart;
|
|
|
|
|
2016-08-28 11:22:44 +00:00
|
|
|
const u32 addrOffset = ((_address - pBuffer->m_startAddress) << 1 >> pBuffer->m_size);
|
|
|
|
srcY0 = addrOffset / (*REG.VI_WIDTH);
|
|
|
|
if (addrOffset % (*REG.VI_WIDTH) != 0)
|
|
|
|
Xoffset = (*REG.VI_WIDTH) - addrOffset % (*REG.VI_WIDTH);
|
2014-11-29 13:01:27 +00:00
|
|
|
if (isLowerField) {
|
|
|
|
if (srcY0 > 0)
|
2015-08-27 13:20:26 +00:00
|
|
|
--srcY0;
|
2014-11-29 13:01:27 +00:00
|
|
|
if (dstY0 > 0)
|
|
|
|
--dstY0;
|
|
|
|
}
|
2014-09-26 12:19:23 +00:00
|
|
|
|
2014-10-10 10:22:10 +00:00
|
|
|
if (srcY0 + vCurrentHeight > vFullHeight) {
|
|
|
|
dstPartHeight = srcY0;
|
|
|
|
srcY0 = (GLint)(srcY0*yScale);
|
|
|
|
srcPartHeight = srcY0;
|
|
|
|
srcY1 = VI.real_height;
|
|
|
|
dstY1 = dstY0 + vCurrentHeight - dstPartHeight;
|
2014-09-27 15:27:32 +00:00
|
|
|
} else {
|
2014-10-10 10:22:10 +00:00
|
|
|
dstY0 += srcY0;
|
|
|
|
dstY1 = dstY0 + vCurrentHeight;
|
|
|
|
srcY0 = (GLint)(srcY0*yScale);
|
|
|
|
srcY1 = srcY0 + VI.real_height;
|
2013-09-29 15:02:50 +00:00
|
|
|
}
|
|
|
|
|
2016-05-13 17:29:35 +00:00
|
|
|
FrameBuffer * pFilteredBuffer = PostProcessor::get().doBlur(PostProcessor::get().doGammaCorrection(pBuffer));
|
|
|
|
|
2016-08-29 11:32:16 +00:00
|
|
|
const bool vi_fsaa = (*REG.VI_STATUS & 512) == 0;
|
|
|
|
const bool vi_divot = (*REG.VI_STATUS & 16) != 0;
|
|
|
|
if (vi_fsaa && vi_divot)
|
|
|
|
Xdivot = 1;
|
|
|
|
|
2016-02-09 17:33:31 +00:00
|
|
|
const f32 viScaleX = _FIXED2FLOAT(_SHIFTR(*REG.VI_X_SCALE, 0, 12), 10);
|
2016-05-13 17:29:35 +00:00
|
|
|
const f32 srcScaleX = pFilteredBuffer->m_scaleX;
|
2016-02-09 17:33:31 +00:00
|
|
|
const f32 dstScaleX = ogl.getScaleX();
|
2015-02-21 14:44:32 +00:00
|
|
|
const s32 h0 = (isPAL ? 128 : 108);
|
|
|
|
const s32 hx0 = max(0, hStart - h0);
|
|
|
|
const s32 hx1 = max(0, h0 + 640 - hEnd);
|
2016-08-28 11:22:44 +00:00
|
|
|
X0 = (GLint)((hx0 * viScaleX + Xoffset) * dstScaleX);
|
2016-08-29 11:32:16 +00:00
|
|
|
Xwidth = (GLint)((min((f32)VI.width, (hEnd - hStart)*viScaleX - Xoffset - Xdivot)) * srcScaleX);
|
2016-02-09 17:33:31 +00:00
|
|
|
X1 = ogl.getWidth() - (GLint)(hx1 *viScaleX * dstScaleX);
|
2015-02-09 05:36:20 +00:00
|
|
|
|
2016-05-13 17:29:35 +00:00
|
|
|
const f32 srcScaleY = pFilteredBuffer->m_scaleY;
|
2015-04-03 05:36:31 +00:00
|
|
|
const GLint hOffset = (ogl.getScreenWidth() - ogl.getWidth()) / 2;
|
|
|
|
const GLint vOffset = (ogl.getScreenHeight() - ogl.getHeight()) / 2 + ogl.getHeightOffset();
|
2016-05-13 17:29:35 +00:00
|
|
|
CachedTexture * pBufferTexture = pFilteredBuffer->m_pTexture;
|
2015-04-03 05:36:31 +00:00
|
|
|
GLint srcCoord[4] = { 0, (GLint)(srcY0*srcScaleY), Xwidth, min((GLint)(srcY1*srcScaleY), (GLint)pBufferTexture->realHeight) };
|
|
|
|
if (srcCoord[2] > pBufferTexture->realWidth || srcCoord[3] > pBufferTexture->realHeight) {
|
|
|
|
removeBuffer(pBuffer->m_startAddress);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
GLint dstCoord[4] = { X0 + hOffset, vOffset + (GLint)(dstY0*dstScaleY), hOffset + X1, vOffset + (GLint)(dstY1*dstScaleY) };
|
2015-08-27 13:20:26 +00:00
|
|
|
#ifdef GLESX
|
|
|
|
if (render.getRenderer() == OGLRender::glrAdreno)
|
|
|
|
dstCoord[0] += 1; // workaround for Adreno's issue with glBindFramebuffer;
|
|
|
|
#endif // GLESX
|
2015-04-03 05:36:31 +00:00
|
|
|
|
2014-03-21 09:38:39 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
2014-03-21 08:16:36 +00:00
|
|
|
//glDrawBuffer( GL_BACK );
|
2015-04-03 05:36:31 +00:00
|
|
|
float clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
2015-08-27 13:20:26 +00:00
|
|
|
render.clearColorBuffer(clearColor);
|
2015-02-09 12:27:39 +00:00
|
|
|
|
|
|
|
GLenum filter = GL_LINEAR;
|
2016-05-14 12:12:42 +00:00
|
|
|
if (pFilteredBuffer->m_pTexture->frameBufferTexture == CachedTexture::fbMultiSample) {
|
2015-02-21 14:44:32 +00:00
|
|
|
if (X0 > 0 || dstPartHeight > 0 ||
|
2015-02-09 12:27:39 +00:00
|
|
|
(srcCoord[2] - srcCoord[0]) != (dstCoord[2] - dstCoord[0]) ||
|
|
|
|
(srcCoord[3] - srcCoord[1]) != (dstCoord[3] - dstCoord[1])) {
|
2016-05-14 12:12:42 +00:00
|
|
|
pFilteredBuffer->resolveMultisampledTexture(true);
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, pFilteredBuffer->m_resolveFBO);
|
2015-04-03 05:36:31 +00:00
|
|
|
} else {
|
2016-05-14 12:12:42 +00:00
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, pFilteredBuffer->m_FBO);
|
2015-02-09 12:27:39 +00:00
|
|
|
filter = GL_NEAREST;
|
2015-04-03 05:36:31 +00:00
|
|
|
}
|
|
|
|
} else
|
2016-04-02 12:56:07 +00:00
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, pFilteredBuffer->m_FBO);
|
2015-02-09 05:36:20 +00:00
|
|
|
|
2016-06-23 10:14:04 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
2016-03-19 14:20:18 +00:00
|
|
|
|
2016-06-23 10:14:04 +00:00
|
|
|
ogl.getRender().copyTexturedRect(srcCoord[0], srcCoord[1], srcCoord[2], srcCoord[3],
|
|
|
|
pBufferTexture->realWidth, pBufferTexture->realHeight, pBufferTexture->glName,
|
|
|
|
dstCoord[0], dstCoord[1], dstCoord[2], dstCoord[3],
|
|
|
|
ogl.getScreenWidth(), ogl.getScreenHeight() + ogl.getHeightOffset(), filter);
|
2014-09-26 12:19:23 +00:00
|
|
|
|
2014-10-10 10:22:10 +00:00
|
|
|
if (dstPartHeight > 0) {
|
2013-09-29 15:02:50 +00:00
|
|
|
const u32 size = *REG.VI_STATUS & 3;
|
2014-09-08 11:01:22 +00:00
|
|
|
pBuffer = findBuffer(_address + (((*REG.VI_WIDTH)*VI.height)<<size>>1));
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pBuffer != nullptr) {
|
2016-05-22 02:54:53 +00:00
|
|
|
pFilteredBuffer = PostProcessor::get().doBlur(PostProcessor::get().doGammaCorrection(pBuffer));
|
2013-09-29 15:02:50 +00:00
|
|
|
srcY0 = 0;
|
2014-10-10 10:22:10 +00:00
|
|
|
srcY1 = srcPartHeight;
|
2013-09-29 15:02:50 +00:00
|
|
|
dstY0 = dstY1;
|
2014-10-10 10:22:10 +00:00
|
|
|
dstY1 = dstY0 + dstPartHeight;
|
2016-05-22 02:54:53 +00:00
|
|
|
if (pFilteredBuffer->m_pTexture->frameBufferTexture == CachedTexture::fbMultiSample) {
|
|
|
|
pFilteredBuffer->resolveMultisampledTexture();
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, pFilteredBuffer->m_resolveFBO);
|
|
|
|
} else
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, pFilteredBuffer->m_FBO);
|
2016-06-23 10:14:04 +00:00
|
|
|
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
|
|
|
|
|
|
|
pBufferTexture = pFilteredBuffer->m_pTexture;
|
|
|
|
ogl.getRender().copyTexturedRect(0, (GLint)(srcY0*srcScaleY), Xwidth, min((GLint)(srcY1*srcScaleY), (GLint)pFilteredBuffer->m_pTexture->realHeight),
|
|
|
|
pBufferTexture->realWidth, pBufferTexture->realHeight, pBufferTexture->glName,
|
|
|
|
hOffset, vOffset + (GLint)(dstY0*dstScaleY), hOffset + X1, vOffset + (GLint)(dstY1*dstScaleY),
|
|
|
|
ogl.getScreenWidth(), ogl.getScreenHeight() + ogl.getHeightOffset(), filter);
|
2013-09-29 15:02:50 +00:00
|
|
|
}
|
|
|
|
}
|
2014-09-26 12:19:23 +00:00
|
|
|
|
2014-03-21 09:38:39 +00:00
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
|
2016-07-09 19:07:03 +00:00
|
|
|
if (m_pCurrent != nullptr) {
|
2015-03-11 11:34:39 +00:00
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_pCurrent->m_FBO);
|
2016-07-09 19:07:03 +00:00
|
|
|
#ifdef VC
|
|
|
|
const GLenum discards[] = {GL_DEPTH_ATTACHMENT};
|
|
|
|
glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discards);
|
|
|
|
#endif
|
|
|
|
}
|
2014-09-21 12:15:22 +00:00
|
|
|
ogl.swapBuffers();
|
2014-06-09 04:26:43 +00:00
|
|
|
gDP.changed |= CHANGED_SCISSOR;
|
2013-06-01 13:13:04 +00:00
|
|
|
}
|
2015-11-23 12:36:03 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
void FrameBuffer_ActivateBufferTexture(u32 t, FrameBuffer *pBuffer)
|
2013-09-05 16:24:34 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pBuffer == nullptr)
|
2014-10-18 11:56:19 +00:00
|
|
|
return;
|
2015-02-09 12:27:39 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
CachedTexture *pTexture = pBuffer->getTexture(t);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pTexture == nullptr)
|
2016-05-08 09:58:19 +00:00
|
|
|
return;
|
2013-09-05 16:24:34 +00:00
|
|
|
|
2014-10-03 16:27:05 +00:00
|
|
|
// frameBufferList().renderBuffer(pBuffer->m_startAddress);
|
2015-02-09 12:27:39 +00:00
|
|
|
textureCache().activateTexture(t, pTexture);
|
2014-04-27 12:26:12 +00:00
|
|
|
gDP.changed |= CHANGED_FB_TEXTURE;
|
2013-09-05 16:24:34 +00:00
|
|
|
}
|
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
void FrameBuffer_ActivateBufferTextureBG(u32 t, FrameBuffer *pBuffer )
|
2013-09-05 16:24:34 +00:00
|
|
|
{
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pBuffer == nullptr)
|
2015-02-09 12:27:39 +00:00
|
|
|
return;
|
2013-09-05 16:24:34 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
CachedTexture *pTexture = pBuffer->getTextureBG(t);
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pTexture == nullptr)
|
2016-05-08 09:58:19 +00:00
|
|
|
return;
|
2013-09-05 16:24:34 +00:00
|
|
|
|
2016-05-08 09:58:19 +00:00
|
|
|
// frameBufferList().renderBuffer(pBuffer->m_startAddress);
|
2015-02-09 12:27:39 +00:00
|
|
|
textureCache().activateTexture(t, pTexture);
|
2014-04-27 12:26:12 +00:00
|
|
|
gDP.changed |= CHANGED_FB_TEXTURE;
|
2013-09-05 16:24:34 +00:00
|
|
|
}
|
2013-08-10 11:12:17 +00:00
|
|
|
|
2015-10-31 03:11:33 +00:00
|
|
|
void FrameBuffer_CopyToRDRAM(u32 _address, bool _sync)
|
2013-06-09 11:55:21 +00:00
|
|
|
{
|
2016-05-28 15:37:20 +00:00
|
|
|
ColorBufferToRDRAM::get().copyToRDRAM(_address, _sync);
|
2013-06-09 11:55:21 +00:00
|
|
|
}
|
2013-09-07 16:31:04 +00:00
|
|
|
|
2015-11-23 13:03:33 +00:00
|
|
|
void FrameBuffer_CopyChunkToRDRAM(u32 _address)
|
|
|
|
{
|
2016-05-28 15:37:20 +00:00
|
|
|
ColorBufferToRDRAM::get().copyChunkToRDRAM(_address);
|
2015-11-23 13:03:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool FrameBuffer_CopyDepthBuffer( u32 address )
|
|
|
|
{
|
2014-03-21 08:16:36 +00:00
|
|
|
#ifndef GLES2
|
2015-09-27 04:10:05 +00:00
|
|
|
FrameBuffer * pCopyBuffer = frameBufferList().getCopyBuffer();
|
2016-06-10 06:06:06 +00:00
|
|
|
if (pCopyBuffer != nullptr) {
|
2015-09-27 04:10:05 +00:00
|
|
|
// This code is mainly to emulate Zelda MM camera.
|
2016-05-28 15:37:20 +00:00
|
|
|
ColorBufferToRDRAM::get().copyToRDRAM(pCopyBuffer->m_startAddress, true);
|
2015-09-27 04:10:05 +00:00
|
|
|
pCopyBuffer->m_RdramCopy.resize(0); // To disable validity check by RDRAM content. CPU may change content of the buffer for some unknown reason.
|
2016-06-10 06:06:06 +00:00
|
|
|
frameBufferList().setCopyBuffer(nullptr);
|
2015-09-27 04:10:05 +00:00
|
|
|
return true;
|
|
|
|
} else
|
2016-05-28 15:37:20 +00:00
|
|
|
return DepthBufferToRDRAM::get().copyToRDRAM(address);
|
2015-11-23 13:03:33 +00:00
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FrameBuffer_CopyDepthBufferChunk(u32 address)
|
|
|
|
{
|
|
|
|
#ifndef GLES2
|
2016-05-28 15:37:20 +00:00
|
|
|
return DepthBufferToRDRAM::get().copyChunkToRDRAM(address);
|
2015-04-23 11:25:21 +00:00
|
|
|
#else
|
|
|
|
return false;
|
2014-03-21 08:16:36 +00:00
|
|
|
#endif
|
2013-11-12 08:41:19 +00:00
|
|
|
}
|
|
|
|
|
2016-02-03 15:17:53 +00:00
|
|
|
void FrameBuffer_CopyFromRDRAM(u32 _address, bool _bCFB)
|
2013-09-07 16:31:04 +00:00
|
|
|
{
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().copyFromRDRAM(_address, _bCFB);
|
2013-09-07 16:31:04 +00:00
|
|
|
}
|
2016-02-02 18:52:29 +00:00
|
|
|
|
2016-02-03 15:17:53 +00:00
|
|
|
void FrameBuffer_AddAddress(u32 address, u32 _size)
|
2016-02-02 18:52:29 +00:00
|
|
|
{
|
2016-05-28 15:37:20 +00:00
|
|
|
RDRAMtoColorBuffer::get().addAddress(address, _size);
|
2016-02-02 18:52:29 +00:00
|
|
|
}
|