VolumeShaderProgramEffect Class Reference

#include <volumeeffect_p.h>

Inheritance diagram for VolumeShaderProgramEffect:

Collaboration diagram for VolumeShaderProgramEffect:

Public Member Functions
	VolumeShaderProgramEffect (VolumeShaderProgram *parent)
virtual	~VolumeShaderProgramEffect ()
bool	create (const QString &vertexShader, const QString &fragmentShader)
void	update (QGLPainter *painter, QGLPainter::Updates updates)
bool	setUniformForPropertyIndex (int propertyIndex, QGLPainter *painter)
void	setPropertiesDirty ()
void	setPropertyDirty (int property)
void	setAttributeFields (QGL::VertexAttribute fields)

Protected Member Functions
void	processTextureUrl (int uniformLocation, QString urlString)
void	afterLink ()
bool	beforeLink ()

Detailed Description

Definition at line 106 of file volumeeffect_p.h.

Constructor & Destructor Documentation

VolumeShaderProgramEffect::VolumeShaderProgramEffect

(

VolumeShaderProgram *

parent)

Definition at line 240 of file volumeeffect.cpp.

{
    this->parent = parent;
    nextTextureUnit = 1;
    propertyListener = new VolumeShaderProgramPropertyListenerEx(parent, this);
}

VolumeShaderProgramEffect::~VolumeShaderProgramEffect ( )

virtual

Definition at line 252 of file volumeeffect.cpp.

{
    QList<QGLTexture2D*> textures = texture2Ds.values();
    QGLTexture2D* texture;
    foreach (texture, textures)
        delete texture;
}

Member Function Documentation

void VolumeShaderProgramEffect::afterLink ( )

protected

Definition at line 286 of file volumeeffect.cpp.

{
    // Texture3D stuff
//    qDebug() << "After link!";
//    qDebug() << program()->uniformLocation("myTexture3D");
    m_texture3DuniformValue = program()->uniformLocation("myTexture3D");
    m_eyePositionUniformLocation = program()->uniformLocation("ve_eyePosition");
//    qDebug() << m_eyePositionUniformLocation;
//    qDebug() << "Attribute: " << program()->attributeLocation("multiTexCoord3D");
//    double data[24];
//    QGLAttributeValue value(3, GL_FLOAT, 0, array.)
//    glTexCoordPointer(value.tupleSize(), value.type(),
//                      value.stride(), value.data());

    GLuint g_volTexObj;
    GLuint *data = parent.data()->texture3Ddata().data;
    GLuint w = parent.data()->texture3Ddata().width;
    GLuint h = parent.data()->texture3Ddata().height;
    GLuint d = parent.data()->texture3Ddata().depth;
//    qDebug() << "w " << w << " " << h << " " << d;

    glGenTextures(1, &g_volTexObj);
    // bind 3D texture target
    glBindTexture(GL_TEXTURE_3D, g_volTexObj);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
    // pixel transfer happens here from client to OpenGL server
    glPixelStorei(GL_UNPACK_ALIGNMENT,1);
    glTexImage3D(GL_TEXTURE_3D, 0, GL_INTENSITY, w, h, d, 0, GL_LUMINANCE, GL_UNSIGNED_INT, data);

    program()->setUniformValue(m_texture3DuniformValue, g_volTexObj);
    // End Texture3D stuff

    propertyIdsToUniformLocations.clear();
    uniformLocationsToTextureUnits.clear();
    nextTextureUnit = 1;
    propertyListener->disconnect();
    if (parent.data() == 0)
    {
        return;
    }
    QObject::connect(propertyListener, SIGNAL(propertyChanged()), parent.data(), SIGNAL(effectChanged()));

    const QMetaObject* parentMetaObject = parent.data()->metaObject();
    int parentMethodCount = parentMetaObject->methodCount();

    for (int i = parentMetaObject->propertyOffset();
    i < parentMetaObject->propertyCount(); i++)
    {
        QMetaProperty metaProperty = parentMetaObject->property(i);
        QByteArray propertyName = metaProperty.name();
        int location = program()->uniformLocation(propertyName);
        // -1 indicates that the program does not use the variable,
        // so ignore those variables.
        if (location != -1)
        {
            dirtyProperties.append(i);
            propertyIdsToUniformLocations[i] = location;
            if (metaProperty.hasNotifySignal())
            {
                QMetaMethod notifySignal = metaProperty.notifySignal();

                int signalIndex = notifySignal.methodIndex();

                // Connect the myFooChanged() signal from the VolumeShaderProgram
                // to the corresponding imaginary slot on the listener
                // Use the method count to make sure that we don't stomp on
                // real methods and add the property index to tell the
                // properties apart.
                // Warning: Subclasses of VolumeShaderProgramPropertyListener will
                // generate spurious property updates and lots of warnings
                // and might even crash
                QMetaObject::connect(parent.data(), signalIndex,
                                     propertyListener,  parentMethodCount + i);
            } else {
                qWarning() << "Warning: No notification signal found for property: " << propertyName;
                propertiesWithoutNotificationSignal.append(i);
            }
        }
    }

    // Refresh everything
    this->setPropertiesDirty();
}

