D:/Timo/Visualisierung/LU/Aufgabe1/src/GLShader.cpp

Go to the documentation of this file.

#include "GLProgramm.h"

#include <QFile>
#include <QDebug>

GLShader::GLShader(GLuint type)
{
        changed = true;
        initialized = false;
        shader = 0;
        this->type = type;
        loopPos = -1;
        maxLoopIterations = 139;
        loopIterations = maxLoopIterations;
}

GLShader::~GLShader()
{
        free();
}

char* getFileContents(const QString & fileName)
{
        QFile *file = new QFile(fileName);

        if(!file->open(QIODevice::ReadOnly | QIODevice::Unbuffered))
         return 0;

        int fileSize = file->size();

        // TODO: 64bit clipped to 32bit (not interesting for small shaders ;))
        char *content = new char[fileSize + 1];

        file->read(content, fileSize);
        content[fileSize] = '\0';

        file->close();

        return content;
}

bool GLShader::load(QString shaderName)
{
        this->shaderName = shaderName;
        const char *shaderSource = getFileContents("shader/" + shaderName + ".glsl");

        if(shaderSource == 0)
        {
                source = "";
                return false;
        }

        source = shaderSource;
        delete shaderSource;

        loopPos = -1;
        string::size_type currentPos;

        char searchCharacters[] = "|#";
        string::size_type lastPos;

        lastPos = 0;
        currentPos = source.find_first_of(searchCharacters, lastPos);
        while(currentPos != -1)
        {
                if(source.at(currentPos) == '#')
                {
                        loopPos = parts.size();
                }
                parts.push_back(source.substr(lastPos, currentPos));
                glue.push_back("");
                lastPos = currentPos + 1;
                currentPos = source.find_first_of(searchCharacters, lastPos);
        }
        parts.push_back(source.substr(lastPos));

        initialized = false;

        return false;
}

bool GLShader::change()
{
        bool ret = false;

        if(initialized) {
                if(loopPos != -1)
                {
                        if(maxLoopIterations > 70) {
                                maxLoopIterations = 70;
                        } else if(maxLoopIterations > 56) {
                                maxLoopIterations = 56;
                        } else if(maxLoopIterations > 28) {
                                maxLoopIterations = 28;
                        } else if(maxLoopIterations > 20) {
                                maxLoopIterations = 20;
                        } else if(maxLoopIterations > 18) {
                                maxLoopIterations = 18;
                        }else {
                                maxLoopIterations -= 1;
                        }
                        if(loopIterations > maxLoopIterations) {
                                loopIterations = maxLoopIterations;
                        }
                        qDebug() << "changed loop count: " << loopIterations;
                }
        }
        else
        {
                // TODO: check if exstension exists
                GLint glParam;
                glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, &glParam);
                if(maxLoopIterations > (GLuint)(glParam - 4) / 3) {
                        qDebug() << "steps: " << maxLoopIterations << " | ~tex instructions: " << maxLoopIterations * 3 + 4 << "(" << glParam << ")";
                        //maxLoopIterations = (GLuint)(glParam - 4) / 3;
                }
                if(loopIterations > maxLoopIterations) {
                        loopIterations = maxLoopIterations;
                }
                /*while(maxLoopIterations > (GLuint)(glParam - 5) / 3) {
                        maxLoopIterations = maxLoopIterations / 2;
                }
                if(loopIterations > maxLoopIterations) {
                        loopIterations = maxLoopIterations;
                }*/
                //qDebug() << "loops: " << loopIterations << " | ~tex instructions: " << loopIterations * 3 + 5 << "(" << glParam << ")";
                initialized = true;
        }

        if(loopPos != -1)
        {
                char insertString[4];
                sprintf_s(insertString, sizeof(insertString), "%u", loopIterations);
                glue[loopPos] = insertString;
                ret = true;
        }

        string::size_type currentPos;

        source = parts[0];
        currentPos = 1;
        while(currentPos < parts.size())
        {
                source += glue[currentPos - 1];
                source += parts[currentPos];
                ++currentPos;
        }

        /*if(loopPos != -1)
        {
                qDebug() << "code: \n" << source.c_str();
        }*/

        return ret;
}

bool GLShader::compile(bool *changed)
{
        bool ret = true;

        if(changed != 0)
        {
                *changed = change();
        }
        else if(!initialized)
        {
                change();
        }

        if(shader == 0 || (changed != 0 && *changed))
        {
                if(shader == 0)
                {
                        shader = glCreateShader(type);
                }
                const char *stringArray = source.c_str();
                glShaderSource(shader, 1, &stringArray, 0);
                glCompileShader(shader);

                //glGetInfoLog(GLhandle object, GLsizei maxLenght, GLsizei *length, GLchar *infoLog)

                GLenum glError;
                glError = glGetError();
                if(glError != GL_NO_ERROR)
                {
                        qDebug() << "compile shader error " << shaderName << ": " << (char*)gluErrorString(glError);
                        ret = false;
                }

                GLint glParam;
                glGetShaderiv(shader, GL_COMPILE_STATUS, &glParam);
                if(glParam == GL_FALSE)
                {
                        qDebug() << "compile shader failed " << shaderName;
                        //qDebug() << "code: " << source.c_str();
                        ret = false;
                }

                //GLEW_GET_VAR(GL_PROGRAM_TEX_INSTRUCTIONS_ARB);
                //glEnable(GL_FRAGMENT_PROGRAM_ARB);
                //glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, &glParam);
                //qDebug() << "tex instructions: " << glParam;

                if(!ret)
                {
                        char buf[1024];
                        glGetShaderInfoLog(shader, sizeof(buf), NULL, buf);
                        qDebug() << "info: " << buf;
                }

                changed = false;
                //qDebug() << "compiled: " << shaderName;
        }

        return ret;
}

void GLShader::free()
{
        if(shader != 0)
        {
                GLenum glError;

                glDeleteShader(shader);
                shader = 0;

                glError = glGetError();
                if(glError != GL_NO_ERROR)
                {
                        qDebug() << "free shader error: " << (char*)gluErrorString(glError);
                }
        }
}

---