Russian Qt Forum

C++ (Qt)
#include "singlepoint.h"
#include <QGLShader>
#include <QGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
#include <QDebug>
 
SinglePoint::SinglePoint(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Single Point");
}
 
void SinglePoint::initializeGL()
{
    glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
    const char * vs_source =
        "#version 420 core                             \n"
        "                                              \n"
        "void main(void)                               \n"
        "{                                             \n"
        "    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);   \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";
    QGLShader* fs = new QGLShader(QGLShader::Fragment);
    fs->compileSourceCode(fs_source);
 
    QGLShader* vs = new QGLShader(QGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 
    program = new QGLShaderProgram(this);
    program->addShader(vs);
    program->addShader(fs);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
}
 
void SinglePoint::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    program->bind();
    glPointSize(40.0f);
    glDrawArrays(GL_POINTS, 0, 1);
    program->release();
}
 

C++ (Qt)
/*
 * Copyright © 2012-2013 Graham Sellers
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#include <sb6.h>
 
class singlepoint_app : public sb6::application
{
    void init()
    {
        static const char title[] = "OpenGL SuperBible - Single Point";
 
        sb6::application::init();
 
        memcpy(info.title, title, sizeof(title));
    }
 
    virtual void startup()
    {
        static const char * vs_source[] =
        {
            "#version 420 core                             \n"
            "                                              \n"
            "void main(void)                               \n"
            "{                                             \n"
            "    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);   \n"
            "}                                             \n"
        };
 
        static 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"
        };
 
        program = glCreateProgram();
        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fs, 1, fs_source, NULL);
        glCompileShader(fs);
 
        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vs, 1, vs_source, NULL);
        glCompileShader(vs);
 
        glAttachShader(program, vs);
        glAttachShader(program, fs);
 
        glLinkProgram(program);
 
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
    }
 
    virtual void render(double currentTime)
    {
        static const GLfloat red[] = { 1.0f, 0.0f, 0.0f, 1.0f };
        glClearBufferfv(GL_COLOR, 0, red);
 
        glUseProgram(program);
 
        glPointSize(40.0f);
 
        glDrawArrays(GL_POINTS, 0, 1);
    }
 
    virtual void shutdown()
    {
        glDeleteVertexArrays(1, &vao);
        glDeleteProgram(program);
    }
 
private:
    GLuint          program;
    GLuint          vao;
};
 
DECLARE_MAIN(singlepoint_app)
 

C++ (Qt)
#include <QGLFormat>
#include <QGLWidget>
#include <QString>
#include <iostream>
#include <QApplication>
 
int main( int argc, char *argv[] )
{
    QApplication app( argc, argv );
 
    QGLFormat format;
    format.setVersion( 4, 3 );
    QGLFormat::setDefaultFormat( format );
 
    QGLWidget w;
    w.makeCurrent();
 
    QString vendor( QLatin1String( reinterpret_cast<const char*>( glGetString( GL_VENDOR ) ) ) );
    std::cout << "Vendor: " << vendor.toStdString() << std::endl;
 
    QString renderer( QLatin1String( reinterpret_cast<const char*>( glGetString( GL_RENDERER ) ) ) );
    std::cout << "Renderer: " << renderer.toStdString() << std::endl;
 
    QString versionOfGL( QLatin1String( reinterpret_cast<const char*>( glGetString( GL_VERSION ) ) ) );
    std::cout << "Version: " << versionOfGL.toStdString() << std::endl;
 
    QString versionGLSL( QLatin1String( reinterpret_cast<const char*>( glGetString( GL_SHADING_LANGUAGE_VERSION ) ) ) );
    std::cout << "GLSL: "<< versionGLSL.toStdString() << std::endl;
 
    return app.exec();
}
 

C++ (Qt)
#include "singletri.h"
#include <QGLShader>
#include <QGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
 
SingleTri::SingleTri(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Single Triangle");
}
 
void SingleTri::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";
    QGLShader* fs = new QGLShader(QGLShader::Fragment);
    fs->compileSourceCode(fs_source);
 
    QGLShader* vs = new QGLShader(QGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 
    program = new QGLShaderProgram(this);
    program->addShader(vs);
    program->addShader(fs);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    program->bind();
}
 
void SingleTri::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}
 
void SingleTri::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 

C++ (Qt)
#include "movingtri.h"
#include <QGLShader>
#include <QGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
#include <QTime>
#include <math.h>
#include <QVector4D>
 
MovingTri::MovingTri(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Moving Triangle");
    time = new QTime;
    time->start();
    startTimer(33);
}
 
MovingTri::~MovingTri()
{
    delete time;
}
 
void MovingTri::initializeGL()
{
    const char * vs_source =
        "#version 410 core                                                 \n"
        "                                                                  \n"
        "layout (location = 0) in vec4 offset;                             \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"
        "    // Add 'offset' to our hard-coded vertex position             \n"
        "    gl_Position = vertices[gl_VertexID] + offset;                 \n"
        "}                                                                 \n";
    const char * fs_source =
        "#version 410 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";
    QGLShader* fs = new QGLShader(QGLShader::Fragment);
    fs->compileSourceCode(fs_source);
 
    QGLShader* vs = new QGLShader(QGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 
    program = new QGLShaderProgram(this);
    program->addShader(vs);
    program->addShader(fs);
    program->link();
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    program->bind();
}
 
void MovingTri::paintGL()
{
    GLfloat currentTime = time->elapsed() / 1000.0f;
 
    glClearColor(sinf(currentTime) * 0.5f + 0.5f,
                 cosf(currentTime) * 0.5f + 0.5f,
                 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
 
 
    QVector4D attrib
    (
        sinf(currentTime) * 0.5f,
        cosf(currentTime) * 0.6f,
        0.0f,
        0.0f
    );
 
    program->setAttributeValue(0, attrib);
 
    glDrawArrays(GL_TRIANGLES, 0, 3);
}
 
void MovingTri::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 
void MovingTri::timerEvent(QTimerEvent *)
{
    updateGL();
}
 

C++ (Qt)
    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";
 

C++ (Qt)
glBegin(GL_TRIANGLES);
    for (int gl_VertexID = 0; gl_VertexID < 3; gl_VertexID++)
        ....
glEnd();

C++ (Qt)
#include "tessellatedtri.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
 
TessellatedTri::TessellatedTri(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Tessellated Triangle");
}
 
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 TessellatedTri::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_PATCHES, 0, 3);
}
 
void TessellatedTri::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 

C++ (Qt)
    QGLShader* fs = new QGLShader(QGLShader::Fragment);
    fs->compileSourceCode(fs_source);
 
    QGLShader* vs = new QGLShader(QGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 

C++ (Qt)
    program->addShader(vs);
    program->addShader(fs);
 

C++ (Qt)
program->link();
 

C++ (Qt)
program->bind();
 

C++ (Qt)
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
 

C++ (Qt)
#include "tessellatedgstri.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
 
TessellatedGsTri::TessellatedGsTri(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Tessellated Geometry Shader Triangle");
}
 
void TessellatedGsTri::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";
 
    static const char * gs_source =
            "#version 420 core                                                                  \n"
            "                                                                                   \n"
            "layout (triangles) in;                                                             \n"
            "layout (points, max_vertices = 3) out;                                             \n"
            "                                                                                   \n"
            "void main(void)                                                                    \n"
            "{                                                                                  \n"
            "    int i;                                                                         \n"
            "                                                                                   \n"
            "    for (i = 0; i < gl_in.length(); i++)                                           \n"
            "    {                                                                              \n"
            "        gl_Position = gl_in[i].gl_Position;                                        \n"
            "        EmitVertex();                                                              \n"
            "    }                                                                              \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);
 
    QOpenGLShader* gs = new QOpenGLShader(QOpenGLShader::Geometry, this);
    gs->compileSourceCode(gs_source);
 
    program = new QOpenGLShaderProgram(this);
    program->addShader(vs);
    program->addShader(tcs);
    program->addShader(tes);
    program->addShader(gs);
    program->addShader(fs);
    program->link();
 
    glPointSize(5.0f);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    program->bind();
}
 
void TessellatedGsTri::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_PATCHES, 0, 3);
}
 
void TessellatedGsTri::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 

C++ (Qt)
QOpenGLShader::Vertex
QOpenGLShader::Fragment
QOpenGLShader::Geometry
QOpenGLShader::TessellationControl
QOpenGLShader::TessellationEvaluation
QOpenGLShader::Compute
 

C++ (Qt)
#include "fragcolorfrompos.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
 
FragColorFromPos::FragColorFromPos(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Fragment color from position");
    startTimer(1000);
    interpolate = false;
}
 
void FragColorFromPos::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(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(fs_source);
 
    QOpenGLShader* vs = new QOpenGLShader(QOpenGLShader::Vertex);
    vs->compileSourceCode(vs_source);
 
    nonInterpolateProgram = new QOpenGLShaderProgram(this);
    nonInterpolateProgram->addShader(vs);
    nonInterpolateProgram->addShader(fs);
    nonInterpolateProgram->link();
 
 
    const char * vsInterpolate_source =
        "#version 420 core                                                          \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 * fsInterpolate_source =
        "#version 420 core                                                          \n"
        "                                                                           \n"
        "in vec4 vs_color;                                                          \n"
        "out vec4 color;                                                            \n"
        "                                                                           \n"
        "void main(void)                                                            \n"
        "{                                                                          \n"
        "    color = vs_color;                                                      \n"
        "}                                                                          \n";
    fs->compileSourceCode(fsInterpolate_source);
 
    vs->compileSourceCode(vsInterpolate_source);
 
 
    interpolateProgram = new QOpenGLShaderProgram(this);
    interpolateProgram->addShader(vs);
    interpolateProgram->addShader(fs);
 
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->bind();
    nonInterpolateProgram->bind();
}
 
void FragColorFromPos::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}
 
void FragColorFromPos::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 
void FragColorFromPos::timerEvent(QTimerEvent *)
{
    interpolate = !interpolate;
    if (interpolate)
        interpolateProgram->bind();
    else
        nonInterpolateProgram->bind();
    updateGL();
}
 

out vec4 color

const vec4 vertices[] = vec4[](vec4( 0.25, -0.25, 0.5, 1.0)
vec4(-0.25, -0.25, 0.5, 1.0),
vec4( 0.25,  0.25, 0.5, 1.0));

C++ (Qt)
glDrawArrays(GL_TRIANGLES, 0, 3);

C++ (Qt)
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
    .....
        glGenBuffers(1, &buffer);
        glBindBuffer(GL_ARRAY_BUFFER, buffer);
        glBufferData(GL_ARRAY_BUFFER,
                     sizeof(vertex_positions),
                     vertex_positions,
                     GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
        glEnableVertexAttribArray(0);
 

C++ (Qt)
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->create();
    vao->bind();
 
    QOpenGLBuffer* buffer = new QOpenGLBuffer;
    buffer->create();
    buffer->bind();
    buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
    buffer->allocate(vertex_positions, sizeof(vertex_positions));
 
    program->setAttributeBuffer(0, GL_FLOAT, 0, 3);
    program->enableAttributeArray(0);
 

C++ (Qt)
#include "spinnycube.h"
#include <QOpenGLShader>
#include <QOpenGLBuffer>
#include <QMatrix4x4>
#include <QDebug>
#include <QTime>
#include <math.h>
 
SpinnyCube::SpinnyCube(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Spinny Cube");
 
    proj_matrix = new QMatrix4x4;
    program = new QOpenGLShaderProgram;
    time = new QTime;
    many = false;
    time->start();
    startTimer(16);
}
SpinnyCube::~SpinnyCube()
{
    delete proj_matrix;
    delete time;
}
 
void SpinnyCube::initializeGL()
{
    glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
    glClearDepth(1.0f);
 
    const char * vs_source =
    {
        "#version 410 core                                                  \n"
        "                                                                   \n"
        "in vec4 position;                                                  \n"
        "                                                                   \n"
        "out VS_OUT                                                         \n"
        "{                                                                  \n"
        "    vec4 color;                                                    \n"
        "} vs_out;                                                          \n"
        "                                                                   \n"
        "uniform mat4 mv_matrix;                                            \n"
        "uniform mat4 proj_matrix;                                          \n"
        "                                                                   \n"
        "void main(void)                                                    \n"
        "{                                                                  \n"
        "    gl_Position = proj_matrix * mv_matrix * position;              \n"
        "    vs_out.color = position * 2.0 + vec4(0.5, 0.5, 0.5, 0.0);      \n"
        "}                                                                  \n"
    };
 
    const char * fs_source =
    {
        "#version 410 core                                                  \n"
        "                                                                   \n"
        "out vec4 color;                                                    \n"
        "                                                                   \n"
        "in VS_OUT                                                          \n"
        "{                                                                  \n"
        "    vec4 color;                                                    \n"
        "} fs_in;                                                           \n"
        "                                                                   \n"
        "void main(void)                                                    \n"
        "{                                                                  \n"
        "    color = fs_in.color;                                           \n"
        "}                                                                  \n"
    };
 
    program->addShaderFromSourceCode(QOpenGLShader::Fragment, fs_source);
    program->addShaderFromSourceCode(QOpenGLShader::Vertex, vs_source);
    program->link();
 
    mv_location = program->uniformLocation("mv_matrix");
    proj_location = program->uniformLocation("proj_matrix");
 
//    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
//    vao->bind();
 
    static const GLfloat vertex_positions[] =
    {
        -0.25f,  0.25f, -0.25f,
        -0.25f, -0.25f, -0.25f,
         0.25f, -0.25f, -0.25f,
 
         0.25f, -0.25f, -0.25f,
         0.25f,  0.25f, -0.25f,
        -0.25f,  0.25f, -0.25f,
 
         0.25f, -0.25f, -0.25f,
         0.25f, -0.25f,  0.25f,
         0.25f,  0.25f, -0.25f,
 
         0.25f, -0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,
         0.25f,  0.25f, -0.25f,
 
         0.25f, -0.25f,  0.25f,
        -0.25f, -0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,
 
        -0.25f, -0.25f,  0.25f,
        -0.25f,  0.25f,  0.25f,
         0.25f,  0.25f,  0.25f,
 
        -0.25f, -0.25f,  0.25f,
        -0.25f, -0.25f, -0.25f,
        -0.25f,  0.25f,  0.25f,
 
        -0.25f, -0.25f, -0.25f,
        -0.25f,  0.25f, -0.25f,
        -0.25f,  0.25f,  0.25f,
 
        -0.25f, -0.25f,  0.25f,
         0.25f, -0.25f,  0.25f,
         0.25f, -0.25f, -0.25f,
 
         0.25f, -0.25f, -0.25f,
        -0.25f, -0.25f, -0.25f,
        -0.25f, -0.25f,  0.25f,
 
        -0.25f,  0.25f, -0.25f,
         0.25f,  0.25f, -0.25f,
         0.25f,  0.25f,  0.25f,
 
         0.25f,  0.25f,  0.25f,
        -0.25f,  0.25f,  0.25f,
        -0.25f,  0.25f, -0.25f
    };
 
    QOpenGLBuffer* buffer = new QOpenGLBuffer;
    buffer->create();
    buffer->bind();
    buffer->allocate(vertex_positions, sizeof(vertex_positions));
    buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
 
    program->setAttributeArray(0, GL_FLOAT, NULL, 3);
    program->enableAttributeArray(0);
 
    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CW);
 
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
 
}
 
 
void SpinnyCube::paintGL()
{
    float currentTime = time->elapsed() / 1000.0f;
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    program->bind();
    program->setUniformValue(proj_location, *proj_matrix);
 
    if (many)
    {
        int i;
        for (i = 0; i < 24; i++)
        {
            float f = i + currentTime * 0.3f;
            QMatrix4x4 mv_matrix;
            mv_matrix.translate(0.0f, 0.0f, -6.0f);
            mv_matrix.rotate(currentTime * 45.0f, 0.0f, 1.0f, 0.0f);
            mv_matrix.rotate(currentTime * 21.0f, 1.0f, 0.0f, 0.0f);
            mv_matrix.translate(sinf(2.1f * f) * 2.0f,
                                cosf(1.7f * f) * 2.0f,
                                sinf(1.3f * f) * cosf(1.5f * f) * 2.0f);
            program->setUniformValue(mv_location, mv_matrix);
            glDrawArrays(GL_TRIANGLES, 0, 36);
        }
    }
    else
    {
        float f = currentTime * 0.3f;
        QMatrix4x4 mv_matrix;
        mv_matrix.translate(0.0f, 0.0f, -4.0f);
        mv_matrix.translate(sinf(2.1f * f) * 0.5f,
                            cosf(1.7f * f) * 0.5f,
                            sinf(1.3f * f) * cosf(1.5f * f) * 2.0f);
        mv_matrix.rotate(currentTime * 45.0f, 0.0f, 1.0f, 0.0f);
        mv_matrix.rotate(currentTime * 81.0f, 1.0f, 0.0f, 0.0f);
        program->setUniformValue(mv_location, mv_matrix);
        glDrawArrays(GL_TRIANGLES, 0, 36);
    }
}
 
void SpinnyCube::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
    float aspect = static_cast<float>(w) / static_cast<float>(h);
    proj_matrix->setToIdentity();
    proj_matrix->perspective(50.0f, aspect, 0.1f, 1000.0f);
}
 
void SpinnyCube::timerEvent(QTimerEvent *)
{
    if (time->elapsed() % 4000 < 2000)
        many = false;
    else
        many = true;
    updateGL();
}
 

C++ (Qt)
gl_Position = proj_matrix * mv_matrix * position;

C++ (Qt)
        glGenBuffers(1, &buffer);
        glBindBuffer(GL_ARRAY_BUFFER, buffer);
        glBufferData(GL_ARRAY_BUFFER,
                     sizeof(vertex_positions),
                     vertex_positions,
                     GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
 

C++ (Qt)
    QOpenGLVertexArrayObject* vao = new QOpenGLVertexArrayObject(this);
    vao->create();
    vao->bind();
 
    QOpenGLBuffer* buffer = new QOpenGLBuffer;
    buffer->create();
    buffer->bind();
    buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
    buffer->allocate(vertex_positions, sizeof(vertex_positions));
 
    program->setAttributeBuffer(0, GL_FLOAT, 0, 3);
    program->enableAttributeArray(0);
 

C++ (Qt)
int loc = program->attributeLocation("posAttr");

C++ (Qt)
int loc = program->attributeLocation("posAttr");

C++ (Qt)
void QGLShaderProgram::setAttributeBuffer ( int location, GLenum type, int offset, int tupleSize, int stride = 0 )

C++ (Qt)
    glVertexPointer(3, GL_FLOAT, 0, VertexArray);
    glTexCoordPointer(2, GL_FLOAT, 0, TextureArray);
    glDrawElements(GL_TRIANGLES, 24, GL_UNSIGNED_INT, IndexArray);
 

C++ (Qt)
#ifndef SIMPLETEXTURE_H
#define SIMPLETEXTURE_H
 
#include <QGLWidget>
 
class QOpenGLShaderProgram;
class QOpenGLVertexArrayObject;
class QOpenGLTexture;
 
class SimpleTexture : public QGLWidget
{
    Q_OBJECT
public:
    explicit SimpleTexture(QWidget *parent = 0);
//    ~SimpleTexture();
 
signals:
 
public slots:
 
private:
    void initializeGL();
    void paintGL();
    void resizeGL(int w, int h);
 
    QOpenGLShaderProgram* program;
    QOpenGLTexture* texture;
void generate_texture(float * data, int width, int height)
{
    int x, y;
 
    for (y = 0; y < height; y++)
    {
        for (x = 0; x < width; x++)
        {
            data[(y * width + x) * 4 + 0] = (float)((x & y) & 0xFF) / 255.0f;
            data[(y * width + x) * 4 + 1] = (float)((x | y) & 0xFF) / 255.0f;
            data[(y * width + x) * 4 + 2] = (float)((x ^ y) & 0xFF) / 255.0f;
            data[(y * width + x) * 4 + 3] = 1.0f;
        }
    }
}
 
};
 
#endif // SIMPLETEXTURE_H
 

C++ (Qt)
#include "simpletexture.h"
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QOpenGLVertexArrayObject>
#include <QPainter>
#include <QOpenGLTexture>
 
const char* vs_source =
    "#version 420 core                                                              \n"
    "                                                                               \n"
    "void main(void)                                                                \n"
    "{                                                                              \n"
    "    const vec4 vertices[] = vec4[](vec4( 0.75, -0.75, 0.5, 1.0),               \n"
    "                                   vec4(-0.75, -0.75, 0.5, 1.0),               \n"
    "                                   vec4( 0.75,  0.75, 0.5, 1.0));              \n"
    "                                                                               \n"
    "    gl_Position = vertices[gl_VertexID];                                       \n"
    "}                                                                              \n";
const char* fs_source =
    "#version 430 core                                                              \n"
    "                                                                               \n"
    "uniform sampler2D s;                                                           \n"
    "                                                                               \n"
    "out vec4 color;                                                                \n"
    "                                                                               \n"
    "void main(void)                                                                \n"
    "{                                                                              \n"
    "    color = texture(s, gl_FragCoord.xy / textureSize(s, 0));                   \n"
    "}                                                                              \n";
 
SimpleTexture::SimpleTexture(QWidget *parent) :
    QGLWidget(parent)
{
    setWindowTitle("Simple Texture");
    program = new QOpenGLShaderProgram(this);
    texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
}
 
//SimpleTexture::~SimpleTexture()
//{
//    delete texture;
//}
 
void SimpleTexture::initializeGL()
{
    glClearColor(0.0f, 0.25f, 0.0f, 1.0f);
 
    texture->create();
    texture->bind();
    texture->setMipLevels(8);
    texture->setFormat(QOpenGLTexture::RGBA32F);
    texture->setSize(256, 256);
    texture->allocateStorage();
 
 
    float data[256 * 256 * 4];
    generate_texture(data, 256, 256);
 
    texture->setData(QOpenGLTexture::RGBA, QOpenGLTexture::Float32, data);
 
    program->addShaderFromSourceCode(QOpenGLShader::Vertex, vs_source);
    program->addShaderFromSourceCode(QOpenGLShader::Fragment, fs_source);
    program->bind();
}
 
void SimpleTexture::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
}
 
void SimpleTexture::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 

C++ (Qt)
#ifndef ALIENRAIN_H
#define ALIENRAIN_H
 
#include <QGLWidget>
 
class QOpenGLShaderProgram;
class QOpenGLFunctions_4_3_Compatibility;
class QTime;
class QOpenGLTexture;
class QOpenGLBuffer;
 
class AlienRain : public QGLWidget
{
	Q_OBJECT
 
public:
	AlienRain(QWidget *parent = 0);
	~AlienRain();
 
private:
 
	void initializeGL();
	void resizeGL(int w, int h);
	void paintGL();
	void timerEvent(QTimerEvent*);
 
	QOpenGLFunctions_4_3_Compatibility* ogl;
	QTime* time;
    QOpenGLShaderProgram* program;
    QOpenGLTexture* texture;
    QOpenGLBuffer* buffer;
 
protected:
	float           droplet_x_offset[256];
	float           droplet_rot_speed[256];
	float           droplet_fall_speed[256];
 
};
 
#endif // ALIENRAIN_H
 

C++ (Qt)
#include "alienrain.h"
 
#include <QOpenGLFunctions_4_3_Compatibility>
#include <qopengltexture.h>
#include <QDebug>
#include <cmath>
#include "ktx.h"
#include <qdatetime.h>
#include <QOpenGLShaderProgram>
#include <QOpenGLShader>
#include <QOpenGLTexture>
#include <QOpenGLBuffer>
 
typedef float vec4[4];
 
// Random number generator
static unsigned int seed = 0x13371337;
 
 
static inline float random_float()
{
	float res;
	unsigned int tmp;
 
	seed *= 16807;
 
	tmp = seed ^ (seed >> 4) ^ (seed << 15);
 
	*((unsigned int *)&res) = (tmp >> 9) | 0x3F800000;
 
	return (res - 1.0f);
}
 
 
AlienRain::AlienRain(QWidget *parent)
	: QGLWidget(parent)
{
	setWindowTitle("Alien Rain");
 
	ogl = new QOpenGLFunctions_4_3_Compatibility;
	time = new QTime;
	time->start();
    program = new QOpenGLShaderProgram;
    buffer = new QOpenGLBuffer(static_cast<QOpenGLBuffer::Type>(GL_UNIFORM_BUFFER));
    texture = 0;
    startTimer(16);
}
 
AlienRain::~AlienRain()
{
	delete ogl;
	delete time;
    delete program;
    delete buffer;
    if (texture)
        delete texture;
}
 
void AlienRain::initializeGL()
{
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	ogl->initializeOpenGLFunctions();
 
    program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/alienrain.vert");
    program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/alienrain.frag");
    program->bind();
 
    texture = ktx::load("D:/Docs/GLSL/media/textures/aliens.ktx");
    texture->bind();
 
 
    buffer->create();
    buffer->bind();
    buffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
    buffer->allocate(256 * sizeof(vec4));
 
	for (int i = 0; i < 256; i++)
	{
		droplet_x_offset[i] = random_float() * 2.0f - 1.0f;
		droplet_rot_speed[i] = (random_float() + 0.5f) * ((i & 1) ? -3.0f : 3.0f);
		droplet_fall_speed[i] = random_float() + 0.2f;
	}
 
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
 
void AlienRain::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);
}
 
void AlienRain::paintGL()
{
	float t = time->elapsed() / 1000.0f;
 
    glClear(GL_COLOR_BUFFER_BIT);
    program->bind();
 
    ogl->glBindBufferBase(buffer->type(), 0, buffer->bufferId());
 
    vec4* droplet = (vec4*) buffer->map(QOpenGLBuffer::WriteOnly);
	for (int i = 0; i < 256; i++)
	{
		droplet[i][0] = droplet_x_offset[i];
		droplet[i][1] = 2.0f - fmodf((t + float(i)) * droplet_fall_speed[i], 4.31f);
		droplet[i][2] = t * droplet_rot_speed[i];
		droplet[i][3] = 0.0f;
	}
    buffer->unmap();
 
	int alien_index;
	for (alien_index = 0; alien_index < 256; alien_index++)
	{
        ogl->glVertexAttribI1i(0, alien_index);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
	}
}
 
void AlienRain::timerEvent(QTimerEvent*)
{
	updateGL();
}
 

C++ (Qt)
#version 410 core
 
layout (location = 0) in int alien_index;
 
out VS_OUT
{
    flat int alien;
    vec2 tc;
} vs_out;
 
struct droplet_t
{
    float x_offset;
    float y_offset;
    float orientation;
    float unused;
};
 
layout (std140) uniform droplets
{
    droplet_t droplet[256];
};
 
void main(void)
{
    const vec2[4] position = vec2[4](vec2(-0.5, -0.5),
                                     vec2( 0.5, -0.5),
                                     vec2(-0.5,  0.5),
                                     vec2( 0.5,  0.5));
    vs_out.tc = position[gl_VertexID].xy + vec2(0.5);
    float co = cos(droplet[alien_index].orientation);
    float so = sin(droplet[alien_index].orientation);
    mat2 rot = mat2(vec2(co, so),
                    vec2(-so, co));
    vec2 pos = 0.25 * rot * position[gl_VertexID];
    gl_Position = vec4(pos.x + droplet[alien_index].x_offset,
                       pos.y + droplet[alien_index].y_offset,
                       0.5, 1.0);
    vs_out.alien = alien_index % 64;
}
 

C++ (Qt)
#version 410 core
 
layout (location = 0) out vec4 color;
 
in VS_OUT
{
    flat int alien;
    vec2 tc;
} fs_in;
 
uniform sampler2DArray tex_aliens;
 
void main(void)
{
    color = texture(tex_aliens, vec3(fs_in.tc, float(fs_in.alien)));
}
 

C++ (Qt)
#ifndef KTX_H
#define KTX_H
 
class QOpenGLTexture;
 
namespace ktx
{
 
	struct header
	{
		unsigned char identifier[12];
		unsigned int endianness;
		unsigned int gltype;
		unsigned int gltypesize;
		unsigned int glformat;
		unsigned int glinternalformat;
		unsigned int glbaseinternalformat;
		unsigned int pixelwidth;
		unsigned int pixelheight;
		unsigned int pixeldepth;
		unsigned int arrayelements;
		unsigned int faces;
		unsigned int miplevels;
		unsigned int keypairbytes;
	};
 
	union keyvaluepair
	{
		unsigned int size;
		unsigned char rawbytes[4];
	};
 
	QOpenGLTexture* load(const char * filename, unsigned int tex = 0);
 
}
 
#endif // KTX_H
 

C++ (Qt)
#include "ktx.h"
#include <QFile>
#include <QOpenGLTexture>
#include <QOpenGLFunctions_4_3_Core>
#include <QDebug>
 
namespace ktx
{
 
	static const unsigned char identifier[] =
	{
		0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
	};
 
	static const unsigned int swap32(const unsigned int u32)
	{
		union
		{
			unsigned int u32;
			unsigned char u8[4];
		} a, b;
 
		a.u32 = u32;
		for (int i = 0; i < 4; i++)
			b.u8[i] = a.u8[3 - i];
 
		return b.u32;
	}
 
 
	QOpenGLTexture* load(const char * filename, unsigned int tex)
	{
        QOpenGLFunctions_4_3_Core ogl;
        ogl.initializeOpenGLFunctions();
		QFile file(filename);
		GLuint temp = 0;
		header h;
		size_t data_start, data_end;
		QVector<unsigned char> data;
		QOpenGLTexture::Target target = static_cast<QOpenGLTexture::Target>(0);
 
		if (!file.open(QFile::ReadOnly))
		{
			qDebug() << "KTX not opened";
			return 0;
		}
 
		if (file.read(reinterpret_cast<char*>(&h), sizeof(h)) != sizeof(h))
		{
			qDebug() << "KTX header read error";
			return 0;
		}
 
		if (QString::compare(
			QByteArray(reinterpret_cast<const char*>(identifier), sizeof(identifier)),
			QByteArray(reinterpret_cast<const char*>(h.identifier), sizeof(h.identifier))))
		{
			qDebug() << "KTX bad header";
			return 0;
		}
 
		if (h.endianness == 0x01020304)
		{
			h.endianness = swap32(h.endianness);
			h.gltype = swap32(h.gltype);
			h.gltypesize = swap32(h.gltypesize);
			h.glformat = swap32(h.glformat);
			h.glinternalformat = swap32(h.glinternalformat);
			h.glbaseinternalformat = swap32(h.glbaseinternalformat);
			h.pixelwidth = swap32(h.pixelwidth);
			h.pixelheight = swap32(h.pixelheight);
			h.pixeldepth = swap32(h.pixeldepth);
			h.arrayelements = swap32(h.arrayelements);
			h.faces = swap32(h.faces);
			h.miplevels = swap32(h.miplevels);
			h.keypairbytes = swap32(h.keypairbytes);
		}
 
		else if (h.endianness != 0x04030201)
		{
			qDebug() << "KTX bad header";
			return 0;
		}
 
		// Guess target (texture type)
		if (h.pixelheight == 0)
		{
			if (h.arrayelements == 0)
				target = QOpenGLTexture::Target1D;
			else
				target = QOpenGLTexture::Target1DArray;
		}
		else if (h.pixeldepth == 0)
		{
			if (h.arrayelements == 0)
			{
				if (h.faces == 0)
					target = QOpenGLTexture::Target2D;
				else
					target = QOpenGLTexture::TargetCubeMap;
			}
			else
			{
				if (h.faces == 0)
					target = QOpenGLTexture::Target2DArray;
				else
					target = QOpenGLTexture::TargetCubeMapArray;
			}
		}
		else
			target = QOpenGLTexture::Target3D;
 
		// Check for insanity...
		if (target == 0 ||                                    // Couldn't figure out target
			(h.pixelwidth == 0) ||                                  // Texture has no width???
			(h.pixelheight == 0 && h.pixeldepth != 0))              // Texture has depth but no height???
		{
			qDebug() << "KTX bad header";
			return 0;
		}
 
		temp = tex;
 
		QOpenGLTexture* texture = new QOpenGLTexture(target);
		texture->create();
		texture->bind();
		tex = texture->textureId();
 
		data_start = file.pos();
		data_end = file.size();
 
		data.resize(data_end - data_start);
		data.fill(0);
 
		file.read(reinterpret_cast<char*>(data.data()), data.size());
 
		if (h.miplevels == 0)
		{
			h.miplevels = 1;
		}
 
		switch (target)
		{
		case QOpenGLTexture::Target1D:
			//                glTexStorage1D(GL_TEXTURE_1D, h.miplevels, h.glinternalformat, h.pixelwidth);
			//                glTexSubImage1D(GL_TEXTURE_1D, 0, 0, h.pixelwidth, h.glformat, h.glinternalformat, data);
			break;
		case QOpenGLTexture::Target2D:
			//                glTexStorage2D(GL_TEXTURE_2D, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight);
			//                {
			//                    unsigned char * ptr = data;
			//                    unsigned int height = h.pixelheight;
			//                    unsigned int width = h.pixelwidth;
			//                    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
			//                    for (unsigned int i = 0; i < h.miplevels; i++)
			//                    {
			//                        glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, width, height, h.glformat, h.gltype, ptr);
			//                        ptr += height * calculate_stride(h, width, 1);
			//                        height >>= 1;
			//                        width >>= 1;
			//                        if (!height)
			//                            height = 1;
			//                        if (!width)
			//                            width = 1;
			//                    }
			//                }
			break;
		case QOpenGLTexture::Target3D:
			//                glTexStorage3D(GL_TEXTURE_3D, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight, h.pixeldepth);
			//                glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, h.pixelwidth, h.pixelheight, h.pixeldepth, h.glformat, h.gltype, data);
			break;
		case QOpenGLTexture::Target1DArray:
			//                glTexStorage2D(GL_TEXTURE_1D_ARRAY, h.miplevels, h.glinternalformat, h.pixelwidth, h.arrayelements);
			//                glTexSubImage2D(GL_TEXTURE_1D_ARRAY, 0, 0, 0, h.pixelwidth, h.arrayelements, h.glformat, h.gltype, data);
			break;
		case QOpenGLTexture::Target2DArray:
//			texture->setMipLevels(h.miplevels);
//			texture->setSize(h.pixelwidth, h.pixelheight, h.pixeldepth);
//			texture->setLayers(h.arrayelements);
//			texture->allocateStorage();
 
//			texture->setData(static_cast<QOpenGLTexture::PixelFormat> (h.glformat),
//				static_cast<QOpenGLTexture::PixelType> (h.gltype),
//				data.data());
 
			//                glTexStorage3D(GL_TEXTURE_2D_ARRAY, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight, h.arrayelements);
			//                glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, h.pixelwidth, h.pixelheight, h.arrayelements, h.glformat, h.gltype, data);
            ogl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight, h.arrayelements);
            ogl.glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, h.pixelwidth, h.pixelheight, h.arrayelements, h.glformat, h.gltype, data.data());
			break;
		case QOpenGLTexture::TargetCubeMap:
			//                glTexStorage2D(GL_TEXTURE_CUBE_MAP, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight);
			// glTexSubImage3D(GL_TEXTURE_CUBE_MAP, 0, 0, 0, 0, h.pixelwidth, h.pixelheight, h.faces, h.glformat, h.gltype, data);
			//                {
			//                    unsigned int face_size = calculate_face_size(h);
			//                    for (unsigned int i = 0; i < h.faces; i++)
			//                    {
			//                        glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, h.pixelwidth, h.pixelheight, h.glformat, h.gltype, data + face_size * i);
			//                    }
			//                }
			break;
		case QOpenGLTexture::TargetCubeMapArray:
			//                glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, h.miplevels, h.glinternalformat, h.pixelwidth, h.pixelheight, h.arrayelements);
			//                glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, 0, h.pixelwidth, h.pixelheight, h.faces * h.arrayelements, h.glformat, h.gltype, data);
			break;
		}
		//        if (h.miplevels == 1)
		//                texture->generateMipMaps();
		return texture;
	}
 
}