bool VolumeShaderProgramEffect::beforeLink ( )

protected

Definition at line 374 of file volumeeffect.cpp.

{
//    program()->bindAttributeLocation("multiTexCoord3D", 8);
    return true;
}

bool VolumeShaderProgramEffect::create	(	const QString &	vertexShader,
		const QString &	fragmentShader
	)

Definition at line 270 of file volumeeffect.cpp.

{
    if (!QOpenGLShaderProgram::hasOpenGLShaderPrograms())
        return false;

    setVertexShader(vertexShader.toLatin1());
    setFragmentShader(fragmentShader.toLatin1());

    return true;
}

void VolumeShaderProgramEffect::processTextureUrl ( int  uniformLocation, QString  urlString  )

protected

Definition at line 665 of file volumeeffect.cpp.

{
    QUrl url(urlString);
    if (urlString.isEmpty() &&
       urls.contains(uniformLocation) &&
       !urls[uniformLocation].isNull())
    {
        if (images.contains(uniformLocation) && !images[uniformLocation].isNull())
        {
            images[uniformLocation] = QImage();
            urls.remove(uniformLocation);
            changedTextures.insert(uniformLocation);
            return;
        }
    };

    // Try to make path absolute:
    if (url.isRelative())
    {
        // Get the baseUrl from the qml engine
        QQmlContext *context =
                QQmlEngine::contextForObject(parent.data());

        if (context)
        {
            QUrl baseurl = context->baseUrl();
            QUrl absolute =  baseurl.resolved(urlString);

            if (absolute.isValid())
            {
                url = absolute;
                urlString = absolute.toString();
            } else {
                qWarning() << "Warning: failed to resolve relative path " <<
                        urlString;
            }
        }
    };

    if (urlString != urls[uniformLocation])
    {
        if (url.scheme() != QLatin1String("file"))
        {
            // TODO - support network URL's for loading - note that this feature is for
            // the Qt3D 1.1 release and there is no point in implementing it until for example
            // model loading and all other parts of Qt3D support it.  Also when it is implemented
            // it has to be done with a facility that does not depend on private headers in
            // QtQml which can change within minor dot-point releases.
            qWarning("Network URL's not yet supported - %s", qPrintable(urlString));
        }
        else
        {
            QString localFile = url.toLocalFile();
            if (localFile.endsWith(QLatin1String(".dds")))
            {
                qWarning("Shader effects with compressed textures not supported: %s",
                         qPrintable(urlString));
            }
            else
            {
                QImage im(localFile);
                if (im.isNull())
                {
                    qWarning("Could not load image from local file path - %s", qPrintable(localFile));
                }
                else
                {
                    images[uniformLocation] = im;
                    changedTextures.insert(uniformLocation);
                }
            }
        }
    }
}

void VolumeShaderProgramEffect::setAttributeFields

(

QGL::VertexAttribute

fields)

void VolumeShaderProgramEffect::setPropertiesDirty

(

)

Definition at line 641 of file volumeeffect.cpp.

{
    dirtyProperties = this->propertyIdsToUniformLocations.keys();
}

void VolumeShaderProgramEffect::setPropertyDirty

(

int

property)

Definition at line 650 of file volumeeffect.cpp.

{
    if (dirtyProperties.indexOf(property) == -1)
    {
        dirtyProperties.append(property);
    }
}

bool VolumeShaderProgramEffect::setUniformForPropertyIndex ( int  propertyIndex, QGLPainter *  painter  )

inline

Definition at line 515 of file volumeeffect.cpp.

