void VideoViewer::makeShaders()
{
    _shaderProgram = new QGLShaderProgram(this);
    QGLShader *vertexShader = new QGLShader(QGLShader::Vertex, this);
    QGLShader *fragmentShader = new QGLShader(QGLShader::Fragment, this);

    QString vertexShaderSource;
    QString fragmentShaderSource;

    vertexShaderSource.append("#version 110\n");
    vertexShaderSource.append("attribute vec2 position;\n");
    vertexShaderSource.append("uniform mat2 matrix;\n");
    vertexShaderSource.append("varying vec2 texcoord;\n");
    vertexShaderSource.append("void main()\n");
    vertexShaderSource.append("{\n");
    vertexShaderSource.append(
        "gl_Position = vec4(matrix * position, 0.0, 1.0);\n");
    vertexShaderSource.append("texcoord = vec2(position.x, -position.y) "
                              "* vec2(0.5) + vec2(0.5);\n");
    vertexShaderSource.append("}\n");

    fragmentShaderSource.append("#version 110\n");
    fragmentShaderSource.append("uniform sampler2D texture;\n");
    fragmentShaderSource.append("varying vec2 texcoord;\n");
    fragmentShaderSource.append("void main()\n");
    fragmentShaderSource.append("{\n");
    fragmentShaderSource.append(
        "gl_FragColor = texture2D(texture, texcoord);\n");
    fragmentShaderSource.append("}\n");

    vertexShader->compileSourceCode(vertexShaderSource);
    fragmentShader->compileSourceCode(fragmentShaderSource);

    if (!vertexShader->isCompiled())
    {
        qDebug()
                << "Could not compile vertex shader:\n"
                << vertexShader->log();
    }

    if (!fragmentShader->isCompiled())
    {
        qDebug()
                << "Could not compile fragment shader:\n"
                << fragmentShader->log();
    }

    _shaderProgram->addShader(fragmentShader);
    _shaderProgram->addShader(vertexShader);

    _shaderProgram->link();
    _shaderProgram->bind();

}
Пример #2
0
void Widget::initializeGL()
{
    qDebug() << "isValid:" << this->context()->isValid();
    qDebug() << "isSharing:" << this->context()->isSharing();
    qDebug() << "hasOpenGL:" << this->context()->format().hasOpenGL();
    qDebug() << "Format:" << this->context()->format();


    glEnable(GL_DEPTH_TEST);

    QString vertexShaderSource(
        "uniform mat4 modelViewMatrix;\n"
        "uniform mat4 projectionMatrix;\n"
        "attribute vec4 vertexPosition;\n"
        "\n"
        "void main(void)\n"
        "{\n"
        "    gl_Position = projectionMatrix * modelViewMatrix  * vertexPosition;\n"
        "}\n");

    QString fragmentShaderSource(
        "precision mediump float;\n"
        "\n"
        "void main(void)\n"
        "{\n"
        "gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n"
        "}\n");

    QGLShader *vertexShader = new QGLShader(QGLShader::Vertex, this);
    QGLShader *fragmentShader = new QGLShader(QGLShader::Fragment, this);
    qDebug() << "After constuctor Shaders.";
    qDebug() << vertexShader->log();

    vertexShader->compileSourceCode(vertexShaderSource);
    fragmentShader->compileSourceCode(fragmentShaderSource);
    
    _shaderProgram = new QGLShaderProgram(this);

    _shaderProgram->addShader(vertexShader);
    _shaderProgram->addShader(fragmentShader);

    _shaderProgram->link();
    
    _shaderProgram->bind();

    qglClearColor(Qt::gray);
    _timer->start(10);
    qDebug() << vertexShader->log();
}
Пример #3
0
void GLWidget::loadShaders(QGLShaderProgram* program, QString vShaderFileName, QString fShaderFileName)
{
    QGLShader* vertexShader = NULL;
    QGLShader* fragmentShader = NULL;

    QFileInfo vsh(vShaderFileName);
    if(vsh.exists()) {
        vertexShader = new QGLShader(QGLShader::Vertex);
        if(vertexShader->compileSourceFile(vShaderFileName)) {
            program->addShader(vertexShader);
            qDebug() << "Vertex shader compiled successfully.";
        }
        else {
            qWarning() << "Vertex Shader Error" << vertexShader->log();
        }
    }
    else {
        qWarning() << "Vertex Shader source file " << fShaderFileName << " not found.";
    }

    QFileInfo fsh(fShaderFileName);
    if(fsh.exists()) {
        fragmentShader = new QGLShader(QGLShader::Fragment);
        if(fragmentShader->compileSourceFile(fShaderFileName)) {
            program->addShader(fragmentShader);
            qDebug() << "Fragment shader compiled successfully.";
        }
        else {
            qWarning() << "Fragment Shader Error" << fragmentShader->log();
        }
    }
    else {
        qWarning() << "Fragment Shader source file " << fShaderFileName << " not found.";
    }

    if(!program->link()){
        qWarning() << "Shader Program Linker Error" << program->log();
    }

}
Пример #4
0
QGLShader* StelQGLGLSLShader::createVertexShader(const QString& source)
{
	Q_ASSERT_X(state == State_Unlocked || state == State_Modified, Q_FUNC_INFO,
	           "Can't add a vertex shader to a built shader program");
	state = State_Modified;
	QGLShader* shader = new QGLShader(QGLShader::Vertex, renderer->getGLContext());
	aggregatedLog += shader->log();

	if(shader->compileSourceCode(source))
	{
		return shader;
	}
	else
	{
		delete shader;
		return NULL;
	}
}
Пример #5
0
void RenderViewWidget::initShaders(){

    Assert(QGLContext::currentContext() != 0);

    //First, check if we can even use OpenGL shader programs
    const bool canUseShaders = QGLShaderProgram::hasOpenGLShaderPrograms();
    Assert(canUseShaders);

    //Fragment shader(s)
    QGLShader* shader = new QGLShader(QGLShader::Fragment, this);
    const bool ok1 = shader->compileSourceCode(
        "//Simple Vertex Shader" \
        "\n"\
        "uniform sampler2D sampler;\n"\
        "\n"\
        "void main(void)\n" \
        "{\n" \
        "//    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" \
        "\n"\
        "    vec4 c = texture2D(sampler, gl_TexCoord[0].st);\n" \
        "    gl_FragColor = vec4(c.x, c.y, c.z, 1.0);\n"\
        "}\n" \
    );
    std::cout << shader->log().toStdString() << std::endl;
    Assert(ok1);
    hdrFragShaders.push_back(shader);


    //Vertex shader
    hdrVertShader = new QGLShader(QGLShader::Vertex, this);
    const bool ok2 = hdrVertShader->compileSourceCode(
        "//Simple fragment shader\n"\
        "\n"\
        "\n"\
        "void main(void){\n"\
        "    gl_TexCoord[0] = gl_MultiTexCoord0;\n"\
        "    gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;\n"\
        "}\n"\
        "\n"\
    );
    std::cout << hdrVertShader->log().toStdString() << std::endl;
    Assert(ok2);
    hdrFragShaders.push_back(hdrVertShader);
}
Пример #6
0
bool StelQGLGLSLShader::addFragmentShader(const QString& source)
{
	Q_ASSERT_X(state == State_Unlocked || state == State_Modified, Q_FUNC_INFO,
	           "Can't add a fragment shader to a built shader program");

	state = State_Modified;

	QGLShader* shader = new QGLShader(QGLShader::Fragment, renderer->getGLContext());
	const bool success = shader->compileSourceCode(source);
	aggregatedLog += shader->log();
	if(success)
	{
		defaultFragmentShaders.append(shader);
	}
	else
	{
		delete shader;
	}
	return success;
}
Пример #7
0
QGLShader *SceneParser::loadShader(KeyValues *data)
{
  const char *type = data->getString("type");
  if(!type) {
    fprintf(stderr, "Key 'type' not found on Shader\n");
    return NULL;
  }

  const char *file = data->getString("file");
  if(!file) {
    fprintf(stderr, "Key 'file' not found on Shader\n");
    return NULL;
  }
  char *filename = resolvePath(file);

  QGLShader::ShaderType shaderType;
  if(strcmp(type, "vertex") == 0) {
    shaderType = QGLShader::Vertex;
  }
  else if(strcmp(type, "fragment") == 0) {
    shaderType = QGLShader::Fragment;
  }
  else {
    fprintf(stderr, "Invalid shader type: %s\n", type);
    delete[] filename;
    return NULL;
  }

  QGLShader *shader = new QGLShader(shaderType);
  if(!shader->compileSourceFile(filename)) {
    fprintf(stderr, "Failed to load shader %s\n", filename);
    fprintf(stdout, shader->log().toStdString().c_str());
    delete shader;
    delete[] filename;
    return NULL;
  }
  delete[] filename;

  return shader;
}
Пример #8
0
const bool CCDeviceRenderer::loadShader(CCShader *shader)
{
    // Create shader program
    shader->program = new QGLShaderProgram();

    // Create and compile vertex shader
    CCText shaderFilename( "Resources/Shaders/" );
    shaderFilename += shader->name;
    shaderFilename += ".fx";

    const char *qtDefines = "#define QT\r\n";

    QGLShader *vertexShader = new QGLShader( QGLShader::Vertex );
    QGLShader *fragmentShader = new QGLShader( QGLShader::Fragment );
    {
        char *fileData = NULL;
        CCFileManager::getPackagedFile( shaderFilename.buffer, &fileData );
        {
            QString shaderData = QString( qtDefines );
            shaderData.append( "#define VERTEX_SHADER\r\n" );
            shaderData.append( fileData );
            if( vertexShader->compileSourceCode( shaderData ) == false )
            {
                QString error( "CCDeviceRenderer::Failed to compile vertex shader.\n" );
                error.append( vertexShader->log() );
                ASSERT_MESSAGE( false, error.toUtf8().constData() );

                delete vertexShader;
                vertexShader = NULL;
            }
        }
        {
            QString shaderData = QString( qtDefines );
            shaderData.append( "#define PIXEL_SHADER\r\n" );
            shaderData.append( fileData );
            if( fragmentShader->compileSourceCode( shaderData ) == false )
            {
                QString error( "CCDeviceRenderer::Failed to compile pixel shader.\n" );
                error.append( fragmentShader->log() );
                ASSERT_MESSAGE( false, error.toUtf8().constData() );

                delete fragmentShader;
                fragmentShader = NULL;
            }
        }
        FREE_POINTER( fileData );
    }

    // Attach vertex shader to program
    shader->program->addShader( vertexShader );

    // Attach fragment shader to program
    shader->program->addShader( fragmentShader );

    // Bind attribute locations
    // this needs to be done prior to linking
    shader->program->bindAttributeLocation( "vs_position", ATTRIB_VERTEX );
    shader->program->bindAttributeLocation( "vs_color",	ATTRIB_COLOR );
    shader->program->bindAttributeLocation( "vs_texCoord", ATTRIB_TEXCOORD );

    // Link program
    if( !shader->program->link() )
    {
        // Should log: "Failed to link program";
        return false;
    }

    return true;
}