MGislv/GLideN64
1
0
Fork 0
mirror of https://github.com/blawar/GLideN64.git synced 2024-06-25 05:49:34 +00:00
Code Issues Projects Releases Wiki Activity

Code cleaup: remove unused MonochromeCombiner.

Browse Source
This commit is contained in:
Sergey Lipskiy 2017-09-24 18:51:02 +07:00
parent 7ba58fe5b6
commit 1266ced083
9 changed files with 0 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/Combiner.cpp
View File

@ -111,14 +111,12 @@ void CombinerInfo::init()
}
m_shadowmapProgram.reset(gfxContext.createDepthFogShader());
m_monochromeProgram.reset(gfxContext.createMonochromeShader());
m_texrectCopyProgram.reset(gfxContext.createTexrectCopyShader());
}
void CombinerInfo::destroy()
{
m_shadowmapProgram.reset();
m_monochromeProgram.reset();
m_texrectCopyProgram.reset();
m_pCurrent = nullptr;
@ -317,14 +315,6 @@ void CombinerInfo::setDepthFogCombiner()
}
}
void CombinerInfo::setMonochromeCombiner()
{
if (m_monochromeProgram) {
m_monochromeProgram->activate();
m_pCurrent = m_monochromeProgram.get();
}
}
ShaderProgram * CombinerInfo::getTexrectCopyProgram()
{
return m_texrectCopyProgram.get();

2
src/Combiner.h
View File

@ -126,7 +126,6 @@ public:
void updateParameters();
void setDepthFogCombiner();
void setMonochromeCombiner();
graphics::ShaderProgram * getTexrectCopyProgram();
graphics::CombinerProgram * getCurrent() const { return m_pCurrent; }
@ -164,7 +163,6 @@ private:
graphics::Combiners m_combiners;
std::unique_ptr<graphics::ShaderProgram> m_shadowmapProgram;
std::unique_ptr<graphics::ShaderProgram> m_monochromeProgram;
std::unique_ptr<graphics::ShaderProgram> m_texrectCopyProgram;
};

5
src/Graphics/Context.cpp
View File

