MGislv/GLideN64
1
0
Fork 0
mirror of https://github.com/blawar/GLideN64.git synced 2024-06-24 21:39:35 +00:00
Code Issues Projects Releases Wiki Activity

Don't use glGetTexLevelParameteriv to determine texture size

Browse Source
This commit is contained in:
fzurita 2019-11-28 20:18:34 -05:00 committed by Sergey Lipskiy
parent a2fbea9086
commit b31e510932
15 changed files with 84 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Combiner.cpp
View File

@ -315,12 +315,12 @@ void CombinerInfo::setDepthFogCombiner()
}
}
ShaderProgram * CombinerInfo::getTexrectCopyProgram()
TexrectCopyShaderProgram * CombinerInfo::getTexrectCopyProgram()
{
return m_texrectCopyProgram.get();
}
ShaderProgram * CombinerInfo::getTexrectColorAndDepthCopyProgram()
TexrectCopyShaderProgram * CombinerInfo::getTexrectColorAndDepthCopyProgram()
{
return m_texrectColorAndDepthCopyProgram.get();
}

8
src/Combiner.h
View File

@ -126,8 +126,8 @@ public:
void updateParameters();
void setDepthFogCombiner();
graphics::ShaderProgram * getTexrectCopyProgram();
graphics::ShaderProgram * getTexrectColorAndDepthCopyProgram();
graphics::TexrectCopyShaderProgram * getTexrectCopyProgram();
graphics::TexrectCopyShaderProgram * getTexrectColorAndDepthCopyProgram();
graphics::CombinerProgram * getCurrent() const { return m_pCurrent; }
bool isChanged() const {return m_bChanged;}
@ -159,8 +159,8 @@ private:
graphics::Combiners m_combiners;
std::unique_ptr<graphics::ShaderProgram> m_shadowmapProgram;
std::unique_ptr<graphics::ShaderProgram> m_texrectCopyProgram;
std::unique_ptr<graphics::ShaderProgram> m_texrectColorAndDepthCopyProgram;
std::unique_ptr<graphics::TexrectCopyShaderProgram> m_texrectCopyProgram;
std::unique_ptr<graphics::TexrectCopyShaderProgram> m_texrectColorAndDepthCopyProgram;
};
inline

10
src/Graphics/Context.cpp
View File

@ -278,27 +278,27 @@ ShaderProgram * Context::createTexrectDrawerClearShader()
return m_impl->createTexrectDrawerClearShader();
}
ShaderProgram * Context::createTexrectCopyShader()
TexrectCopyShaderProgram * Context::createTexrectCopyShader()
{
return m_impl->createTexrectCopyShader();
}
ShaderProgram * Context::createTexrectColorAndDepthCopyShader()
TexrectCopyShaderProgram * Context::createTexrectColorAndDepthCopyShader()
{
return m_impl->createTexrectColorAndDepthCopyShader();
}
ShaderProgram * Context::createGammaCorrectionShader()
TexrectCopyShaderProgram * Context::createGammaCorrectionShader()
{
return m_impl->createGammaCorrectionShader();
}
ShaderProgram * Context::createOrientationCorrectionShader()
TexrectCopyShaderProgram * Context::createOrientationCorrectionShader()
{
return m_impl->createOrientationCorrectionShader();
}
ShaderProgram * Context::createFXAAShader()
TexrectCopyShaderProgram * Context::createFXAAShader()
{
return m_impl->createFXAAShader();
}

10
src/Graphics/Context.h
View File

