void CPageCurlFX::InitEffect(QObject* parent)
{
CEffect::InitEffect(parent);
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, parent);
// Flip y coordinate for input texture (render to texture with framebuffer)
const char* vsrc =
"attribute highp vec4 vertex;\n"
"varying mediump vec2 texc;\n"
"void main(void)\n"
"{\n"
" gl_Position = vec4(vertex.xy, 0.0, 1.0);\n"
" texc.x = 0.5 * (1.0 + vertex.x);\n"
" texc.y = 0.5 * (1.0 + vertex.y);\n"
"}\n";
vshader->compileSourceCode(vsrc);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, parent);
QFile frag(":/CMainWindow/page-curl.frag");
frag.open(QIODevice::ReadOnly | QIODevice::Text);
fshader->compileSourceCode(frag.readAll());
m_program.setParent(parent);
m_program.addShader(vshader);
m_program.addShader(fshader);
m_program.bindAttributeLocation("vertex", 0);
m_program.link();
m_vertexLoc = m_program.attributeLocation("vertex");
m_sourceTexLoc = m_program.uniformLocation("sourceTex");
m_targetTexLoc = m_program.uniformLocation("targetTex");
m_timeLoc = m_program.uniformLocation("time");
}
void CMoviePlayback::InitEffect(QObject* parent)
{
CEffect::InitEffect(parent);
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, parent);
vshader->compileSourceCode(BASIC_VERTEX_SHADER);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, parent);
const char *fsrc =
"varying mediump vec2 texc;\n"
"uniform sampler2D videoTex;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(videoTex, texc);\n"
"}\n";
fshader->compileSourceCode(fsrc);
m_program.setParent(parent);
m_program.addShader(vshader);
m_program.addShader(fshader);
m_program.bindAttributeLocation("vertex", 0);
m_program.link();
m_ffmpegLoc = m_program.uniformLocation("videoTex");
}
void QtRenderer::initialize()
{
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceCode(
"attribute highp vec4 vertex;"
"attribute mediump vec3 normal;"
"uniform mediump mat4 matrix;"
"uniform lowp vec4 sourceColor;"
"varying mediump vec4 color;"
"void main(void)"
"{"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));"
" float angle = max(dot(normal, toLight), 0.0);"
" vec3 col = sourceColor.rgb;"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);"
" color = clamp(color, 0.0, 1.0);"
" gl_Position = matrix * vertex;"
"}");
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceCode(
"varying mediump vec4 color;"
"void main(void)"
"{"
" gl_FragColor = color;"
"}");
m_program = new QOpenGLShaderProgram(this);
m_program->addShader(vshader);
m_program->addShader(fshader);
m_program->link();
m_program->bind();
vertexAttr = m_program->attributeLocation("vertex");
normalAttr = m_program->attributeLocation("normal");
matrixUniform = m_program->uniformLocation("matrix");
colorUniform = m_program->uniformLocation("sourceColor");
m_fAngle = 0;
createGeometry();
m_vbo.create();
m_vbo.bind();
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
m_vbo.allocate(verticesSize * 2);
m_vbo.write(0, vertices.constData(), verticesSize);
m_vbo.write(verticesSize, normals.constData(), verticesSize);
QOpenGLFunctions *f = m_context->functions();
f->glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
f->glFrontFace(GL_CW);
f->glCullFace(GL_FRONT);
f->glEnable(GL_CULL_FACE);
f->glEnable(GL_DEPTH_TEST);
m_program->enableAttributeArray(vertexAttr);
m_program->enableAttributeArray(normalAttr);
m_program->setAttributeBuffer(vertexAttr, GL_FLOAT, 0, 3);
m_program->setAttributeBuffer(normalAttr, GL_FLOAT, verticesSize, 3);
}
void Renderer::initialize()
{
// Threaded shader compilation can confuse some drivers. Avoid it.
QMutexLocker lock(initMutex());
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceCode(
"attribute highp vec4 vertex;"
"attribute mediump vec3 normal;"
"uniform mediump mat4 matrix;"
"uniform lowp vec4 sourceColor;"
"varying mediump vec4 color;"
"void main(void)"
"{"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));"
" float angle = max(dot(normal, toLight), 0.0);"
" vec3 col = sourceColor.rgb;"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);"
" color = clamp(color, 0.0, 1.0);"
" gl_Position = matrix * vertex;"
"}");
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceCode(
"varying mediump vec4 color;"
"void main(void)"
"{"
" gl_FragColor = color;"
"}");
m_program = new QOpenGLShaderProgram(this);
m_program->addShader(vshader);
m_program->addShader(fshader);
m_program->link();
m_program->bind();
vertexAttr = m_program->attributeLocation("vertex");
normalAttr = m_program->attributeLocation("normal");
matrixUniform = m_program->uniformLocation("matrix");
colorUniform = m_program->uniformLocation("sourceColor");
m_fAngle = 0;
createGeometry();
m_vbo.create();
m_vbo.bind();
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
m_vbo.allocate(verticesSize * 2);
m_vbo.write(0, vertices.constData(), verticesSize);
m_vbo.write(verticesSize, normals.constData(), verticesSize);
}
void QAndroidTextureVideoOutput::createGLResources()
{
Q_ASSERT(QOpenGLContext::currentContext() != NULL);
if (!m_glDeleter)
m_glDeleter.reset(new OpenGLResourcesDeleter);
if (m_surfaceTextureCanAttachToContext && !m_externalTex) {
m_surfaceTexture->detachFromGLContext();
glGenTextures(1, &m_externalTex);
m_surfaceTexture->attachToGLContext(m_externalTex);
}
if (!m_fbo || m_fbo->size() != m_nativeSize) {
delete m_fbo;
m_fbo = new QOpenGLFramebufferObject(m_nativeSize);
}
if (!m_program) {
m_program = new QOpenGLShaderProgram;
QOpenGLShader *vertexShader = new QOpenGLShader(QOpenGLShader::Vertex, m_program);
vertexShader->compileSourceCode("attribute highp vec4 vertexCoordsArray; \n" \
"attribute highp vec2 textureCoordArray; \n" \
"uniform highp mat4 texMatrix; \n" \
"varying highp vec2 textureCoords; \n" \
"void main(void) \n" \
"{ \n" \
" gl_Position = vertexCoordsArray; \n" \
" textureCoords = (texMatrix * vec4(textureCoordArray, 0.0, 1.0)).xy; \n" \
"}\n");
m_program->addShader(vertexShader);
QOpenGLShader *fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment, m_program);
fragmentShader->compileSourceCode("#extension GL_OES_EGL_image_external : require \n" \
"varying highp vec2 textureCoords; \n" \
"uniform samplerExternalOES frameTexture; \n" \
"void main() \n" \
"{ \n" \
" gl_FragColor = texture2D(frameTexture, textureCoords); \n" \
"}\n");
m_program->addShader(fragmentShader);
m_program->bindAttributeLocation("vertexCoordsArray", 0);
m_program->bindAttributeLocation("textureCoordArray", 1);
m_program->link();
}
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
makeObject();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
#define PROGRAM_VERTEX_ATTRIBUTE 0
#define PROGRAM_TEXCOORD_ATTRIBUTE 1
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
const char *vsrc =
"attribute highp vec4 vertex;\n"
"attribute mediump vec4 texCoord;\n"
"varying mediump vec4 texc;\n"
"uniform mediump mat4 matrix;\n"
"void main(void)\n"
"{\n"
" gl_Position = matrix * vertex;\n"
" texc = texCoord;\n"
"}\n";
vshader->compileSourceCode(vsrc);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
const char *fsrc =
"uniform sampler2D texture;\n"
"varying mediump vec4 texc;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(texture, texc.st);\n"
"}\n";
fshader->compileSourceCode(fsrc);
program = new QOpenGLShaderProgram;
program->addShader(vshader);
program->addShader(fshader);
program->bindAttributeLocation("vertex", PROGRAM_VERTEX_ATTRIBUTE);
program->bindAttributeLocation("texCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
program->link();
program->bind();
program->setUniformValue("texture", 0);
}
void MyGLWidget::carregaShaders()
{
// Creem els shaders per al fragment shader i el vertex shader
QOpenGLShader fs (QOpenGLShader::Fragment, this);
QOpenGLShader vs (QOpenGLShader::Vertex, this);
// Carreguem el codi dels fitxers i els compilem
fs.compileSourceFile("shaders/fragshad.frag");
vs.compileSourceFile("shaders/vertshad.vert");
// Creem el program
program = new QOpenGLShaderProgram(this);
// Li afegim els shaders corresponents
program->addShader(&fs);
program->addShader(&vs);
// Linkem el program
program->link();
// Indiquem que aquest és el program que volem usar
program->bind();
// Obtenim identificador per a l'atribut “vertex” del vertex shader
vertexLoc = glGetAttribLocation (program->programId(), "vertex");
// Obtenim identificador per a l'atribut “normal” del vertex shader
normalLoc = glGetAttribLocation (program->programId(), "normal");
// Obtenim identificador per a l'atribut “matamb” del vertex shader
matambLoc = glGetAttribLocation (program->programId(), "matamb");
// Obtenim identificador per a l'atribut “matdiff” del vertex shader
matdiffLoc = glGetAttribLocation (program->programId(), "matdiff");
// Obtenim identificador per a l'atribut “matspec” del vertex shader
matspecLoc = glGetAttribLocation (program->programId(), "matspec");
// Obtenim identificador per a l'atribut “matshin” del vertex shader
matshinLoc = glGetAttribLocation (program->programId(), "matshin");
// Demanem identificadors per als uniforms del vertex shader
transLoc = glGetUniformLocation (program->programId(), "TG");
projLoc = glGetUniformLocation (program->programId(), "proj");
viewLoc = glGetUniformLocation (program->programId(), "view");
//COLOR
posFocus = glGetUniformLocation (program->programId(), "posFocus");
colFocus = glGetUniformLocation (program->programId(), "colFocus");
llumAmbient = glGetUniformLocation (program->programId(), "llumAmbient");
franges = glGetUniformLocation (program->programId(), "franges");
}
QOpenGLShaderProgram *generateShaderProgram(QObject *parent, QByteArray vsrc, QByteArray fsrc)
{
QOpenGLShaderProgram *program = new QOpenGLShaderProgram(parent);
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, program);
vshader->compileSourceCode(vsrc);
if (!vshader->compileSourceCode(vsrc))
qFatal("Error in vertex src:\n%s\n", vsrc.constData());
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, program);
if (!fshader->compileSourceCode(fsrc))
qFatal("Error in fragment src:\n%s\n", fsrc.constData());
program->addShader(vshader);
program->addShader(fshader);
if (!program->link())
qFatal("Error linking:\n%s\n%s\n", vsrc.constData(), fsrc.constData());
return program;
}
void Renderer::initialize()
{
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceCode(
"attribute highp vec4 vertex;"
"attribute mediump vec3 normal;"
"uniform mediump mat4 matrix;"
"uniform lowp vec4 sourceColor;"
"varying mediump vec4 color;"
"void main(void)"
"{"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));"
" float angle = max(dot(normal, toLight), 0.0);"
" vec3 col = sourceColor.rgb;"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);"
" color = clamp(color, 0.0, 1.0);"
" gl_Position = matrix * vertex;"
"}");
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceCode(
"varying mediump vec4 color;"
"void main(void)"
"{"
" gl_FragColor = color;"
"}");
m_program = new QOpenGLShaderProgram(this);
m_program->addShader(vshader);
m_program->addShader(fshader);
m_program->link();
vertexAttr = m_program->attributeLocation("vertex");
normalAttr = m_program->attributeLocation("normal");
matrixUniform = m_program->uniformLocation("matrix");
colorUniform = m_program->uniformLocation("sourceColor");
m_fAngle = 0;
createGeometry();
}
void QAndroidVideoRendererControl::createGLResources()
{
if (!m_fbo || m_fbo->size() != m_nativeSize) {
delete m_fbo;
m_fbo = new QOpenGLFramebufferObject(m_nativeSize);
m_glDeleter->setFbo(m_fbo);
}
if (!m_program) {
m_program = new QOpenGLShaderProgram;
QOpenGLShader *vertexShader = new QOpenGLShader(QOpenGLShader::Vertex, m_program);
vertexShader->compileSourceCode("attribute highp vec4 vertexCoordsArray; \n" \
"attribute highp vec2 textureCoordArray; \n" \
"uniform highp mat4 texMatrix; \n" \
"varying highp vec2 textureCoords; \n" \
"void main(void) \n" \
"{ \n" \
" gl_Position = vertexCoordsArray; \n" \
" textureCoords = (texMatrix * vec4(textureCoordArray, 0.0, 1.0)).xy; \n" \
"}\n");
m_program->addShader(vertexShader);
QOpenGLShader *fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment, m_program);
fragmentShader->compileSourceCode("#extension GL_OES_EGL_image_external : require \n" \
"varying highp vec2 textureCoords; \n" \
"uniform samplerExternalOES frameTexture; \n" \
"void main() \n" \
"{ \n" \
" gl_FragColor = texture2D(frameTexture, textureCoords); \n" \
"}\n");
m_program->addShader(fragmentShader);
m_program->bindAttributeLocation("vertexCoordsArray", 0);
m_program->bindAttributeLocation("textureCoordArray", 1);
m_program->link();
m_glDeleter->setShaderProgram(m_program);
}
}
void SingleTri::initializeGL()
{
glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
const char * vs_source =
"#version 130 \n"
" \n"
"void main(void) \n"
"{ \n"
" const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0), \n"
" vec4(-0.25, -0.25, 0.5, 1.0), \n"
" vec4( 0.25, 0.25, 0.5, 1.0)); \n"
" \n"
" gl_Position = vertices[gl_VertexID]; \n"
"} \n";
const char * fs_source =
"#version 130 \n"
" \n"
"out vec4 color; \n"
" \n"
"void main(void) \n"
"{ \n"
" color = vec4(0.0, 0.8, 1.0, 1.0); \n"
"} \n";
QOpenGLShader* fs = new QOpenGLShader(QOpenGLShader::Fragment);
fs->compileSourceCode(fs_source);
QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex);
vs->compileSourceCode(vs_source);
program = new QOpenGLShaderProgram(this);
program->addShader(vs);
program->addShader(fs);
QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
vao->bind();
program->bind();
}
// Build a passthrough glsl program
QOpenGLShaderProgram* GLImageProcessor::buildPassthorughProgram() const
{
QOpenGLShaderProgram* prog = new QOpenGLShaderProgram();
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, prog);
const char *vsrc =
"attribute highp vec4 in_Vertex;\n"
"attribute mediump vec4 in_TexCoord;\n"
"varying mediump vec4 texCoord;\n"
"void main(void)\n"
"{\n"
" gl_Position = in_Vertex;\n"
" texCoord = in_TexCoord;\n"
"}\n";
vshader->compileSourceCode(vsrc);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, prog);
const char *fsrc =
"uniform sampler2D in_Texture;\n"
"varying mediump vec4 texCoord;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(in_Texture, texCoord.st);\n"
"}\n";
fshader->compileSourceCode(fsrc);
prog->addShader(vshader);
prog->addShader(fshader);
prog->bindAttributeLocation("in_Vertex", 0);
prog->bindAttributeLocation("in_TexCoord", 1);
prog->link();
prog->bind();
prog->setUniformValue("in_Texture", 0);
prog->release();
return prog;
}
void CFractalFX::InitEffect(QObject* parent)
{
CEffect::InitEffect(parent);
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, parent);
vshader->compileSourceCode(BASIC_VERTEX_SHADER);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, parent);
const char *fsrc =
"varying mediump vec2 texc;\n"
"uniform sampler2D fractalTex;\n"
"uniform sampler2D videoTex;\n"
"uniform sampler2D lookupTex;\n"
"uniform float alpha;\n"
"void main(void)\n"
"{\n"
" vec4 fractColour = texture2D(fractalTex, texc);\n"
" float fractAlpha = fractColour.r * (1.0 - alpha);\n"
"\n"
" vec4 videoColour = texture2D(videoTex, texc);\n"
" vec4 lookupColour = texture2D(lookupTex, vec2(fractColour.x, 0.0));\n"
"\n"
" gl_FragColor = lookupColour * fractAlpha +\n"
" videoColour * (1.0 - fractAlpha);\n"
"}\n";
fshader->compileSourceCode(fsrc);
m_program.setParent(parent);
m_program.addShader(vshader);
m_program.addShader(fshader);
m_program.bindAttributeLocation("vertex", 0);
m_program.link();
m_fractalLoc = m_program.uniformLocation("fractalTex");
m_ffmpegLoc = m_program.uniformLocation("videoTex");
m_lookupLoc = m_program.uniformLocation("lookupTex");
m_alphaLoc = m_program.uniformLocation("alpha");
}
void MyGLWidget::carregaShaders()
{
// Creem els shaders per al fragment shader i el vertex shader
QOpenGLShader fs (QOpenGLShader::Fragment, this);
QOpenGLShader vs (QOpenGLShader::Vertex, this);
// Carreguem el codi dels fitxers i els compilem
fs.compileSourceFile("shaders/fragshad.frag");
vs.compileSourceFile("shaders/vertshad.vert");
// Creem el program
program = new QOpenGLShaderProgram(this);
// Li afegim els shaders corresponents
program->addShader(&fs);
program->addShader(&vs);
// Linkem el program
program->link();
// Indiquem que aquest és el program que volem usar
program->bind();
// Obtenim identificador per a l'atribut “vertex” del vertex shader
vertexLoc = glGetAttribLocation (program->programId(), "vertex");
// Obtenim identificador per a l'atribut “color” del vertex shader
colorLoc = glGetAttribLocation (program->programId(), "color");
// Uniform locations
transLoc = glGetUniformLocation(program->programId(), "TG");
//Uniform projection
projLoc = glGetUniformLocation(program->programId(), "proj");
//Uniform view
viewLoc = glGetUniformLocation(program->programId(), "view");
glEnable(GL_DEPTH_TEST);
}
Shader::Shader(QString vshaderName, QString fshaderName, QObject *parent)
:QOpenGLShaderProgram(parent)
{
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, parent);
{
QFile file(":/res/Shaders/"+vshaderName+".vert");
if (file.open(QIODevice::ReadOnly)) {
QString vsrc = file.readAll();
if (!vshader->compileSourceCode(vsrc)){
printf("%s", vshader->log().data());
exit(1);
}
}
}
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, parent);
{
QFile file(":/res/Shaders/"+fshaderName+".frag");
if (file.open(QIODevice::ReadOnly)) {
QString fsrc = file.readAll();
if (!fshader->compileSourceCode(fsrc)){
printf("%s", fshader->log().data());
exit(1);
}
}
}
this->addShader(vshader);
this->addShader(fshader);
this->bindAttributeLocation("vertex", PROGRAM_VERTEX_ATTRIBUTE);
this->bindAttributeLocation("texCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
this->bindAttributeLocation("lightPosition", PROGRAM_LIGHT_POSITION_ATTRIBUTE);
this->bindAttributeLocation("lightColour", PROGRAM_LIGHT_COLOUR_ATTRIBUTE);
this->bindAttributeLocation("useTexture", PROGRAM_USE_TEXTURE);
if (!this->link())
{
printf("%s", this->log().data());
exit(1);
}
this->bind();
this->setUniformValue("texture", 0);
}
QOpenGLEngineSharedShaders::QOpenGLEngineSharedShaders(QOpenGLContext* context)
: blitShaderProg(0)
, simpleShaderProg(0)
{
/*
Rather than having the shader source array statically initialised, it is initialised
here instead. This is to allow new shader names to be inserted or existing names moved
around without having to change the order of the glsl strings. It is hoped this will
make future hard-to-find runtime bugs more obvious and generally give more solid code.
*/
static bool snippetsPopulated = false;
if (!snippetsPopulated) {
const char** code = qShaderSnippets; // shortcut
code[MainVertexShader] = qopenglslMainVertexShader;
code[MainWithTexCoordsVertexShader] = qopenglslMainWithTexCoordsVertexShader;
code[MainWithTexCoordsAndOpacityVertexShader] = qopenglslMainWithTexCoordsAndOpacityVertexShader;
code[UntransformedPositionVertexShader] = qopenglslUntransformedPositionVertexShader;
code[PositionOnlyVertexShader] = qopenglslPositionOnlyVertexShader;
code[ComplexGeometryPositionOnlyVertexShader] = qopenglslComplexGeometryPositionOnlyVertexShader;
code[PositionWithPatternBrushVertexShader] = qopenglslPositionWithPatternBrushVertexShader;
code[PositionWithLinearGradientBrushVertexShader] = qopenglslPositionWithLinearGradientBrushVertexShader;
code[PositionWithConicalGradientBrushVertexShader] = qopenglslPositionWithConicalGradientBrushVertexShader;
code[PositionWithRadialGradientBrushVertexShader] = qopenglslPositionWithRadialGradientBrushVertexShader;
code[PositionWithTextureBrushVertexShader] = qopenglslPositionWithTextureBrushVertexShader;
code[AffinePositionWithPatternBrushVertexShader] = qopenglslAffinePositionWithPatternBrushVertexShader;
code[AffinePositionWithLinearGradientBrushVertexShader] = qopenglslAffinePositionWithLinearGradientBrushVertexShader;
code[AffinePositionWithConicalGradientBrushVertexShader] = qopenglslAffinePositionWithConicalGradientBrushVertexShader;
code[AffinePositionWithRadialGradientBrushVertexShader] = qopenglslAffinePositionWithRadialGradientBrushVertexShader;
code[AffinePositionWithTextureBrushVertexShader] = qopenglslAffinePositionWithTextureBrushVertexShader;
code[MainFragmentShader_CMO] = qopenglslMainFragmentShader_CMO;
code[MainFragmentShader_CM] = qopenglslMainFragmentShader_CM;
code[MainFragmentShader_MO] = qopenglslMainFragmentShader_MO;
code[MainFragmentShader_M] = qopenglslMainFragmentShader_M;
code[MainFragmentShader_CO] = qopenglslMainFragmentShader_CO;
code[MainFragmentShader_C] = qopenglslMainFragmentShader_C;
code[MainFragmentShader_O] = qopenglslMainFragmentShader_O;
code[MainFragmentShader] = qopenglslMainFragmentShader;
code[MainFragmentShader_ImageArrays] = qopenglslMainFragmentShader_ImageArrays;
code[ImageSrcFragmentShader] = qopenglslImageSrcFragmentShader;
code[ImageSrcWithPatternFragmentShader] = qopenglslImageSrcWithPatternFragmentShader;
code[NonPremultipliedImageSrcFragmentShader] = qopenglslNonPremultipliedImageSrcFragmentShader;
code[CustomImageSrcFragmentShader] = qopenglslCustomSrcFragmentShader; // Calls "customShader", which must be appended
code[SolidBrushSrcFragmentShader] = qopenglslSolidBrushSrcFragmentShader;
code[TextureBrushSrcFragmentShader] = qopenglslTextureBrushSrcFragmentShader;
code[TextureBrushSrcWithPatternFragmentShader] = qopenglslTextureBrushSrcWithPatternFragmentShader;
code[PatternBrushSrcFragmentShader] = qopenglslPatternBrushSrcFragmentShader;
code[LinearGradientBrushSrcFragmentShader] = qopenglslLinearGradientBrushSrcFragmentShader;
code[RadialGradientBrushSrcFragmentShader] = qopenglslRadialGradientBrushSrcFragmentShader;
code[ConicalGradientBrushSrcFragmentShader] = qopenglslConicalGradientBrushSrcFragmentShader;
code[ShockingPinkSrcFragmentShader] = qopenglslShockingPinkSrcFragmentShader;
code[NoMaskFragmentShader] = "";
code[MaskFragmentShader] = qopenglslMaskFragmentShader;
code[RgbMaskFragmentShaderPass1] = qopenglslRgbMaskFragmentShaderPass1;
code[RgbMaskFragmentShaderPass2] = qopenglslRgbMaskFragmentShaderPass2;
code[RgbMaskWithGammaFragmentShader] = ""; //###
code[NoCompositionModeFragmentShader] = "";
code[MultiplyCompositionModeFragmentShader] = ""; //###
code[ScreenCompositionModeFragmentShader] = ""; //###
code[OverlayCompositionModeFragmentShader] = ""; //###
code[DarkenCompositionModeFragmentShader] = ""; //###
code[LightenCompositionModeFragmentShader] = ""; //###
code[ColorDodgeCompositionModeFragmentShader] = ""; //###
code[ColorBurnCompositionModeFragmentShader] = ""; //###
code[HardLightCompositionModeFragmentShader] = ""; //###
code[SoftLightCompositionModeFragmentShader] = ""; //###
code[DifferenceCompositionModeFragmentShader] = ""; //###
code[ExclusionCompositionModeFragmentShader] = ""; //###
#if defined(QT_DEBUG)
// Check that all the elements have been filled:
for (int i = 0; i < TotalSnippetCount; ++i) {
if (qShaderSnippets[i] == 0) {
qFatal("Shader snippet for %s (#%d) is missing!",
snippetNameStr(SnippetName(i)).constData(), i);
}
}
#endif
snippetsPopulated = true;
}
QOpenGLShader* fragShader;
QOpenGLShader* vertexShader;
QByteArray vertexSource;
QByteArray fragSource;
// Compile up the simple shader:
vertexSource.append(qShaderSnippets[MainVertexShader]);
vertexSource.append(qShaderSnippets[PositionOnlyVertexShader]);
fragSource.append(qShaderSnippets[MainFragmentShader]);
fragSource.append(qShaderSnippets[ShockingPinkSrcFragmentShader]);
simpleShaderProg = new QOpenGLShaderProgram;
CachedShader simpleShaderCache(fragSource, vertexSource);
bool inCache = simpleShaderCache.load(simpleShaderProg, context);
if (!inCache) {
vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);
shaders.append(vertexShader);
if (!vertexShader->compileSourceCode(vertexSource))
qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile");
fragShader = new QOpenGLShader(QOpenGLShader::Fragment);
shaders.append(fragShader);
if (!fragShader->compileSourceCode(fragSource))
qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
simpleShaderProg->addShader(vertexShader);
simpleShaderProg->addShader(fragShader);
simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
}
simpleShaderProg->link();
if (simpleShaderProg->isLinked()) {
if (!inCache)
simpleShaderCache.store(simpleShaderProg, context);
} else {
qCritical("Errors linking simple shader: %s", qPrintable(simpleShaderProg->log()));
}
// Compile the blit shader:
vertexSource.clear();
vertexSource.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
vertexSource.append(qShaderSnippets[UntransformedPositionVertexShader]);
fragSource.clear();
fragSource.append(qShaderSnippets[MainFragmentShader]);
fragSource.append(qShaderSnippets[ImageSrcFragmentShader]);
blitShaderProg = new QOpenGLShaderProgram;
CachedShader blitShaderCache(fragSource, vertexSource);
inCache = blitShaderCache.load(blitShaderProg, context);
if (!inCache) {
vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);
shaders.append(vertexShader);
if (!vertexShader->compileSourceCode(vertexSource))
qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile");
fragShader = new QOpenGLShader(QOpenGLShader::Fragment);
shaders.append(fragShader);
if (!fragShader->compileSourceCode(fragSource))
qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
blitShaderProg->addShader(vertexShader);
blitShaderProg->addShader(fragShader);
blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
blitShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
}
blitShaderProg->link();
if (blitShaderProg->isLinked()) {
if (!inCache)
blitShaderCache.store(blitShaderProg, context);
} else {
qCritical("Errors linking blit shader: %s", qPrintable(blitShaderProg->log()));
}
#ifdef QT_GL_SHARED_SHADER_DEBUG
qDebug(" -> QOpenGLEngineSharedShaders() %p for thread %p.", this, QThread::currentThread());
#endif
}
void Renderer::render()
{
if (m_exiting)
return;
QOpenGLContext *ctx = m_glwidget->context();
if (!ctx) // QOpenGLWidget not yet initialized
return;
// Grab the context.
m_grabMutex.lock();
emit contextWanted();
m_grabCond.wait(&m_grabMutex);
QMutexLocker lock(&m_renderMutex);
m_grabMutex.unlock();
if (m_exiting)
return;
Q_ASSERT(ctx->thread() == QThread::currentThread());
// Make the context (and an offscreen surface) current for this thread. The
// QOpenGLWidget's fbo is bound in the context.
m_glwidget->makeCurrent();
if (!m_inited) {
m_inited = true;
initializeOpenGLFunctions();
QMutexLocker initLock(initMutex());
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
const char *vsrc =
"attribute highp vec4 vertex;\n"
"attribute mediump vec3 normal;\n"
"uniform mediump mat4 matrix;\n"
"varying mediump vec4 color;\n"
"void main(void)\n"
"{\n"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));\n"
" float angle = max(dot(normal, toLight), 0.0);\n"
" vec3 col = vec3(0.40, 1.0, 0.0);\n"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);\n"
" color = clamp(color, 0.0, 1.0);\n"
" gl_Position = matrix * vertex;\n"
"}\n";
vshader->compileSourceCode(vsrc);
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
const char *fsrc =
"varying mediump vec4 color;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = color;\n"
"}\n";
fshader->compileSourceCode(fsrc);
program.addShader(vshader);
program.addShader(fshader);
program.link();
vertexAttr = program.attributeLocation("vertex");
normalAttr = program.attributeLocation("normal");
matrixUniform = program.uniformLocation("matrix");
m_fAngle = 0;
m_fScale = 1;
createGeometry();
vbo.create();
vbo.bind();
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
vbo.allocate(verticesSize * 2);
vbo.write(0, vertices.constData(), verticesSize);
vbo.write(verticesSize, normals.constData(), verticesSize);
m_elapsed.start();
}
//qDebug("%p elapsed %lld", QThread::currentThread(), m_elapsed.restart());
glClearColor(0.1f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glFrontFace(GL_CW);
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
QMatrix4x4 modelview;
modelview.rotate(m_fAngle, 0.0f, 1.0f, 0.0f);
modelview.rotate(m_fAngle, 1.0f, 0.0f, 0.0f);
modelview.rotate(m_fAngle, 0.0f, 0.0f, 1.0f);
modelview.scale(m_fScale);
modelview.translate(0.0f, -0.2f, 0.0f);
program.bind();
program.setUniformValue(matrixUniform, modelview);
paintQtLogo();
program.release();
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
m_fAngle += 1.0f;
// Make no context current on this thread and move the QOpenGLWidget's
// context back to the gui thread.
m_glwidget->doneCurrent();
ctx->moveToThread(qGuiApp->thread());
// Schedule composition. Note that this will use QueuedConnection, meaning
// that update() will be invoked on the gui thread.
QMetaObject::invokeMethod(m_glwidget, "update");
}
// The address returned here will only be valid until next time this function is called.
// The program is return bound.
QOpenGLEngineShaderProg *QOpenGLEngineSharedShaders::findProgramInCache(const QOpenGLEngineShaderProg &prog)
{
for (int i = 0; i < cachedPrograms.size(); ++i) {
QOpenGLEngineShaderProg *cachedProg = cachedPrograms[i];
if (*cachedProg == prog) {
// Move the program to the top of the list as a poor-man's cache algo
cachedPrograms.move(i, 0);
cachedProg->program->bind();
return cachedProg;
}
}
QScopedPointer<QOpenGLEngineShaderProg> newProg;
do {
QByteArray fragSource;
// Insert the custom stage before the srcPixel shader to work around an ATI driver bug
// where you cannot forward declare a function that takes a sampler as argument.
if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
fragSource.append(prog.customStageSource);
fragSource.append(qShaderSnippets[prog.mainFragShader]);
fragSource.append(qShaderSnippets[prog.srcPixelFragShader]);
if (prog.compositionFragShader)
fragSource.append(qShaderSnippets[prog.compositionFragShader]);
if (prog.maskFragShader)
fragSource.append(qShaderSnippets[prog.maskFragShader]);
QByteArray vertexSource;
vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
QScopedPointer<QOpenGLShaderProgram> shaderProgram(new QOpenGLShaderProgram);
CachedShader shaderCache(fragSource, vertexSource);
bool inCache = shaderCache.load(shaderProgram.data(), QOpenGLContext::currentContext());
if (!inCache) {
QScopedPointer<QOpenGLShader> fragShader(new QOpenGLShader(QOpenGLShader::Fragment));
QByteArray description;
#if defined(QT_DEBUG)
// Name the shader for easier debugging
description.append("Fragment shader: main=");
description.append(snippetNameStr(prog.mainFragShader));
description.append(", srcPixel=");
description.append(snippetNameStr(prog.srcPixelFragShader));
if (prog.compositionFragShader) {
description.append(", composition=");
description.append(snippetNameStr(prog.compositionFragShader));
}
if (prog.maskFragShader) {
description.append(", mask=");
description.append(snippetNameStr(prog.maskFragShader));
}
fragShader->setObjectName(QString::fromLatin1(description));
#endif
if (!fragShader->compileSourceCode(fragSource)) {
qWarning() << "Warning:" << description << "failed to compile!";
break;
}
QScopedPointer<QOpenGLShader> vertexShader(new QOpenGLShader(QOpenGLShader::Vertex));
#if defined(QT_DEBUG)
// Name the shader for easier debugging
description.clear();
description.append("Vertex shader: main=");
description.append(snippetNameStr(prog.mainVertexShader));
description.append(", position=");
description.append(snippetNameStr(prog.positionVertexShader));
vertexShader->setObjectName(QString::fromLatin1(description));
#endif
if (!vertexShader->compileSourceCode(vertexSource)) {
qWarning() << "Warning:" << description << "failed to compile!";
break;
}
shaders.append(vertexShader.data());
shaders.append(fragShader.data());
shaderProgram->addShader(vertexShader.take());
shaderProgram->addShader(fragShader.take());
// We have to bind the vertex attribute names before the program is linked:
shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
if (prog.useTextureCoords)
shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
if (prog.useOpacityAttribute)
shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
if (prog.usePmvMatrixAttribute) {
shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
}
}
newProg.reset(new QOpenGLEngineShaderProg(prog));
newProg->program = shaderProgram.take();
newProg->program->link();
if (newProg->program->isLinked()) {
if (!inCache)
shaderCache.store(newProg->program, QOpenGLContext::currentContext());
} else {
QLatin1String none("none");
QLatin1String br("\n");
QString error;
error = QLatin1String("Shader program failed to link,");
#if defined(QT_DEBUG)
error += QLatin1String("\n Shaders Used:\n");
for (int i = 0; i < newProg->program->shaders().count(); ++i) {
QOpenGLShader *shader = newProg->program->shaders().at(i);
error += QLatin1String(" ") + shader->objectName() + QLatin1String(": \n")
+ QLatin1String(shader->sourceCode()) + br;
}
#endif
error += QLatin1String(" Error Log:\n")
+ QLatin1String(" ") + newProg->program->log();
qWarning() << error;
break;
}
newProg->program->bind();
if (newProg->maskFragShader != QOpenGLEngineSharedShaders::NoMaskFragmentShader) {
GLuint location = newProg->program->uniformLocation("maskTexture");
newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT);
}
if (cachedPrograms.count() > 30) {
// The cache is full, so delete the last 5 programs in the list.
// These programs will be least used, as a program us bumped to
// the top of the list when it's used.
for (int i = 0; i < 5; ++i) {
delete cachedPrograms.last();
cachedPrograms.removeLast();
}
}
cachedPrograms.insert(0, newProg.data());
} while (false);
return newProg.take();
}
void FragColorFromPos::initializeGL()
{
glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
const char * vsInterpolate_source =
"#version 130 \n"
" \n"
"void main(void) \n"
"{ \n"
" const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0), \n"
" vec4(-0.25, -0.25, 0.5, 1.0), \n"
" vec4( 0.25, 0.25, 0.5, 1.0)); \n"
" \n"
" gl_Position = vertices[gl_VertexID]; \n"
"} \n";
const char * fsInterpolate_source =
"#version 130 \n"
" \n"
"out vec4 color; \n"
" \n"
"void main(void) \n"
"{ \n"
" color = vec4(sin(gl_FragCoord.x * 0.25) * 0.5 + 0.5, \n"
" cos(gl_FragCoord.y * 0.25) * 0.5 + 0.5, \n"
" sin(gl_FragCoord.x * 0.15) * cos(gl_FragCoord.y * 0.1), \n"
" 1.0); \n"
"} \n";
QOpenGLShader* fs = new QOpenGLShader(QOpenGLShader::Fragment);
fs->compileSourceCode(fsInterpolate_source);
QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex);
vs->compileSourceCode(vsInterpolate_source);
interpolateProgram = new QOpenGLShaderProgram(this);
interpolateProgram->addShader(vs);
interpolateProgram->addShader(fs);
interpolateProgram->link();
const char * vs_source =
"#version 130 \n"
" \n"
"out vec4 vs_color; \n"
"void main(void) \n"
"{ \n"
" const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0), \n"
" vec4(-0.25, -0.25, 0.5, 1.0), \n"
" vec4( 0.25, 0.25, 0.5, 1.0)); \n"
" const vec4 colors[] = vec4[](vec4(1.0, 0.0, 0.0, 1.0), \n"
" vec4(0.0, 1.0, 0.0, 1.0), \n"
" vec4(0.0, 0.0, 1.0, 1.0)); \n"
" \n"
" gl_Position = vertices[gl_VertexID]; \n"
" vs_color = colors[gl_VertexID]; \n"
"} \n";
const char * fs_source =
"#version 130 \n"
" \n"
"in vec4 vs_color; \n"
"out vec4 color; \n"
" \n"
"void main(void) \n"
"{ \n"
" color = vs_color; \n"
"} \n";
fs->compileSourceCode(fs_source);
vs->compileSourceCode(vs_source);
nonInterpolateProgram = new QOpenGLShaderProgram(this);
nonInterpolateProgram->addShader(vs);
nonInterpolateProgram->addShader(fs);
QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
vao->bind();
nonInterpolateProgram->bind();
}
void TessellatedTri::initializeGL()
{
glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
const char * vs_source =
"#version 420 core \n"
" \n"
"void main(void) \n"
"{ \n"
" const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0), \n"
" vec4(-0.25, -0.25, 0.5, 1.0), \n"
" vec4( 0.25, 0.25, 0.5, 1.0)); \n"
" \n"
" gl_Position = vertices[gl_VertexID]; \n"
"} \n";
const char * fs_source =
"#version 420 core \n"
" \n"
"out vec4 color; \n"
" \n"
"void main(void) \n"
"{ \n"
" color = vec4(0.0, 0.8, 1.0, 1.0); \n"
"} \n";
const char * tcs_source =
"#version 420 core \n"
" \n"
"layout (vertices = 3) out; \n"
" \n"
"void main(void) \n"
"{ \n"
" if (gl_InvocationID == 0) \n"
" { \n"
" gl_TessLevelInner[0] = 5.0; \n"
" gl_TessLevelOuter[0] = 5.0; \n"
" gl_TessLevelOuter[1] = 5.0; \n"
" gl_TessLevelOuter[2] = 5.0; \n"
" } \n"
" gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position; \n"
"} \n";
const char * tes_source =
"#version 420 core \n"
" \n"
"layout (triangles, equal_spacing, cw) in; \n"
" \n"
"void main(void) \n"
"{ \n"
" gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) + \n"
" (gl_TessCoord.y * gl_in[1].gl_Position) + \n"
" (gl_TessCoord.z * gl_in[2].gl_Position); \n"
"} \n";
QOpenGLShader* fs = new QOpenGLShader(QOpenGLShader::Fragment, this);
fs->compileSourceCode(fs_source);
QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex, this);
vs->compileSourceCode(vs_source);
QOpenGLShader* tcs = new QOpenGLShader(QOpenGLShader::TessellationControl, this);
tcs->compileSourceCode(tcs_source);
QOpenGLShader* tes = new QOpenGLShader(QOpenGLShader::TessellationEvaluation, this);
tes->compileSourceCode(tes_source);
program = new QOpenGLShaderProgram(this);
program->addShader(vs);
program->addShader(tcs);
program->addShader(tes);
program->addShader(fs);
program->link();
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
vao->bind();
program->bind();
}
void QOpenGLTextureGlyphCache::resizeTextureData(int width, int height)
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
if (ctx == 0) {
qWarning("QOpenGLTextureGlyphCache::resizeTextureData: Called with no context");
return;
}
int oldWidth = m_textureResource->m_width;
int oldHeight = m_textureResource->m_height;
// Make the lower glyph texture size 16 x 16.
if (width < 16)
width = 16;
if (height < 16)
height = 16;
GLuint oldTexture = m_textureResource->m_texture;
createTextureData(width, height);
if (ctx->d_func()->workaround_brokenFBOReadBack) {
QImageTextureGlyphCache::resizeTextureData(width, height);
Q_ASSERT(image().depth() == 8);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
glDeleteTextures(1, &oldTexture);
return;
}
// ### the QTextureGlyphCache API needs to be reworked to allow
// ### resizeTextureData to fail
QOpenGLFunctions funcs(ctx);
funcs.glBindFramebuffer(GL_FRAMEBUFFER, m_textureResource->m_fbo);
GLuint tmp_texture;
glGenTextures(1, &tmp_texture);
glBindTexture(GL_TEXTURE_2D, tmp_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
m_filterMode = Nearest;
glBindTexture(GL_TEXTURE_2D, 0);
funcs.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, tmp_texture, 0);
funcs.glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
glBindTexture(GL_TEXTURE_2D, oldTexture);
if (pex != 0)
pex->transferMode(BrushDrawingMode);
glDisable(GL_STENCIL_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glViewport(0, 0, oldWidth, oldHeight);
QOpenGLShaderProgram *blitProgram = 0;
if (pex == 0) {
if (m_blitProgram == 0) {
m_blitProgram = new QOpenGLShaderProgram(ctx);
{
QString source;
source.append(QLatin1String(qopenglslMainWithTexCoordsVertexShader));
source.append(QLatin1String(qopenglslUntransformedPositionVertexShader));
QOpenGLShader *vertexShader = new QOpenGLShader(QOpenGLShader::Vertex, m_blitProgram);
vertexShader->compileSourceCode(source);
m_blitProgram->addShader(vertexShader);
}
{
QString source;
source.append(QLatin1String(qopenglslMainFragmentShader));
source.append(QLatin1String(qopenglslImageSrcFragmentShader));
QOpenGLShader *fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment, m_blitProgram);
fragmentShader->compileSourceCode(source);
m_blitProgram->addShader(fragmentShader);
}
m_blitProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
m_blitProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
m_blitProgram->link();
}
funcs.glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_vertexCoordinateArray);
funcs.glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_textureCoordinateArray);
m_blitProgram->bind();
m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
m_blitProgram->disableAttributeArray(int(QT_OPACITY_ATTR));
blitProgram = m_blitProgram;
} else {
pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, m_vertexCoordinateArray);
pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, m_textureCoordinateArray);
pex->shaderManager->useBlitProgram();
blitProgram = pex->shaderManager->blitProgram();
}
blitProgram->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, 0);
glDeleteTextures(1, &tmp_texture);
glDeleteTextures(1, &oldTexture);
funcs.glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_func()->current_fbo);
if (pex != 0) {
glViewport(0, 0, pex->width, pex->height);
pex->updateClipScissorTest();
} else {
m_blitProgram->disableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
m_blitProgram->disableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
}
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
makeCurrent();
qglClearColor(QColor::fromCmykF(0.79, 0.79, 0.79, 0.0).dark());
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST);
qDebug() << "Loading quad (vertex shader)";
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/plane.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (fragment shader)";
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/plane.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation control shader)";
QOpenGLShader *tcshader = new QOpenGLShader(QOpenGLShader::TessellationControl, this);
tcshader->compileSourceFile(":/resources/plane.tcs.vert");
if (!tcshader->log().isEmpty()) qDebug() << tcshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (tessellation evaluation shader)";
QOpenGLShader *teshader = new QOpenGLShader(QOpenGLShader::TessellationEvaluation, this);
teshader->compileSourceFile(":/resources/plane.tes.vert");
if (!teshader->log().isEmpty()) qDebug() << teshader->log();
else qDebug() << "done";
qDebug() << "Loading quad (geometry shader)";
QOpenGLShader *gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
QFile gFile(":/resources/plane.geom");
gFile.open(QFile::ReadOnly);
qDebug() << gFile.isOpen() << " File";
QTextStream in(&gFile);
QString preambule = "#version 400 core\n"
"layout(triangle_strip, max_vertices = 3) out;\n" ;
QString shaderCode = in.readAll();
gshader->compileSourceCode(preambule+shaderCode);
//gshader->compileSourceFile(in.readAll());
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
program = new QOpenGLShaderProgram(this);
program->addShader(vshader);
program->addShader(fshader);
program->addShader(tcshader);
program->addShader(teshader);
program->addShader(gshader);
program->bindAttributeLocation("FragColor",0);
program->bindAttributeLocation("FragNormal",1);
program->bindAttributeLocation("FragGlowColor",2);
program->bindAttributeLocation("FragPosition",3);
GLCHK(program->link());
GLCHK(program->bind());
program->setUniformValue("texDiffuse" , 0);
program->setUniformValue("texNormal" , 1);
program->setUniformValue("texSpecular" , 2);
program->setUniformValue("texHeight" , 3);
program->setUniformValue("texSSAO" , 4);
program->setUniformValue("texRoughness", 5);
program->setUniformValue("texMetallic", 6);
program->setUniformValue("texMaterial", 7);
program->setUniformValue("texDiffuseEnvMap", 8);
program->setUniformValue("texEnvMap" , 9);
// lines shader
qDebug() << "Compiling lines program...";
preambule = QString("#version 400 core\n")+
"layout(line_strip, max_vertices = 3) out;\n" ;
gshader->compileSourceCode(preambule+shaderCode);
line_program = new QOpenGLShaderProgram(this);
line_program->addShader(vshader);
line_program->addShader(fshader);
line_program->addShader(tcshader);
line_program->addShader(teshader);
line_program->addShader(gshader);
line_program->bindAttributeLocation("FragColor",0);
line_program->bindAttributeLocation("FragNormal",1);
line_program->bindAttributeLocation("FragGlowColor",2);
line_program->bindAttributeLocation("FragPosition",3);
GLCHK(line_program->link());
GLCHK(line_program->bind());
line_program->setUniformValue("texDiffuse" , 0);
line_program->setUniformValue("texNormal" , 1);
line_program->setUniformValue("texSpecular" , 2);
line_program->setUniformValue("texHeight" , 3);
line_program->setUniformValue("texSSAO" , 4);
line_program->setUniformValue("texRoughness", 5);
line_program->setUniformValue("texMetallic", 6);
line_program->setUniformValue("texMaterial", 7);
line_program->setUniformValue("texDiffuseEnvMap", 8);
line_program->setUniformValue("texEnvMap" , 9);
delete vshader;
delete fshader;
delete tcshader;
delete teshader;
delete gshader;
// loading sky box shader
qDebug() << "Loading skybox shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/skybox.vert.glsl");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading skybox shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/skybox.frag.glsl");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
skybox_program = new QOpenGLShaderProgram(this);
skybox_program->addShader(vshader);
skybox_program->addShader(fshader);
skybox_program->bindAttributeLocation("FragColor",0);
skybox_program->bindAttributeLocation("FragNormal",1);
skybox_program->bindAttributeLocation("FragGlowColor",2);
skybox_program->bindAttributeLocation("FragPosition",3);
GLCHK(skybox_program->link());
GLCHK(skybox_program->bind());
skybox_program->setUniformValue("texEnv" , 0);
// loading enviromental shader
qDebug() << "Loading enviromental shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/env.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (geometry shader)";
gshader = new QOpenGLShader(QOpenGLShader::Geometry, this);
gshader->compileSourceFile(":/resources/env.geom");
if (!gshader->log().isEmpty()) qDebug() << gshader->log();
else qDebug() << "done";
qDebug() << "Loading enviromental shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/env.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
env_program = new QOpenGLShaderProgram(this);
env_program->addShader(vshader);
env_program->addShader(gshader);
env_program->addShader(fshader);
GLCHK(env_program->link());
GLCHK(env_program->bind());
env_program->setUniformValue("texEnv" , 0);
delete vshader;
delete fshader;
delete gshader;
// -------------------------------------------------
// Loading post processing filters
// -------------------------------------------------
qDebug() << "Loading post-processing shader (vertex shader)";
vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceFile(":/resources/filters_3d.vert");
if (!vshader->log().isEmpty()) qDebug() << vshader->log();
else qDebug() << "done";
qDebug() << "Loading post-processing shader (fragment shader)";
fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceFile(":/resources/filters_3d.frag");
if (!fshader->log().isEmpty()) qDebug() << fshader->log();
else qDebug() << "done";
filters_program = new QOpenGLShaderProgram(this);
filters_program->addShader(vshader);
filters_program->addShader(fshader);
filters_program->bindAttributeLocation("positionIn", 0);
GLCHK( filters_program->link() );
GLCHK( filters_program->bind() );
GLCHK( filters_program->setUniformValue("layerA" , 0) );
GLCHK( filters_program->setUniformValue("layerB" , 1) );
GLCHK( filters_program->setUniformValue("layerC" , 2) );
GLCHK( filters_program->setUniformValue("layerD" , 3) );
GLCHK( filters_program->setUniformValue("layerE" , 4) );
GLCHK( filters_program->setUniformValue("layerF" , 5) );
GLCHK( filters_program->setUniformValue("layerG" , 6) );
GLCHK( subroutines["mode_normal_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_normal_filter") );
GLCHK( subroutines["mode_gauss_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_gauss_filter") );
GLCHK( subroutines["mode_bloom_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_bloom_filter") );
GLCHK( subroutines["mode_dof_filter"] = glGetSubroutineIndex(filters_program->programId(),GL_FRAGMENT_SHADER,"mode_dof_filter") );
GLCHK( filters_program->release());
delete vshader;
delete fshader;
camera.position.setZ( -0 );
camera.toggleFreeCamera(false);
newCamera.toggleFreeCamera(false);
lightDirection.position.setZ(0);
lightDirection.toggleFreeCamera(false);
lightDirection.radius = 1;
mesh = new Mesh("Core/3D/","Cube.obj");
skybox_mesh = new Mesh("Core/3D/","sky_cube.obj");
env_mesh = new Mesh("Core/3D/","sky_cube_env.obj");
quad_mesh = new Mesh("Core/3D/","quad.obj");
m_prefiltered_env_map = new GLTextureCube(512);
resizeFBOs();
emit readyGL();
}