{
    QOpenGLShaderProgram *program = this->program();
    int uniformLocation = propertyIdsToUniformLocations[propertyIndex];

    QVariant value =
            parent.data()->metaObject()->property(propertyIndex).read(parent.data());

    switch(int(value.type()))
    {
    case QVariant::Double:
        // Convert double to float to pass to shader program
    case QMetaType::Float:
        program->setUniformValue(uniformLocation, value.toFloat());
        break;
    case QVariant::Int:
        program->setUniformValue(uniformLocation, value.toInt());
        break;
    case QVariant::UInt:
        program->setUniformValue(uniformLocation, value.toUInt());
        break;
    case QVariant::Bool:
        program->setUniformValue(uniformLocation, value.toBool());
        break;
    case QVariant::Color:
        program->setUniformValue(uniformLocation, value.value<QColor>());
        break;
    case QVariant::List:
        setUniformFromFloatList(program, uniformLocation, value.toList());
        break;
    case QVariant::Point:
        program->setUniformValue(uniformLocation, value.toPoint());
        break;
    case QVariant::PointF:
        program->setUniformValue(uniformLocation, value.toPointF());
        break;
    case QVariant::Size:
        program->setUniformValue(uniformLocation, value.toSize());
        break;
    case QVariant::SizeF:
        program->setUniformValue(uniformLocation, value.toSizeF());
        break;
    case QVariant::Matrix4x4:
        program->setUniformValue(uniformLocation, value.value<QMatrix4x4>());
        break;
    case QVariant::Vector2D:
        program->setUniformValue(uniformLocation, value.value<QVector2D>());
        break;
    case QVariant::Vector3D:
        program->setUniformValue(uniformLocation, value.value<QVector3D>());
        break;
    case QVariant::Vector4D:
        program->setUniformValue(uniformLocation, value.value<QVector4D>());
        break;
    case QVariant::String:
        {
            // We assume strings are URLs to images for textures
            QString urlString = value.toString();
            processTextureUrl(uniformLocation, urlString);
        }
        break;
    case QVariant::Image:
        {
            QImage image(value.toString());
            setUniform(uniformLocation, image, painter);
        }
        break;
    default:
        qWarning() << "Unrecognized variant for property " << parent.data()->metaObject()->property(propertyIndex).name() << " of type " << value.typeName() << ", could not set corresponding shader variable";
    }
    return true;
}

void VolumeShaderProgramEffect::update	(	QGLPainter *	painter,
		QGLPainter::Updates	updates
	)

Definition at line 441 of file volumeeffect.cpp.

{
//    painter->glActiveTexture(GL_TEXTURE0 + 0);
//    program()->setUniformValue(m_eyeLocation, painter->);

    if (changedTextures.count() > 0)
    {
        foreach (int i, changedTextures)
        {
            if (!images.contains(i))
            {
                changedTextures.remove(i);
                continue;
            }

            if (!images[i].isNull())
            {
                setUniform(i, images[i], painter);
            } else
            {
                qWarning() << "Warning: VolumeShaderProgramEffect failed to apply texture for uniform" << i << (urls.contains(i) ? QLatin1String(" url: ") + urls[i] : QString());
            }
            changedTextures.remove(i);
        }
    }

    // Update the standard uniform variables.
    QGLShaderProgramEffect::update(painter, updates);

    // Assign custom properties if they exist
    if (!parent.data() || !(propertyIdsToUniformLocations.count() > 0))
        return;

    // update dirty properties and remove them from the list
    int propertyIndex;
    QList<int> propertiesNotUpdated;
    foreach (propertyIndex, dirtyProperties)
    {
        if (!setUniformForPropertyIndex(propertyIndex, painter))
        {
            propertiesNotUpdated.append(propertyIndex);
        };
    }
    dirtyProperties.clear();
    dirtyProperties.append(propertiesNotUpdated);

    // always update the properties we can't track
    foreach (propertyIndex, propertiesWithoutNotificationSignal)
    {
        setUniformForPropertyIndex(propertyIndex, painter);
    }

    // Added specifically for the volume shader effect.
    // This could have been passed more directly, but since we need to
    // know about the scaling, translation and rotation of the item,
    // we might as well calculate the inverse of the modelView matrix
    // to get the true eye position.
    // TODO: For better performance: Intercept the setCamera action in QGLPainter
    // and calculate the proper eye position while calculating the matrices.
    QVector4D inverseColumn3 = painter->modelViewMatrix().top().inverted().column(3);
    program()->setUniformValue(m_eyePositionUniformLocation, inverseColumn3);
}

---

The documentation for this class was generated from the following files:

• /home/svenni/Dropbox/projects/programming/hartree-fock/hartree-fock/hfgui/volumeeffect_p.h
• /home/svenni/Dropbox/projects/programming/hartree-fock/hartree-fock/hfgui/volumeeffect.cpp