#include "mainwindow.h"

 #include <QApplication>

 #include "test01.h"

 int main(int argc, char *argv[])

 {

     QApplication a(argc, argv);

 //    MainWindow w;

     test01 w;

     w.show();

     return a.exec();

 }

 #ifndef __TEST_01_H__

 #define __TEST_01_H__

 #include <iostream>

 #include <string>

 using namespace std;

 //openGL窗口相关文件

 #include <QOpenGLWidget>

 #include <QOpenGLFunctions_3_3_Core>

 #include <QMatrix4x4>

 class test01 :public QOpenGLWidget, public QOpenGLFunctions_3_3_Core

 {

     Q_OBJECT

 public:

     explicit test01(QWidget *parent = );

     ~test01();

 public:

     virtual void initializeGL();

     virtual void resizeGL(int w, int h);// ZC: 不处理窗口大小变化

     virtual void paintGL();

 private:

     unsigned int FuiProgramID;

     GLuint Fvbo;

 public:

     GLuint FuiMVP;

     QMatrix4x4 Fmodel;

     QMatrix4x4 Fview;

     QMatrix4x4 Fprojection;

     QMatrix4x4 Fmvp;

 public:

     int ShaderLoad_Z(

             const QString &_strFullFileName_ShaderVertex,

             const QString &_strFullFileName_ShaderFregment);

     bool CheckCompileErrors(unsigned int _shader, const std::string &_strType);

 };

 #endif // __TEST_01_H__

 #include "test01.h"

 #include <QFile>

 #include <QTextStream>

 #include <iostream>

 using namespace std;

 test01::test01(QWidget *parent): QOpenGLWidget(parent)

 {

     //设置OpenGL的版本信息

     QSurfaceFormat format;

     format.setRenderableType(QSurfaceFormat::OpenGL);

     format.setProfile(QSurfaceFormat::CoreProfile);

     format.setVersion(,);

 //    format.setVersion(2,0);

     setFormat(format);

   // *** *** ***

     FuiProgramID = ;

 }

 test01::~test01()

 {}

 void test01::initializeGL()

 {

     // Initialize OpenGL Backend

     initializeOpenGLFunctions();

     // ZC: 刷背景色

     // Set global information

     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

     // ZC: 在类test01的构造函数中，如果指明使用3.x版本的OpenGL的话，下面3句代码是必须的(至少Qt中是这样的，C++的使用glfw时 我暂时不知道 如何指定使用哪个版本的OpenGL)

     unsigned int VAO;

     glGenVertexArrays(, &VAO);

     glBindVertexArray(VAO);

     // 创建着色器对象

     ShaderLoad_Z(":/test01/shaders/test01/ShaderVertex.glsl", ":/test01/shaders/test01/ShaderFragment.glsl");

   // *** *** ***

     FuiMVP = glGetUniformLocation(FuiProgramID, "MVP");

     // ZC: MVP设置：(3步骤)

     {

         // ZC: (1)MVP中的 P

         // ZC:  投射矩阵的设置在 resizeGL(...)中

         // ZC: (2)MVP中的 V

         Fview.lookAt(

                     QVector3D(, , ),// Camera is at (4,3,3), in World Space

                     QVector3D(, , ), // and looks at the origin

                     QVector3D(, , )  // Head is up (set to 0,-1,0 to look upside-down)

                     );

         // ZC: (3)MVP中的 M

         Fmodel.setToIdentity();

 //        model.translate();

 //        model.rotate();

     }

   // *** *** ***

 //    static const GLfloat g_vertex_buffer_data[] = {

 //        -0.8f, -0.8f, -10.0f,

 //        0.8f, -0.8f, -10.0f,

 //        0.0f,  0.8f, -10.0f,

 //    };

     static const GLfloat g_vertex_buffer_data[] = {

         -1.0f, -1.0f, 0.0f,

         1.0f, -1.0f, 0.0f,

         0.0f,  1.0f, 0.0f,

     };

     glGenBuffers(, &Fvbo);

     glBindBuffer(GL_ARRAY_BUFFER, Fvbo);

     glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

   // ***

     glEnable(GL_DEPTH_TEST);

     glPointSize();

 //    cout << "test01::initializeGL() out" << endl;

 }

 void test01::resizeGL(int w, int h)

 {

     qDebug() << "MainWidget::resizeGL(...)";

     // Set OpenGL viewport to cover whole widget

     glViewport(, , w, h);

     // ZC: 下面是 投射矩阵相关

     {

             // Calculate aspect ratio

             qreal aspect = qreal(w) / qreal(h ? h : );

             // Set near plane to 3.0, far plane to 7.0, field of view 45 degrees

         //    const qreal zNear = 3.0, zFar = 7.0, fov = 45.0;

             const qreal zNear = 0.1, zFar = 100.0, fov = 45.0;

             // Reset projection

             Fprojection.setToIdentity();

             // Set perspective projection

             Fprojection.perspective(fov, aspect, zNear, zFar);

     }

     Fmvp = Fprojection * Fview * Fmodel;

 }

 void test01::paintGL()

 {

 //    cout << "test01::paintGL()" << endl;

     //每次绘图前清理屏幕，否则会有残影

     //glClearColor(0.2f, 0.3f, 0.3f, 1.0f);

     glClearColor(0.0f, 0.0f, 1.0f, 1.0f);

     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 // ***

     glUseProgram( FuiProgramID );

     glUniformMatrix4fv(FuiMVP, , GL_FALSE, Fmvp.data());

     // ZC: 这下面的参数"0"应该是对应顶点着色器的layout的location序号(我记得在哪里看到有函数可以通过变量名取到这个序号的)

     glEnableVertexAttribArray();

         glBindBuffer(GL_ARRAY_BUFFER, Fvbo);

         glVertexAttribPointer(

             ,                  // attribute. No particular reason for 0, but must match the layout in the shader.

             ,                  // size

             GL_FLOAT,           // type

             GL_FALSE,           // normalized?

             ,                  // stride

             (void*)            // array buffer offset

             );

         glDrawArrays(GL_TRIANGLES, , ); // 3 indices starting at 0 -> 1 triangle

     glDisableVertexAttribArray();

 }

 int test01::ShaderLoad_Z(const QString &_strFullFileName_ShaderVertex, const QString &_strFullFileName_ShaderFregment)

 {

     // ZC: 着色器文件-->着色器字符串

     QFile file1( _strFullFileName_ShaderVertex );

     file1.open(QIODevice::ReadOnly);

     QTextStream in1(&file1);

     // 将文本流读取到字符串中：

     string strShaderVertex = in1.readAll().toStdString();

     file1.close();

     QFile file2( _strFullFileName_ShaderFregment );

     file2.open(QIODevice::ReadOnly);

     QTextStream in2(&file2);

     // 将文本流读取到字符串中：

     string strShaderFregment = in2.readAll().toStdString();

     file2.close();

 //    cout << "strShaderVertex : " << strShaderVertex << endl;

 //    cout << "strShaderFregment : " << strShaderFregment << endl;

 // *** *** *** ***

     const char* pcShaderVertex  = strShaderVertex.c_str();

     const char* pcShaderFregment= strShaderFregment.c_str();

     // 编辑编译着色器

     unsigned int shaderVertex;// vertex, fragment;

     unsigned int shaderFregment;

     // 顶点着色器

     shaderVertex = glCreateShader(GL_VERTEX_SHADER);

     glShaderSource(shaderVertex, , &pcShaderVertex, NULL);

     glCompileShader(shaderVertex);

     // 检查着色器编译错误

     CheckCompileErrors(shaderVertex, "VERTEX");

     // ***

     // 片段着色器

     shaderFregment = glCreateShader(GL_FRAGMENT_SHADER);

     glShaderSource(shaderFregment, , &pcShaderFregment, NULL);

     glCompileShader(shaderFregment);

     // 检查着色器编译错误

     CheckCompileErrors(shaderFregment, "FRAGMENT");

     // ***

     // 链接着色器程序

     FuiProgramID = glCreateProgram();

     glAttachShader(FuiProgramID, shaderVertex);

     glAttachShader(FuiProgramID, shaderFregment);

     glLinkProgram(FuiProgramID);

     // 检查链接错误

     CheckCompileErrors(FuiProgramID, "PROGRAM");

     glDetachShader(FuiProgramID, shaderVertex);

     glDetachShader(FuiProgramID, shaderFregment);

     // 删除着色器

     glDeleteShader(shaderVertex);

     glDeleteShader(shaderFregment);

     return ;//uiProgramID;

 }

 bool test01::CheckCompileErrors(unsigned int _shader, const string& _strType)

 {

     int success;

     char infoLog[];

     if (_strType != "PROGRAM"){

         glGetShaderiv(_shader, GL_COMPILE_STATUS, &success);

         if (!success){

             glGetShaderInfoLog(_shader, , NULL, infoLog);

             cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << _strType << "---" << infoLog  << endl;

             return false;

         }

     }else{

         glGetProgramiv(_shader, GL_LINK_STATUS, &success);

         if (!success){

             glGetProgramInfoLog(_shader, , NULL, infoLog);

             cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << _strType << "---" << infoLog << endl;

             return false;

         }

     }

     return true;

 }