mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-02-02 17:54:05 +00:00
93f9f23576
glBlitFramebuffer depends on scissior test and color mask. It isn't documented well, but it does. So we have to reset the apistate before using it. In this way, there isn't any benefit of glBlitFramebuffer, glDrawArray would be better :-(
482 lines
14 KiB
C++
482 lines
14 KiB
C++
// Copyright 2013 Dolphin Emulator Project
|
|
// Licensed under GPLv2
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "Globals.h"
|
|
#include "FramebufferManager.h"
|
|
#include "VertexShaderGen.h"
|
|
|
|
#include "TextureConverter.h"
|
|
#include "Render.h"
|
|
#include "HW/Memmap.h"
|
|
|
|
namespace OGL
|
|
{
|
|
|
|
int FramebufferManager::m_targetWidth;
|
|
int FramebufferManager::m_targetHeight;
|
|
int FramebufferManager::m_msaaSamples;
|
|
int FramebufferManager::m_msaaCoverageSamples;
|
|
|
|
GLuint FramebufferManager::m_efbFramebuffer;
|
|
GLuint FramebufferManager::m_efbColor; // Renderbuffer in MSAA mode; Texture otherwise
|
|
GLuint FramebufferManager::m_efbDepth; // Renderbuffer in MSAA mode; Texture otherwise
|
|
|
|
// Only used in MSAA mode.
|
|
GLuint FramebufferManager::m_resolvedFramebuffer;
|
|
GLuint FramebufferManager::m_resolvedColorTexture;
|
|
GLuint FramebufferManager::m_resolvedDepthTexture;
|
|
|
|
GLuint FramebufferManager::m_xfbFramebuffer;
|
|
|
|
// reinterpret pixel format
|
|
GLuint FramebufferManager::m_pixel_format_vao;
|
|
GLuint FramebufferManager::m_pixel_format_vbo;
|
|
SHADER FramebufferManager::m_pixel_format_shaders[2];
|
|
|
|
|
|
FramebufferManager::FramebufferManager(int targetWidth, int targetHeight, int msaaSamples, int msaaCoverageSamples)
|
|
{
|
|
m_efbFramebuffer = 0;
|
|
m_efbColor = 0;
|
|
m_efbDepth = 0;
|
|
m_resolvedFramebuffer = 0;
|
|
m_resolvedColorTexture = 0;
|
|
m_resolvedDepthTexture = 0;
|
|
m_xfbFramebuffer = 0;
|
|
|
|
m_targetWidth = targetWidth;
|
|
m_targetHeight = targetHeight;
|
|
|
|
m_msaaSamples = msaaSamples;
|
|
m_msaaCoverageSamples = msaaCoverageSamples;
|
|
|
|
// The EFB can be set to different pixel formats by the game through the
|
|
// BPMEM_ZCOMPARE register (which should probably have a different name).
|
|
// They are:
|
|
// - 24-bit RGB (8-bit components) with 24-bit Z
|
|
// - 24-bit RGBA (6-bit components) with 24-bit Z
|
|
// - Multisampled 16-bit RGB (5-6-5 format) with 16-bit Z
|
|
// We only use one EFB format here: 32-bit ARGB with 24-bit Z.
|
|
// Multisampling depends on user settings.
|
|
// The distinction becomes important for certain operations, i.e. the
|
|
// alpha channel should be ignored if the EFB does not have one.
|
|
|
|
// Create EFB target.
|
|
|
|
glGenFramebuffers(1, &m_efbFramebuffer);
|
|
glActiveTexture(GL_TEXTURE0 + 9);
|
|
|
|
if (m_msaaSamples <= 1)
|
|
{
|
|
// EFB targets will be textures in non-MSAA mode.
|
|
|
|
GLuint glObj[3];
|
|
glGenTextures(3, glObj);
|
|
m_efbColor = glObj[0];
|
|
m_efbDepth = glObj[1];
|
|
m_resolvedColorTexture = glObj[2]; // needed for pixel format convertion
|
|
|
|
glBindTexture(getFbType(), m_efbColor);
|
|
glTexParameteri(getFbType(), GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(getFbType(), 0, GL_RGBA8, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
glBindTexture(getFbType(), m_efbDepth);
|
|
glTexParameteri(getFbType(), GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(getFbType(), 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
|
|
|
|
glBindTexture(getFbType(), m_resolvedColorTexture);
|
|
glTexParameteri(getFbType(), GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(getFbType(), 0, GL_RGBA8, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
// Bind target textures to the EFB framebuffer.
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, getFbType(), m_efbColor, 0);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, getFbType(), m_efbDepth, 0);
|
|
|
|
GL_REPORT_FBO_ERROR();
|
|
}
|
|
#ifndef USE_GLES3
|
|
else
|
|
{
|
|
// EFB targets will be renderbuffers in MSAA mode (required by OpenGL).
|
|
// Resolve targets will be created to transfer EFB to RAM textures.
|
|
// XFB framebuffer will be created to transfer EFB to XFB texture.
|
|
|
|
// Create EFB target renderbuffers.
|
|
|
|
GLuint glObj[2];
|
|
glGenRenderbuffers(2, glObj);
|
|
m_efbColor = glObj[0];
|
|
m_efbDepth = glObj[1];
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, m_efbColor);
|
|
if (m_msaaCoverageSamples)
|
|
glRenderbufferStorageMultisampleCoverageNV(GL_RENDERBUFFER, m_msaaCoverageSamples, m_msaaSamples, GL_RGBA8, m_targetWidth, m_targetHeight);
|
|
else
|
|
glRenderbufferStorageMultisample(GL_RENDERBUFFER, m_msaaSamples, GL_RGBA8, m_targetWidth, m_targetHeight);
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, m_efbDepth);
|
|
if (m_msaaCoverageSamples)
|
|
glRenderbufferStorageMultisampleCoverageNV(GL_RENDERBUFFER, m_msaaCoverageSamples, m_msaaSamples, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight);
|
|
else
|
|
glRenderbufferStorageMultisample(GL_RENDERBUFFER, m_msaaSamples, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight);
|
|
|
|
glBindRenderbuffer(GL_RENDERBUFFER, 0);
|
|
|
|
// Bind target renderbuffers to EFB framebuffer.
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer);
|
|
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_efbColor);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_efbDepth);
|
|
|
|
GL_REPORT_FBO_ERROR();
|
|
|
|
// Create resolved targets for transferring multisampled EFB to texture.
|
|
|
|
glGenFramebuffers(1, &m_resolvedFramebuffer);
|
|
|
|
glGenTextures(2, glObj);
|
|
m_resolvedColorTexture = glObj[0];
|
|
m_resolvedDepthTexture = glObj[1];
|
|
|
|
glBindTexture(getFbType(), m_resolvedColorTexture);
|
|
glTexParameteri(getFbType(), GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(getFbType(), 0, GL_RGBA8, m_targetWidth, m_targetHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
glBindTexture(getFbType(), m_resolvedDepthTexture);
|
|
glTexParameteri(getFbType(), GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(getFbType(), 0, GL_DEPTH_COMPONENT24, m_targetWidth, m_targetHeight, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
// Bind resolved textures to resolved framebuffer.
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_resolvedFramebuffer);
|
|
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, getFbType(), m_resolvedColorTexture, 0);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, getFbType(), m_resolvedDepthTexture, 0);
|
|
|
|
GL_REPORT_FBO_ERROR();
|
|
|
|
// Return to EFB framebuffer.
|
|
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer);
|
|
}
|
|
#endif
|
|
// Create XFB framebuffer; targets will be created elsewhere.
|
|
|
|
glGenFramebuffers(1, &m_xfbFramebuffer);
|
|
|
|
// EFB framebuffer is currently bound, make sure to clear its alpha value to 1.f
|
|
glViewport(0, 0, m_targetWidth, m_targetHeight);
|
|
glScissor(0, 0, m_targetWidth, m_targetHeight);
|
|
glClearColor(0.f, 0.f, 0.f, 1.f);
|
|
glClearDepthf(1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
|
|
// reinterpret pixel format
|
|
glGenBuffers(1, &m_pixel_format_vbo);
|
|
glGenVertexArrays(1, &m_pixel_format_vao);
|
|
glBindVertexArray(m_pixel_format_vao);
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_pixel_format_vbo);
|
|
glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
|
|
glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_FLOAT, 0, sizeof(GLfloat)*2, NULL);
|
|
|
|
float vertices[] = {
|
|
-1.0, -1.0,
|
|
1.0, -1.0,
|
|
-1.0, 1.0,
|
|
1.0, 1.0,
|
|
};
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
|
|
|
|
char vs[] =
|
|
"ATTRIN vec2 rawpos;\n"
|
|
"void main(void) {\n"
|
|
" gl_Position = vec4(rawpos,0,1);\n"
|
|
"}\n";
|
|
|
|
char ps_rgba6_to_rgb8[] =
|
|
"uniform sampler2DRect samp9;\n"
|
|
"COLOROUT(ocol0)\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" ivec4 src6 = ivec4(round(texture2DRect(samp9, gl_FragCoord.xy) * 63.f));\n"
|
|
" ivec4 dst8;\n"
|
|
" dst8.r = (src6.r << 2) | (src6.g >> 4);\n"
|
|
" dst8.g = ((src6.g & 0xF) << 4) | (src6.b >> 2);\n"
|
|
" dst8.b = ((src6.b & 0x3) << 6) | src6.a;\n"
|
|
" dst8.a = 255;\n"
|
|
" ocol0 = float4(dst8) / 255.f;\n"
|
|
"}";
|
|
|
|
char ps_rgb8_to_rgba6[] =
|
|
"uniform sampler2DRect samp9;\n"
|
|
"COLOROUT(ocol0)\n"
|
|
"void main()\n"
|
|
"{\n"
|
|
" ivec4 src8 = ivec4(round(texture2DRect(samp9, gl_FragCoord.xy) * 255.f));\n"
|
|
" ivec4 dst6;\n"
|
|
" dst6.r = src8.r >> 2;\n"
|
|
" dst6.g = ((src8.r & 0x3) << 4) | (src8.g >> 4);\n"
|
|
" dst6.b = ((src8.g & 0xF) << 2) | (src8.b >> 6);\n"
|
|
" dst6.a = src8.b & 0x3F;\n"
|
|
" ocol0 = float4(dst6) / 63.f;\n"
|
|
"}";
|
|
|
|
if(g_ogl_config.eSupportedGLSLVersion != GLSL_120)
|
|
{
|
|
// HACK: This shaders aren't glsl120 compatible as glsl120 don't support bit operations
|
|
// it could be workaround by floor + frac + tons off additions, but I think it isn't worth
|
|
ProgramShaderCache::CompileShader(m_pixel_format_shaders[0], vs, ps_rgb8_to_rgba6);
|
|
ProgramShaderCache::CompileShader(m_pixel_format_shaders[1], vs, ps_rgba6_to_rgb8);
|
|
}
|
|
|
|
}
|
|
|
|
FramebufferManager::~FramebufferManager()
|
|
{
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
GLuint glObj[3];
|
|
|
|
// Note: OpenGL deletion functions silently ignore parameters of "0".
|
|
|
|
glObj[0] = m_efbFramebuffer;
|
|
glObj[1] = m_resolvedFramebuffer;
|
|
glObj[2] = m_xfbFramebuffer;
|
|
glDeleteFramebuffers(3, glObj);
|
|
m_efbFramebuffer = 0;
|
|
m_xfbFramebuffer = 0;
|
|
|
|
glObj[0] = m_resolvedColorTexture;
|
|
glObj[1] = m_resolvedDepthTexture;
|
|
glDeleteTextures(2, glObj);
|
|
m_resolvedColorTexture = 0;
|
|
m_resolvedDepthTexture = 0;
|
|
|
|
glObj[0] = m_efbColor;
|
|
glObj[1] = m_efbDepth;
|
|
if (m_msaaSamples <= 1)
|
|
glDeleteTextures(2, glObj);
|
|
else
|
|
glDeleteRenderbuffers(2, glObj);
|
|
m_efbColor = 0;
|
|
m_efbDepth = 0;
|
|
|
|
// reinterpret pixel format
|
|
glDeleteVertexArrays(1, &m_pixel_format_vao);
|
|
glDeleteBuffers(1, &m_pixel_format_vbo);
|
|
m_pixel_format_shaders[0].Destroy();
|
|
m_pixel_format_shaders[1].Destroy();
|
|
}
|
|
|
|
GLuint FramebufferManager::GetEFBColorTexture(const EFBRectangle& sourceRc)
|
|
{
|
|
if (m_msaaSamples <= 1)
|
|
{
|
|
return m_efbColor;
|
|
}
|
|
else
|
|
{
|
|
// Transfer the EFB to a resolved texture. EXT_framebuffer_blit is
|
|
// required.
|
|
|
|
TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
|
|
targetRc.ClampLL(0, 0, m_targetWidth, m_targetHeight);
|
|
|
|
// Resolve.
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer);
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer);
|
|
glBlitFramebuffer(
|
|
targetRc.left, targetRc.top, targetRc.right, targetRc.bottom,
|
|
targetRc.left, targetRc.top, targetRc.right, targetRc.bottom,
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST
|
|
);
|
|
|
|
// Return to EFB.
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer);
|
|
|
|
return m_resolvedColorTexture;
|
|
}
|
|
}
|
|
|
|
GLuint FramebufferManager::GetEFBDepthTexture(const EFBRectangle& sourceRc)
|
|
{
|
|
if (m_msaaSamples <= 1)
|
|
{
|
|
return m_efbDepth;
|
|
}
|
|
else
|
|
{
|
|
// Transfer the EFB to a resolved texture. EXT_framebuffer_blit is
|
|
// required.
|
|
|
|
TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
|
|
targetRc.ClampLL(0, 0, m_targetWidth, m_targetHeight);
|
|
|
|
// Resolve.
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer);
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer);
|
|
glBlitFramebuffer(
|
|
targetRc.left, targetRc.top, targetRc.right, targetRc.bottom,
|
|
targetRc.left, targetRc.top, targetRc.right, targetRc.bottom,
|
|
GL_DEPTH_BUFFER_BIT, GL_NEAREST
|
|
);
|
|
|
|
// Return to EFB.
|
|
glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer);
|
|
|
|
return m_resolvedDepthTexture;
|
|
}
|
|
}
|
|
|
|
void FramebufferManager::CopyToRealXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc,float Gamma)
|
|
{
|
|
u8* xfb_in_ram = Memory::GetPointer(xfbAddr);
|
|
if (!xfb_in_ram)
|
|
{
|
|
WARN_LOG(VIDEO, "Tried to copy to invalid XFB address");
|
|
return;
|
|
}
|
|
|
|
TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
|
|
TextureConverter::EncodeToRamYUYV(ResolveAndGetRenderTarget(sourceRc), targetRc, xfb_in_ram, fbWidth, fbHeight);
|
|
}
|
|
|
|
void FramebufferManager::SetFramebuffer(GLuint fb)
|
|
{
|
|
glBindFramebuffer(GL_FRAMEBUFFER, fb != 0 ? fb : GetEFBFramebuffer());
|
|
}
|
|
|
|
// Apply AA if enabled
|
|
GLuint FramebufferManager::ResolveAndGetRenderTarget(const EFBRectangle &source_rect)
|
|
{
|
|
return GetEFBColorTexture(source_rect);
|
|
}
|
|
|
|
GLuint FramebufferManager::ResolveAndGetDepthTarget(const EFBRectangle &source_rect)
|
|
{
|
|
return GetEFBDepthTexture(source_rect);
|
|
}
|
|
|
|
void FramebufferManager::ReinterpretPixelData(unsigned int convtype)
|
|
{
|
|
if(g_ogl_config.eSupportedGLSLVersion == GLSL_120) {
|
|
// This feature isn't supported by glsl120
|
|
return;
|
|
}
|
|
|
|
g_renderer->ResetAPIState();
|
|
|
|
GLuint src_texture = 0;
|
|
|
|
if(m_msaaSamples > 1)
|
|
{
|
|
// MSAA mode, so resolve first
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer);
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer);
|
|
glBlitFramebuffer(
|
|
0, 0, m_targetWidth, m_targetHeight,
|
|
0, 0, m_targetWidth, m_targetHeight,
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST
|
|
);
|
|
|
|
// Return to EFB.
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_efbFramebuffer);
|
|
|
|
src_texture = m_resolvedColorTexture;
|
|
}
|
|
else
|
|
{
|
|
// non-MSAA mode, so switch textures
|
|
src_texture = m_efbColor;
|
|
m_efbColor = m_resolvedColorTexture;
|
|
m_resolvedColorTexture = src_texture;
|
|
|
|
// also switch them on fbo
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, getFbType(), m_efbColor, 0);
|
|
}
|
|
glViewport(0,0, m_targetWidth, m_targetHeight);
|
|
glActiveTexture(GL_TEXTURE0 + 9);
|
|
glBindTexture(getFbType(), src_texture);
|
|
|
|
m_pixel_format_shaders[convtype ? 1 : 0].Bind();
|
|
glBindVertexArray(m_pixel_format_vao);
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
|
|
|
g_renderer->RestoreAPIState();
|
|
}
|
|
|
|
XFBSource::~XFBSource()
|
|
{
|
|
glDeleteTextures(1, &texture);
|
|
}
|
|
|
|
|
|
void XFBSource::Draw(const MathUtil::Rectangle<float> &sourcerc,
|
|
const MathUtil::Rectangle<float> &drawrc, int width, int height) const
|
|
{
|
|
// Texture map xfbSource->texture onto the main buffer
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
|
|
glBlitFramebuffer(sourcerc.left, sourcerc.bottom, sourcerc.right, sourcerc.top,
|
|
drawrc.left, drawrc.bottom, drawrc.right, drawrc.top,
|
|
GL_COLOR_BUFFER_BIT, GL_LINEAR);
|
|
|
|
GL_REPORT_ERRORD();
|
|
}
|
|
|
|
void XFBSource::DecodeToTexture(u32 xfbAddr, u32 fbWidth, u32 fbHeight)
|
|
{
|
|
TextureConverter::DecodeToTexture(xfbAddr, fbWidth, fbHeight, texture);
|
|
}
|
|
|
|
void XFBSource::CopyEFB(float Gamma)
|
|
{
|
|
g_renderer->ResetAPIState();
|
|
|
|
// Copy EFB data to XFB and restore render target again
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferManager::GetEFBFramebuffer());
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferManager::GetXFBFramebuffer());
|
|
|
|
// Bind texture.
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
|
|
GL_REPORT_FBO_ERROR();
|
|
|
|
glBlitFramebuffer(
|
|
0, 0, texWidth, texHeight,
|
|
0, 0, texWidth, texHeight,
|
|
GL_COLOR_BUFFER_BIT, GL_NEAREST
|
|
);
|
|
|
|
// Return to EFB.
|
|
FramebufferManager::SetFramebuffer(0);
|
|
|
|
g_renderer->RestoreAPIState();
|
|
|
|
}
|
|
|
|
XFBSourceBase* FramebufferManager::CreateXFBSource(unsigned int target_width, unsigned int target_height)
|
|
{
|
|
GLuint texture;
|
|
|
|
glGenTextures(1, &texture);
|
|
|
|
glActiveTexture(GL_TEXTURE0 + 9);
|
|
glBindTexture(GL_TEXTURE_2D, texture);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, target_width, target_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
|
|
return new XFBSource(texture);
|
|
}
|
|
|
|
void FramebufferManager::GetTargetSize(unsigned int *width, unsigned int *height, const EFBRectangle& sourceRc)
|
|
{
|
|
*width = m_targetWidth;
|
|
*height = m_targetHeight;
|
|
}
|
|
|
|
} // namespace OGL
|