@ -219,11 +219,6 @@ ShaderProgram * Context::createDepthFogShader()
return m_impl->createDepthFogShader();
}
ShaderProgram * Context::createMonochromeShader()
{
return m_impl->createMonochromeShader();
}
TexrectDrawerShaderProgram * Context::createTexrectDrawerDrawShader()
{
return m_impl->createTexrectDrawerDrawShader();

2
src/Graphics/Context.h
View File

@ -208,8 +208,6 @@ namespace graphics {
ShaderProgram * createDepthFogShader();
ShaderProgram * createMonochromeShader();
TexrectDrawerShaderProgram * createTexrectDrawerDrawShader();
ShaderProgram * createTexrectDrawerClearShader();

1
src/Graphics/ContextImpl.h
View File

@ -49,7 +49,6 @@ namespace graphics {
virtual bool saveShadersStorage(const Combiners & _combiners) = 0;
virtual bool loadShadersStorage(Combiners & _combiners) = 0;
virtual ShaderProgram * createDepthFogShader() = 0;
virtual ShaderProgram * createMonochromeShader() = 0;
virtual TexrectDrawerShaderProgram * createTexrectDrawerDrawShader() = 0;
virtual ShaderProgram * createTexrectDrawerClearShader() = 0;
virtual ShaderProgram * createTexrectCopyShader() = 0;

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

@ -84,66 +84,6 @@ namespace glsl {
}
};
/*---------------MonochromeShaderPart-------------*/
class MonochromeFragmentShader : public ShaderPart
{
public:
MonochromeFragmentShader(const opengl::GLInfo & _glinfo)
{
if (_glinfo.isGLES2) {
m_part =
"uniform sampler2D uColorImage; \n"
"uniform mediump vec2 uScreenSize; \n"
"void main() \n"
"{ \n"
" mediump vec2 coord = gl_FragCoord.xy/uScreenSize; \n"
" lowp vec4 tex = texture2D(uColorImage, coord); \n"
" lowp float c = dot(vec4(0.2126, 0.7152, 0.0722, 0.0), tex); \n"
" gl_FragColor = vec4(c, c, c, 1.0); \n"
"} \n"
;
} else {
if (config.video.multisampling > 0) {
m_part =
"uniform lowp sampler2DMS uColorImage; \n"
"uniform lowp int uMSAASamples; \n"
"OUT lowp vec4 fragColor; \n"
"lowp vec4 sampleMS() \n"
"{ \n"
" mediump ivec2 coord = ivec2(gl_FragCoord.xy); \n"
" lowp vec4 texel = vec4(0.0); \n"
" for (int i = 0; i < uMSAASamples; ++i) \n"
" texel += texelFetch(uColorImage, coord, i); \n"
" return texel / float(uMSAASamples); \n"
"} \n"
" \n"
"void main() \n"
"{ \n"
" lowp vec4 tex = sampleMS(); \n"
//" lowp float c = (tex.r + tex.g + tex.b) / 3.0f; \n"
" lowp float c = dot(vec4(0.2126, 0.7152, 0.0722, 0.0), tex);\n"
" fragColor = vec4(c, c, c, 1.0); \n"
"} \n"
;
} else {
m_part =
"uniform sampler2D uColorImage; \n"
"OUT lowp vec4 fragColor; \n"
"void main() \n"
"{ \n"
" mediump ivec2 coord = ivec2(gl_FragCoord.xy); \n"
" lowp vec4 tex = texelFetch(uColorImage, coord, 0); \n"
//" lowp float c = (tex.r + tex.g + tex.b) / 3.0f; \n"
" lowp float c = dot(vec4(0.2126, 0.7152, 0.0722, 0.0), tex);\n"
" fragColor = vec4(c, c, c, 1.0); \n"
"} \n"
;
}
}
}
};
/*---------------TexrectDrawerShaderPart-------------*/
class TexrectDrawerTex3PointFilter : public ShaderPart
@ -510,31 +450,6 @@ namespace glsl {
int m_loc;
};
/*---------------MonochromeShader-------------*/
typedef SpecialShader<VertexShaderRectNocolor, MonochromeFragmentShader> MonochromeShaderBase;
class MonochromeShader : public MonochromeShaderBase
{
public:
MonochromeShader(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: MonochromeShaderBase(_glinfo, _useProgram, _vertexHeader, _fragmentHeader)
{
m_useProgram->useProgram(m_program);
const int texLoc = glGetUniformLocation(GLuint(m_program), "uColorImage");
if (config.video.multisampling > 0) {
glUniform1i(texLoc, u32(graphics::textureIndices::MSTex[0]));
const int samplesLoc = glGetUniformLocation(GLuint(m_program), "uMSAASamples");
glUniform1i(samplesLoc, config.video.multisampling);
} else
glUniform1i(texLoc, u32(graphics::textureIndices::Tex[0]));
m_useProgram->useProgram(graphics::ObjectHandle::null);
}
};
/*---------------TexrectDrawerShader-------------*/
class TexrectDrawerShaderDraw : public graphics::TexrectDrawerShaderProgram
@ -745,11 +660,6 @@ namespace glsl {
return new ShadowMapShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::ShaderProgram * SpecialShadersFactory::createMonochromeShader() const
{
return new MonochromeShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::TexrectDrawerShaderProgram * SpecialShadersFactory::createTexrectDrawerDrawShader() const
{
return new TexrectDrawerShaderDraw(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);

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

@ -24,8 +24,6 @@ namespace glsl {
graphics::ShaderProgram * createShadowMapShader() const;
graphics::ShaderProgram * createMonochromeShader() const;
graphics::TexrectDrawerShaderProgram * createTexrectDrawerDrawShader() const;
graphics::ShaderProgram * createTexrectDrawerClearShader() const;

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

@ -341,11 +341,6 @@ graphics::ShaderProgram * ContextImpl::createDepthFogShader()
return m_specialShadersFactory->createShadowMapShader();
}
graphics::ShaderProgram * ContextImpl::createMonochromeShader()
{
return m_specialShadersFactory->createMonochromeShader();
}
graphics::TexrectDrawerShaderProgram * ContextImpl::createTexrectDrawerDrawShader()
{
return m_specialShadersFactory->createTexrectDrawerDrawShader();

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

@ -106,8 +106,6 @@ namespace opengl {
graphics::ShaderProgram * createDepthFogShader() override;
graphics::ShaderProgram * createMonochromeShader() override;
graphics::TexrectDrawerShaderProgram * createTexrectDrawerDrawShader() override;
graphics::ShaderProgram * createTexrectDrawerClearShader() override;