@ -232,15 +232,15 @@ namespace graphics {
ShaderProgram * createTexrectDrawerClearShader();
ShaderProgram * createTexrectCopyShader();
TexrectCopyShaderProgram * createTexrectCopyShader();
ShaderProgram * createTexrectColorAndDepthCopyShader();
TexrectCopyShaderProgram * createTexrectColorAndDepthCopyShader();
ShaderProgram * createGammaCorrectionShader();
TexrectCopyShaderProgram * createGammaCorrectionShader();
ShaderProgram * createOrientationCorrectionShader();
TexrectCopyShaderProgram * createOrientationCorrectionShader();
ShaderProgram * createFXAAShader();
TexrectCopyShaderProgram * createFXAAShader();
TextDrawerShaderProgram * createTextDrawerShader();

10
src/Graphics/ContextImpl.h
View File

@ -57,11 +57,11 @@ namespace graphics {
virtual ShaderProgram * createDepthFogShader() = 0;
virtual TexrectDrawerShaderProgram * createTexrectDrawerDrawShader() = 0;
virtual ShaderProgram * createTexrectDrawerClearShader() = 0;
virtual ShaderProgram * createTexrectCopyShader() = 0;
virtual ShaderProgram * createTexrectColorAndDepthCopyShader() = 0;
virtual ShaderProgram * createGammaCorrectionShader() = 0;
virtual ShaderProgram * createOrientationCorrectionShader() = 0;
virtual ShaderProgram * createFXAAShader() = 0;
virtual TexrectCopyShaderProgram * createTexrectCopyShader() = 0;
virtual TexrectCopyShaderProgram * createTexrectColorAndDepthCopyShader() = 0;
virtual TexrectCopyShaderProgram * createGammaCorrectionShader() = 0;
virtual TexrectCopyShaderProgram * createOrientationCorrectionShader() = 0;
virtual TexrectCopyShaderProgram * createFXAAShader() = 0;
virtual TextDrawerShaderProgram * createTextDrawerShader() = 0;
virtual void resetShaderProgram() = 0;
virtual void drawTriangles(const Context::DrawTriangleParameters & _params) = 0;

55
src/Graphics/OpenGLContext/GLSL/glsl_SpecialShadersFactory.cpp
View File

@ -640,7 +640,7 @@ namespace glsl {
/*---------------FXAAShader-------------*/
typedef SpecialShader<FXAAVertexShader, FXAAFragmentShader> FXAAShaderBase;
typedef SpecialShader<FXAAVertexShader, FXAAFragmentShader, graphics::TexrectCopyShaderProgram> FXAAShaderBase;
class FXAAShader : public FXAAShaderBase
{
@ -657,6 +657,11 @@ namespace glsl {
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
void setTextureSize(u32 _width, u32 _height) override
{
}
void activate() override {
FXAAShaderBase::activate();
FrameBuffer * pBuffer = frameBufferList().findBuffer(*REG.VI_ORIGIN);
@ -767,7 +772,9 @@ namespace glsl {
/*---------------TexrectCopyShader-------------*/
typedef SpecialShader<VertexShaderTexturedRect, TexrectCopy> TexrectCopyShaderBase;
typedef SpecialShader<VertexShaderTexturedRect,
TexrectCopy,
graphics::TexrectCopyShaderProgram> TexrectCopyShaderBase;
class TexrectCopyShader : public TexrectCopyShaderBase
{
@ -786,15 +793,11 @@ namespace glsl {
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
void activate() override
void setTextureSize(u32 _width, u32 _height) override
{
TexrectCopyShaderBase::activate();
if (m_textureSizeLoc < 0)
return;
GLint texWidth, texHeight;
glGetTexLevelParameteriv(0, 0, GL_TEXTURE_WIDTH, &texWidth);
glGetTexLevelParameteriv(0, 0, GL_TEXTURE_HEIGHT, &texHeight);
glUniform2i(m_textureSizeLoc, texWidth, texHeight);
glUniform2i(m_textureSizeLoc, (GLint)_width, (GLint)_height);
}
private:
@ -803,7 +806,9 @@ namespace glsl {
/*---------------TexrectColorAndDepthCopyShader-------------*/
typedef SpecialShader<VertexShaderTexturedRect, TexrectColorAndDepthCopy> TexrectColorAndDepthCopyShaderBase;
typedef SpecialShader<VertexShaderTexturedRect,
TexrectColorAndDepthCopy,
graphics::TexrectCopyShaderProgram> TexrectColorAndDepthCopyShaderBase;
class TexrectColorAndDepthCopyShader : public TexrectColorAndDepthCopyShaderBase
{
@ -824,15 +829,11 @@ namespace glsl {
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
void activate() override
void setTextureSize(u32 _width, u32 _height) override
{
TexrectColorAndDepthCopyShaderBase::activate();
if (m_textureSizeLoc < 0)
return;
GLint texWidth, texHeight;
glGetTexLevelParameteriv(0, 0, GL_TEXTURE_WIDTH, &texWidth);
glGetTexLevelParameteriv(0, 0, GL_TEXTURE_HEIGHT, &texHeight);
glUniform2i(m_textureSizeLoc, texWidth, texHeight);
glUniform2i(m_textureSizeLoc, (GLint)_width, (GLint)_height);
}
private:
@ -841,7 +842,7 @@ namespace glsl {
/*---------------PostProcessorShader-------------*/
typedef SpecialShader<VertexShaderTexturedRect, GammaCorrection> GammaCorrectionShaderBase;
typedef SpecialShader<VertexShaderTexturedRect, GammaCorrection, graphics::TexrectCopyShaderProgram> GammaCorrectionShaderBase;
class GammaCorrectionShader : public GammaCorrectionShaderBase
{
@ -862,9 +863,14 @@ namespace glsl {
glUniform1f(levelLoc, gammaLevel);
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
void setTextureSize(u32 _width, u32 _height) override
{
}
};
typedef SpecialShader<VertexShaderTexturedRect, OrientationCorrection> OrientationCorrectionShaderBase;
typedef SpecialShader<VertexShaderTexturedRect, OrientationCorrection, graphics::TexrectCopyShaderProgram> OrientationCorrectionShaderBase;
class OrientationCorrectionShader : public OrientationCorrectionShaderBase
{
@ -881,6 +887,11 @@ namespace glsl {
glUniform1i(texLoc, 0);
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
void setTextureSize(u32 _width, u32 _height) override
{
}
};
/*---------------TexrectDrawerShader-------------*/
@ -948,12 +959,12 @@ namespace glsl {
return new TexrectDrawerShaderClear(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::ShaderProgram * SpecialShadersFactory::createTexrectCopyShader() const
graphics::TexrectCopyShaderProgram * SpecialShadersFactory::createTexrectCopyShader() const
{
return new TexrectCopyShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader, m_fragmentEnd);
}
graphics::ShaderProgram * SpecialShadersFactory::createTexrectColorAndDepthCopyShader() const
graphics::TexrectCopyShaderProgram * SpecialShadersFactory::createTexrectColorAndDepthCopyShader() const
{
if (m_glinfo.isGLES2)
return nullptr;
@ -961,17 +972,17 @@ namespace glsl {
return new TexrectColorAndDepthCopyShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader, m_fragmentEnd);
}
graphics::ShaderProgram * SpecialShadersFactory::createGammaCorrectionShader() const
graphics::TexrectCopyShaderProgram * SpecialShadersFactory::createGammaCorrectionShader() const
{
return new GammaCorrectionShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader, m_fragmentEnd);
}
graphics::ShaderProgram * SpecialShadersFactory::createOrientationCorrectionShader() const
graphics::TexrectCopyShaderProgram * SpecialShadersFactory::createOrientationCorrectionShader() const
{
return new OrientationCorrectionShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader, m_fragmentEnd);
}
graphics::ShaderProgram * SpecialShadersFactory::createFXAAShader() const
graphics::TexrectCopyShaderProgram * SpecialShadersFactory::createFXAAShader() const
{
return new FXAAShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader, m_fragmentEnd);
}

10
src/Graphics/OpenGLContext/GLSL/glsl_SpecialShadersFactory.h
View File

@ -28,15 +28,15 @@ namespace glsl {
graphics::ShaderProgram * createTexrectDrawerClearShader() const;
graphics::ShaderProgram * createTexrectCopyShader() const;
graphics::TexrectCopyShaderProgram * createTexrectCopyShader() const;
graphics::ShaderProgram * createTexrectColorAndDepthCopyShader() const;
graphics::TexrectCopyShaderProgram * createTexrectColorAndDepthCopyShader() const;
graphics::ShaderProgram * createGammaCorrectionShader() const;
graphics::TexrectCopyShaderProgram * createGammaCorrectionShader() const;
graphics::ShaderProgram * createOrientationCorrectionShader() const;
graphics::TexrectCopyShaderProgram * createOrientationCorrectionShader() const;
graphics::ShaderProgram * createFXAAShader() const;
graphics::TexrectCopyShaderProgram * createFXAAShader() const;
graphics::TextDrawerShaderProgram * createTextDrawerShader() const;

1
src/Graphics/OpenGLContext/opengl_BufferManipulationObjectFactory.cpp
View File

@ -92,6 +92,7 @@ public:
GLenum(_params.textureTarget),
GLuint(_params.textureHandle));
} else {
//FRAMEBUFFER
glFramebufferTexture2D(GLenum(_params.bufferTarget),
GLenum(_params.attachment),
GLenum(_params.textureTarget),

10
src/Graphics/OpenGLContext/opengl_ContextImpl.cpp
View File

@ -418,27 +418,27 @@ graphics::ShaderProgram * ContextImpl::createTexrectDrawerClearShader()
return m_specialShadersFactory->createTexrectDrawerClearShader();
}
graphics::ShaderProgram * ContextImpl::createTexrectCopyShader()
graphics::TexrectCopyShaderProgram * ContextImpl::createTexrectCopyShader()
{
return m_specialShadersFactory->createTexrectCopyShader();
}
graphics::ShaderProgram * ContextImpl::createTexrectColorAndDepthCopyShader()
graphics::TexrectCopyShaderProgram * ContextImpl::createTexrectColorAndDepthCopyShader()
{
return m_specialShadersFactory->createTexrectColorAndDepthCopyShader();
}
graphics::ShaderProgram * ContextImpl::createGammaCorrectionShader()
graphics::TexrectCopyShaderProgram * ContextImpl::createGammaCorrectionShader()
{
return m_specialShadersFactory->createGammaCorrectionShader();
}
graphics::ShaderProgram * ContextImpl::createOrientationCorrectionShader()
graphics::TexrectCopyShaderProgram * ContextImpl::createOrientationCorrectionShader()
{
return m_specialShadersFactory->createOrientationCorrectionShader();
}
graphics::ShaderProgram * ContextImpl::createFXAAShader()
graphics::TexrectCopyShaderProgram * ContextImpl::createFXAAShader()
{
return m_specialShadersFactory->createFXAAShader();
}

10
src/Graphics/OpenGLContext/opengl_ContextImpl.h
View File

@ -122,15 +122,15 @@ namespace opengl {
graphics::ShaderProgram * createTexrectDrawerClearShader() override;
graphics::ShaderProgram * createTexrectCopyShader() override;
graphics::TexrectCopyShaderProgram * createTexrectCopyShader() override;
graphics::ShaderProgram * createTexrectColorAndDepthCopyShader() override;
graphics::TexrectCopyShaderProgram * createTexrectColorAndDepthCopyShader() override;
graphics::ShaderProgram * createGammaCorrectionShader() override;
graphics::TexrectCopyShaderProgram * createGammaCorrectionShader() override;
graphics::ShaderProgram * createOrientationCorrectionShader() override;
graphics::TexrectCopyShaderProgram * createOrientationCorrectionShader() override;
graphics::ShaderProgram * createFXAAShader() override;
graphics::TexrectCopyShaderProgram * createFXAAShader() override;
graphics::TextDrawerShaderProgram * createTextDrawerShader() override;

6
src/Graphics/ShaderProgram.h
View File

@ -26,6 +26,12 @@ namespace graphics {
virtual void setEnableAlphaTest(int _enable) = 0;
};
class TexrectCopyShaderProgram : public ShaderProgram
{
public:
virtual void setTextureSize(u32 _width, u32 _height) = 0;
};
class TextDrawerShaderProgram : public ShaderProgram
{
public:

1
src/GraphicsDrawer.cpp
View File

@ -1681,6 +1681,7 @@ void GraphicsDrawer::copyTexturedRect(const CopyRectParams & _params)
rectParams.vertices = m_rect;
rectParams.combiner = _params.combiner;
_params.combiner->activate();
_params.combiner->setTextureSize(_params.srcWidth, _params.srcHeight);
gfxContext.enable(enable::SCISSOR_TEST, false);
gfxContext.drawRects(rectParams);
gfxContext.enable(enable::SCISSOR_TEST, true);

2
src/GraphicsDrawer.h
View File

@ -100,7 +100,7 @@ public:
bool invertY = false;
typedef std::array<CachedTexture *, 2> Textures;
Textures tex = Textures{ { nullptr, nullptr } };
graphics::CombinerProgram * combiner = nullptr;
graphics::TexrectCopyShaderProgram * combiner = nullptr;
graphics::TextureParam filter;
};

2
src/PostProcessor.cpp
View File

@ -120,7 +120,7 @@ void PostProcessor::_postDraw()
gfxContext.resetShaderProgram();
}
FrameBuffer * PostProcessor::_doPostProcessing(FrameBuffer * _pBuffer, graphics::ShaderProgram * _pShader)
FrameBuffer * PostProcessor::_doPostProcessing(FrameBuffer * _pBuffer, graphics::TexrectCopyShaderProgram * _pShader)
{
_preDraw(_pBuffer);

9
src/PostProcessor.h
View File

@ -10,6 +10,7 @@
namespace graphics {
class ShaderProgram;
class TexrectCopyShaderProgram;
}
struct FrameBuffer;
@ -36,11 +37,11 @@ private:
void _createResultBuffer(const FrameBuffer * _pMainBuffer);
void _preDraw(FrameBuffer * _pBuffer);
void _postDraw();
FrameBuffer * _doPostProcessing(FrameBuffer * _pBuffer, graphics::ShaderProgram * _pShader);
FrameBuffer * _doPostProcessing(FrameBuffer * _pBuffer, graphics::TexrectCopyShaderProgram * _pShader);
std::unique_ptr<graphics::ShaderProgram> m_gammaCorrectionProgram;
std::unique_ptr<graphics::ShaderProgram> m_orientationCorrectionProgram;
std::unique_ptr<graphics::ShaderProgram> m_FXAAProgram;
std::unique_ptr<graphics::TexrectCopyShaderProgram> m_gammaCorrectionProgram;
std::unique_ptr<graphics::TexrectCopyShaderProgram> m_orientationCorrectionProgram;
std::unique_ptr<graphics::TexrectCopyShaderProgram> m_FXAAProgram;
std::unique_ptr<FrameBuffer> m_pResultBuffer;
CachedTexture * m_pTextureOriginal;
PostprocessingList m_postprocessingList;