MGislv/GLideN64
1
0
Fork 0
mirror of https://github.com/blawar/GLideN64.git synced 2024-07-07 03:13:49 +00:00
Code Issues Projects Releases Wiki Activity

Add CachedUseProgram

Browse Source
This commit is contained in:
Sergey Lipskiy 2017-01-15 20:02:04 +07:00
parent c5e2575722
commit fe5175cee5
11 changed files with 127 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilder.cpp
View File

@ -1877,7 +1877,7 @@ graphics::CombinerProgram * CombinerProgramBuilder::buildCombinerProgram(Combine
UniformGroups uniforms;
m_uniformFactory->buildUniforms(program, combinerInputs, _key, uniforms);
return new CombinerProgramImpl(_key, program, combinerInputs, std::move(uniforms));
return new CombinerProgramImpl(_key, program, m_useProgram, combinerInputs, std::move(uniforms));
}
const ShaderPart * CombinerProgramBuilder::getVertexShaderHeader() const
@ -1911,7 +1911,7 @@ GLuint _createVertexShader(ShaderPart * _header, ShaderPart * _body)
return shader_object;
}
CombinerProgramBuilder::CombinerProgramBuilder(const opengl::GLInfo & _glinfo)
CombinerProgramBuilder::CombinerProgramBuilder(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram)
: m_blender1(new ShaderBlender1(_glinfo))
, m_blender2(new ShaderBlender2(_glinfo))
, m_legacyBlender(new ShaderLegacyBlender)
@ -1955,6 +1955,7 @@ CombinerProgramBuilder::CombinerProgramBuilder(const opengl::GLInfo & _glinfo)
, m_shaderReadtex(new ShaderReadtex(_glinfo))
, m_shaderN64DepthCompare(new ShaderN64DepthCompare(_glinfo))
, m_shaderN64DepthRender(new ShaderN64DepthRender(_glinfo))
, m_useProgram(_useProgram)
{
m_vertexShaderRect = _createVertexShader(m_vertexHeader.get(), m_vertexRect.get());
m_vertexShaderTriangle = _createVertexShader(m_vertexHeader.get(), m_vertexTriangle.get());

7
src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramBuilder.h
View File

@ -7,6 +7,10 @@ namespace graphics {
class CombinerProgram;
}
namespace opengl {
class CachedUseProgram;
}
namespace glsl {
class ShaderPart;
@ -15,7 +19,7 @@ namespace glsl {
class CombinerProgramBuilder
{
public:
CombinerProgramBuilder(const opengl::GLInfo & _glinfo);
CombinerProgramBuilder(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram);
~CombinerProgramBuilder();
graphics::CombinerProgram * buildCombinerProgram(Combiner & _color, Combiner & _alpha, const CombinerKey & _key);
@ -83,6 +87,7 @@ namespace glsl {
GLuint m_vertexShaderTriangle;
GLuint m_vertexShaderTexturedRect;
GLuint m_vertexShaderTexturedTriangle;
opengl::CachedUseProgram * m_useProgram;
};
}

13
src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramImpl.cpp
View File

@ -1,6 +1,7 @@
#include <fstream>
#include <assert.h>
#include <Combiner.h>
#include <Graphics/OpenGLContext/opengl_CachedFunctions.h>
#include "glsl_Utils.h"
#include "glsl_CombinerProgramImpl.h"
@ -8,11 +9,13 @@ using namespace glsl;
CombinerProgramImpl::CombinerProgramImpl(const CombinerKey & _key,
GLuint _program,
opengl::CachedUseProgram * _useProgram,
const CombinerInputs & _inputs,
UniformGroups && _uniforms)
: m_bNeedUpdate(true)
, m_key(_key)
, m_program(_program)
, m_useProgram(_useProgram)
, m_inputs(_inputs)
, m_uniforms(std::move(_uniforms))
{
@ -21,18 +24,20 @@ CombinerProgramImpl::CombinerProgramImpl(const CombinerKey & _key,
CombinerProgramImpl::~CombinerProgramImpl()
{
m_useProgram->useProgram(graphics::ObjectHandle());
glDeleteProgram(GLuint(m_program));
}
void CombinerProgramImpl::activate()
{
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
}
void CombinerProgramImpl::update(bool _force)
{
_force |= m_bNeedUpdate;
m_bNeedUpdate = false;
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
for (auto it = m_uniforms.begin(); it != m_uniforms.end(); ++it)
(*it)->update(_force);
}
@ -70,7 +75,7 @@ bool CombinerProgramImpl::usesHwLighting() const
bool CombinerProgramImpl::getBinaryForm(std::vector<char> & _buffer)
{
GLint binaryLength;
glGetProgramiv(m_program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
glGetProgramiv(GLuint(m_program), GL_PROGRAM_BINARY_LENGTH, &binaryLength);
if (binaryLength < 1)
return false;
@ -81,7 +86,7 @@ bool CombinerProgramImpl::getBinaryForm(std::vector<char> & _buffer)
return false;
GLenum binaryFormat;
glGetProgramBinary(m_program, binaryLength, &binaryLength, &binaryFormat, binary.data());
glGetProgramBinary(GLuint(m_program), binaryLength, &binaryLength, &binaryFormat, binary.data());
if (isGLError())
return false;

9
src/Graphics/OpenGLContext/GLSL/glsl_CombinerProgramImpl.h
View File

@ -2,8 +2,13 @@
#include <memory>
#include <vector>
#include <Graphics/CombinerProgram.h>
#include <Graphics/ObjectHandle.h>
#include "glsl_CombinerInputs.h"
namespace opengl {
class CachedUseProgram;
}
namespace glsl {
class UniformGroup {
@ -19,6 +24,7 @@ namespace glsl {
public:
CombinerProgramImpl(const CombinerKey & _key,
GLuint _program,
opengl::CachedUseProgram * _useProgram,
const CombinerInputs & _inputs,
UniformGroups && _uniforms);
~CombinerProgramImpl();
@ -38,7 +44,8 @@ namespace glsl {
private:
bool m_bNeedUpdate;
CombinerKey m_key;
GLuint m_program;
graphics::ObjectHandle m_program;
opengl::CachedUseProgram * m_useProgram;
CombinerInputs m_inputs;
UniformGroups m_uniforms;
};

11
src/Graphics/OpenGLContext/GLSL/glsl_ShaderStorage.cpp
View File

@ -129,7 +129,9 @@ bool ShaderStorage::saveShadersStorage(const graphics::Combiners & _combiners) c
}
static
CombinerProgramImpl * _readCominerProgramFromStream(std::istream & _is, CombinerProgramUniformFactory & _uniformFactory)
CombinerProgramImpl * _readCominerProgramFromStream(std::istream & _is,
CombinerProgramUniformFactory & _uniformFactory,
opengl::CachedUseProgram * _useProgram)
{
CombinerKey cmbKey;
cmbKey.read(_is);
@ -154,7 +156,7 @@ CombinerProgramImpl * _readCominerProgramFromStream(std::istream & _is, Combiner
UniformGroups uniforms;
_uniformFactory.buildUniforms(program, cmbInputs, cmbKey, uniforms);
return new CombinerProgramImpl(cmbKey, program, cmbInputs, std::move(uniforms));
return new CombinerProgramImpl(cmbKey, program, _useProgram, cmbInputs, std::move(uniforms));
}
bool ShaderStorage::loadShadersStorage(graphics::Combiners & _combiners)
@ -203,7 +205,7 @@ bool ShaderStorage::loadShadersStorage(graphics::Combiners & _combiners)
fin.read((char*)&len, sizeof(len));
for (u32 i = 0; i < len; ++i) {
CombinerProgramImpl * pCombiner = _readCominerProgramFromStream(fin, uniformFactory);
CombinerProgramImpl * pCombiner = _readCominerProgramFromStream(fin, uniformFactory, m_useProgram);
pCombiner->update(true);
_combiners[pCombiner->getKey()] = pCombiner;
}
@ -218,7 +220,8 @@ bool ShaderStorage::loadShadersStorage(graphics::Combiners & _combiners)
}
ShaderStorage::ShaderStorage(const opengl::GLInfo & _glinfo)
ShaderStorage::ShaderStorage(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram)
: m_glinfo(_glinfo)
, m_useProgram(_useProgram)
{
}

7
src/Graphics/OpenGLContext/GLSL/glsl_ShaderStorage.h
View File

@ -1,12 +1,16 @@
#pragma once
#include <Graphics/OpenGLContext/opengl_GLInfo.h>
namespace opengl {
class CachedUseProgram;
}
namespace glsl {
class ShaderStorage
{
public:
ShaderStorage(const opengl::GLInfo & _glinfo);
ShaderStorage(const opengl::GLInfo & _glinfo, opengl::CachedUseProgram * _useProgram);
bool saveShadersStorage(const graphics::Combiners & _combiners) const;
@ -14,6 +18,7 @@ namespace glsl {
private:
const opengl::GLInfo & m_glinfo;
opengl::CachedUseProgram * m_useProgram;
};
}

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

@ -5,6 +5,8 @@
#include <ZlutTexture.h>
#include <gDP.h>
#include <Config.h>
#include <Graphics/ObjectHandle.h>
#include <Graphics/OpenGLContext/opengl_CachedFunctions.h>
#include "glsl_SpecialShadersFactory.h"
#include "glsl_ShaderPart.h"
#include "glsl_Utils.h"
@ -365,9 +367,11 @@ namespace glsl {
{
public:
SpecialShader(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: m_program(0)
, m_useProgram(_useProgram)
{
VertexBody vertexBody(_glinfo);
FragmentBody fragmentBody(_glinfo);
@ -380,23 +384,24 @@ namespace glsl {
_fragmentHeader->write(ssFragmentShader);
fragmentBody.write(ssFragmentShader);
m_program = Utils::createRectShaderProgram(ssVertexShader.str().data(), ssFragmentShader.str().data());
m_program =
graphics::ObjectHandle(Utils::createRectShaderProgram(ssVertexShader.str().data(), ssFragmentShader.str().data()));
}
~SpecialShader()
{
glUseProgram(0);
glDeleteProgram(m_program);
m_program = 0;
m_useProgram->useProgram(graphics::ObjectHandle());
glDeleteProgram(GLuint(m_program));
}
void SpecialShader::activate() override {
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
gDP.changed |= CHANGED_COMBINE;
}
protected:
GLuint m_program;
graphics::ObjectHandle m_program;
opengl::CachedUseProgram * m_useProgram;
};
/*---------------ShadowMapShader-------------*/
@ -407,14 +412,15 @@ namespace glsl {
{
public:
ShadowMapShader(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: ShadowMapShaderBase(_glinfo, _vertexHeader, _fragmentHeader)
: ShadowMapShaderBase(_glinfo, _useProgram, _vertexHeader, _fragmentHeader)
, m_loc(-1)
{
glUseProgram(m_program);
m_loc = glGetUniformLocation(m_program, "uFogColor");
glUseProgram(0);
m_useProgram->useProgram(m_program);
m_loc = glGetUniformLocation(GLuint(m_program), "uFogColor");
m_useProgram->useProgram(graphics::ObjectHandle());
}
void activate() override {
@ -436,14 +442,15 @@ namespace glsl {
{
public:
MonochromeShader(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: MonochromeShaderBase(_glinfo, _vertexHeader, _fragmentHeader)
: MonochromeShaderBase(_glinfo, _useProgram, _vertexHeader, _fragmentHeader)
{
glUseProgram(m_program);
const int texLoc = glGetUniformLocation(m_program, "uColorImage");
m_useProgram->useProgram(m_program);
const int texLoc = glGetUniformLocation(GLuint(m_program), "uColorImage");
glUniform1i(texLoc, 0);
glUseProgram(0);
m_useProgram->useProgram(graphics::ObjectHandle());
}
};
@ -453,9 +460,11 @@ namespace glsl {
{
public:
TexrectDrawerShaderDraw(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: m_program(0)
, m_useProgram(_useProgram)
{
VertexShaderTexturedRect vertexBody(_glinfo);
std::stringstream ssVertexShader;
@ -476,55 +485,56 @@ namespace glsl {
TexrectDrawerFragmentDraw fragmentMain(_glinfo);
fragmentMain.write(ssFragmentShader);
m_program = Utils::createRectShaderProgram(ssVertexShader.str().data(), ssFragmentShader.str().data());
m_program =
graphics::ObjectHandle(Utils::createRectShaderProgram(ssVertexShader.str().data(), ssFragmentShader.str().data()));
glUseProgram(m_program);
GLint loc = glGetUniformLocation(m_program, "uTex0");
m_useProgram->useProgram(m_program);
GLint loc = glGetUniformLocation(GLuint(m_program), "uTex0");
assert(loc >= 0);
glUniform1i(loc, 0);
m_textureSizeLoc = glGetUniformLocation(m_program, "uTextureSize");
m_textureBoundsLoc = glGetUniformLocation(m_program, "uTextureBounds");
m_textureSizeLoc = glGetUniformLocation(GLuint(m_program), "uTextureSize");
m_textureBoundsLoc = glGetUniformLocation(GLuint(m_program), "uTextureBounds");
assert(m_textureBoundsLoc >= 0);
m_enableAlphaTestLoc = glGetUniformLocation(m_program, "uEnableAlphaTest");
glUseProgram(0);
m_enableAlphaTestLoc = glGetUniformLocation(GLuint(m_program), "uEnableAlphaTest");
m_useProgram->useProgram(graphics::ObjectHandle());
}
~TexrectDrawerShaderDraw()
{
glUseProgram(0);
glDeleteProgram(m_program);
m_program = 0;
m_useProgram->useProgram(graphics::ObjectHandle());
glDeleteProgram(GLuint(m_program));
}
void TexrectDrawerShaderDraw::activate() override
{
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
gDP.changed |= CHANGED_COMBINE;
}
void setTextureSize(u32 _width, u32 _height) override
{
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
glUniform2f(m_textureSizeLoc, (GLfloat)_width, (GLfloat)_height);
gDP.changed |= CHANGED_COMBINE;
}
void setTextureBounds(float _texBounds[4]) override
{
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
glUniform4fv(m_textureBoundsLoc, 1, _texBounds);
gDP.changed |= CHANGED_COMBINE;
}
void setEnableAlphaTest(int _enable) override
{
glUseProgram(m_program);
m_useProgram->useProgram(m_program);
glUniform1i(m_enableAlphaTestLoc, _enable);
gDP.changed |= CHANGED_COMBINE;
}
protected:
GLuint m_program;
graphics::ObjectHandle m_program;
opengl::CachedUseProgram * m_useProgram;
GLint m_enableAlphaTestLoc;
GLint m_textureSizeLoc;
GLint m_textureBoundsLoc;
@ -540,14 +550,15 @@ namespace glsl {
{
public:
TexrectCopyShader(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: TexrectCopyShaderBase(_glinfo, _vertexHeader, _fragmentHeader)
: TexrectCopyShaderBase(_glinfo, _useProgram, _vertexHeader, _fragmentHeader)
{
glUseProgram(m_program);
const int texLoc = glGetUniformLocation(m_program, "uTex0");
m_useProgram->useProgram(m_program);
const int texLoc = glGetUniformLocation(GLuint(m_program), "uTex0");
glUniform1i(texLoc, 0);
glUseProgram(0);
m_useProgram->useProgram(graphics::ObjectHandle());
}
};
@ -555,11 +566,13 @@ namespace glsl {
/*---------------SpecialShadersFactory-------------*/
SpecialShadersFactory::SpecialShadersFactory(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader)
: m_glinfo(_glinfo)
, m_vertexHeader(_vertexHeader)
, m_fragmentHeader(_fragmentHeader)
, m_useProgram(_useProgram)
{
}
@ -568,27 +581,27 @@ namespace glsl {
if (!m_glinfo.imageTextures)
return nullptr;
return new ShadowMapShader(m_glinfo, m_vertexHeader, m_fragmentHeader);
return new ShadowMapShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::ShaderProgram * SpecialShadersFactory::createMonochromeShader() const
{
return new MonochromeShader(m_glinfo, m_vertexHeader, m_fragmentHeader);
return new MonochromeShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::TexDrawerShaderProgram * SpecialShadersFactory::createTexDrawerDrawShader() const
{
return new TexrectDrawerShaderDraw(m_glinfo, m_vertexHeader, m_fragmentHeader);
return new TexrectDrawerShaderDraw(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::ShaderProgram * SpecialShadersFactory::createTexDrawerClearShader() const
{
return new TexrectDrawerShaderClear(m_glinfo, m_vertexHeader, m_fragmentHeader);
return new TexrectDrawerShaderClear(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
graphics::ShaderProgram * SpecialShadersFactory::createTexrectCopyShader() const
{
return new TexrectCopyShader(m_glinfo, m_vertexHeader, m_fragmentHeader);
return new TexrectCopyShader(m_glinfo, m_useProgram, m_vertexHeader, m_fragmentHeader);
}
}

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

@ -5,6 +5,10 @@ namespace graphics {
class ShaderProgram;
}
namespace opengl {
class CachedUseProgram;
}
namespace glsl {
class ShaderPart;
@ -13,6 +17,7 @@ namespace glsl {
{
public:
SpecialShadersFactory(const opengl::GLInfo & _glinfo,
opengl::CachedUseProgram * _useProgram,
const ShaderPart * _vertexHeader,
const ShaderPart * _fragmentHeader);
@ -30,6 +35,7 @@ namespace glsl {
const opengl::GLInfo & m_glinfo;
const ShaderPart * m_vertexHeader;
const ShaderPart * m_fragmentHeader;
opengl::CachedUseProgram * m_useProgram;
};
}

15
src/Graphics/OpenGLContext/opengl_CachedFunctions.cpp
View File

@ -125,6 +125,14 @@ void CachedVertexAttribArray::reset()
m_attribs.fill(Parameter());
}
/*---------------CachedUseProgram-------------*/
void CachedUseProgram::useProgram(graphics::ObjectHandle _program)
{
if (update(_program))
glUseProgram(GLuint(_program));
}
/*---------------CachedFunctions-------------*/
CachedFunctions::CachedFunctions(const GLInfo & _glinfo)
@ -160,6 +168,7 @@ void CachedFunctions::reset()
m_blendColor.reset();
m_clearColor.reset();
m_attribArray.reset();
m_useProgram.reset();
}
CachedEnable * CachedFunctions::getCachedEnable(Parameter _parameter)
@ -240,8 +249,12 @@ CachedClearColor * CachedFunctions::getCachedClearColor()
return &m_clearColor;
}
CachedVertexAttribArray * CachedFunctions::getCachedVertexAttribArray()
{
return &m_attribArray;
}
CachedUseProgram * CachedFunctions::getCachedUseProgram()
{
return &m_useProgram;
}

9
src/Graphics/OpenGLContext/opengl_CachedFunctions.h
View File

@ -195,6 +195,12 @@ namespace opengl {
std::array<graphics::Parameter, MaxAttribIndex> m_attribs;
};
class CachedUseProgram : public Cached1<graphics::ObjectHandle>
{
public:
void useProgram(graphics::ObjectHandle _program);
};
/*---------------CachedFunctions-------------*/
class CachedFunctions
@ -235,6 +241,8 @@ namespace opengl {
CachedVertexAttribArray * getCachedVertexAttribArray();
CachedUseProgram * getCachedUseProgram();
private:
typedef std::unordered_map<u32, CachedEnable> EnableParameters;
@ -253,6 +261,7 @@ namespace opengl {
CachedBlendColor m_blendColor;
CachedClearColor m_clearColor;
CachedVertexAttribArray m_attribArray;
CachedUseProgram m_useProgram;
};
}

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

@ -52,7 +52,7 @@ void ContextImpl::init()
m_textDrawer.reset(new DummyTextDrawer);
}
m_combinerProgramBuilder.reset(new glsl::CombinerProgramBuilder(m_glInfo));
m_combinerProgramBuilder.reset(new glsl::CombinerProgramBuilder(m_glInfo, m_cachedFunctions->getCachedUseProgram()));
}
void ContextImpl::destroy()
@ -231,19 +231,20 @@ graphics::CombinerProgram * ContextImpl::createCombinerProgram(Combiner & _color
bool ContextImpl::saveShadersStorage(const graphics::Combiners & _combiners)
{
glsl::ShaderStorage storage(m_glInfo);
glsl::ShaderStorage storage(m_glInfo, m_cachedFunctions->getCachedUseProgram());
return storage.saveShadersStorage(_combiners);
}
bool ContextImpl::loadShadersStorage(graphics::Combiners & _combiners)
{
glsl::ShaderStorage storage(m_glInfo);
glsl::ShaderStorage storage(m_glInfo, m_cachedFunctions->getCachedUseProgram());
return storage.loadShadersStorage(_combiners);
}
graphics::ShaderProgram * ContextImpl::createDepthFogShader()
{
glsl::SpecialShadersFactory shadersFactory(m_glInfo,
m_cachedFunctions->getCachedUseProgram(),
m_combinerProgramBuilder->getVertexShaderHeader(),
m_combinerProgramBuilder->getFragmentShaderHeader());
@ -253,6 +254,7 @@ graphics::ShaderProgram * ContextImpl::createDepthFogShader()
graphics::ShaderProgram * ContextImpl::createMonochromeShader()
{
glsl::SpecialShadersFactory shadersFactory(m_glInfo,
m_cachedFunctions->getCachedUseProgram(),
m_combinerProgramBuilder->getVertexShaderHeader(),
m_combinerProgramBuilder->getFragmentShaderHeader());
@ -262,6 +264,7 @@ graphics::ShaderProgram * ContextImpl::createMonochromeShader()
graphics::TexDrawerShaderProgram * ContextImpl::createTexDrawerDrawShader()
{
glsl::SpecialShadersFactory shadersFactory(m_glInfo,
m_cachedFunctions->getCachedUseProgram(),
m_combinerProgramBuilder->getVertexShaderHeader(),
m_combinerProgramBuilder->getFragmentShaderHeader());
@ -271,6 +274,7 @@ graphics::TexDrawerShaderProgram * ContextImpl::createTexDrawerDrawShader()
graphics::ShaderProgram * ContextImpl::createTexDrawerClearShader()
{
glsl::SpecialShadersFactory shadersFactory(m_glInfo,
m_cachedFunctions->getCachedUseProgram(),
m_combinerProgramBuilder->getVertexShaderHeader(),
m_combinerProgramBuilder->getFragmentShaderHeader());
@ -280,6 +284,7 @@ graphics::ShaderProgram * ContextImpl::createTexDrawerClearShader()
graphics::ShaderProgram * ContextImpl::createTexrectCopyShader()
{
glsl::SpecialShadersFactory shadersFactory(m_glInfo,
m_cachedFunctions->getCachedUseProgram(),
m_combinerProgramBuilder->getVertexShaderHeader(),
m_combinerProgramBuilder->getFragmentShaderHeader());