Library_Project/demo/VideoPlayerGL/GLShader/ShaderBase.cpp

#include "ShaderBase.h"

#include <QString>
#include <QImage>
#include <QFile>

#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QTextStream>

#include "spdlog/spdlog.h"


ShaderBase::ShaderBase()
{
}

ShaderBase::~ShaderBase()
{
    clearTexture();
    
    if(m_shaderProgramObj != nullptr) {
        delete m_shaderProgramObj;
        m_shaderProgramObj = nullptr;
    }
}


/* 初始化Shader，第一个是定点着色器，第二个是片段着色器 */
bool ShaderBase::loadShaderCode(const QString &vertexShaderFile, const QString &fragmentShaderFile)
{
    if(vertexShaderFile.isEmpty() || fragmentShaderFile.isEmpty()) 
    {
        SPDLOG_ERROR("顶点着色器或片段着色器文件为空");
        return false;
    }
    /* 打开文件 */
    QFile vertexFile(vertexShaderFile);
    if (!vertexFile.open(QIODevice::ReadOnly)) 
    {
        SPDLOG_ERROR("Failed to open vertex shader file: {}", vertexShaderFile.toStdString());
        return false;
    }
    m_vertexShaderCode = vertexFile.readAll();
    vertexFile.close();

    if (m_vertexShaderCode.isEmpty()) 
    {
        SPDLOG_ERROR("Vertex shader file is empty: {}", vertexShaderFile.toStdString());
        return false;
    }
    /* 打开文件 */
    QFile fragmentFile(fragmentShaderFile);
    if (!fragmentFile.open(QIODevice::ReadOnly)) 
    {
        SPDLOG_ERROR("Failed to open fragment shader file: {}", fragmentShaderFile.toStdString());
        return false;
    }
    m_fragmentShaderCode = fragmentFile.readAll();
    fragmentFile.close();
    if (m_fragmentShaderCode.isEmpty()) 
    {
        SPDLOG_ERROR("Fragment shader file is empty: {}", fragmentShaderFile.toStdString());
        return false;
    }

    return true;
}


/* 编译着色器程序 */
bool ShaderBase::compileShader()
{
    if(m_vertexShaderCode.isEmpty() || m_fragmentShaderCode.isEmpty()) {
        SPDLOG_ERROR("顶点着色器或片段着色器文件为空");
        return false;
    }
    /* 编译顶点着色器 */
    QOpenGLShader* vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);
    if(!vertexShader->compileSourceCode(m_vertexShaderCode))
    {
        SPDLOG_ERROR("编译顶点着色器错误: {}", vertexShader->log().toStdString());
        return false;
    }
    /* 编译片段着色器 */
    QOpenGLShader* fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment);
    if(!fragmentShader->compileSourceCode(m_fragmentShaderCode))
    {
        SPDLOG_ERROR("编译片段着色器错误: {}", fragmentShader->log().toStdString());
        return false;
    }

    /* 创建着色器程序对象 */
    m_shaderProgramObj = new QOpenGLShaderProgram();
    /* 添加顶点着色器和片段着色器 */
    m_shaderProgramObj->addShader(vertexShader);
    m_shaderProgramObj->addShader(fragmentShader);
    /* 链接着色器程序 */
    if (!m_shaderProgramObj->link()) {
        SPDLOG_ERROR("Failed to link shader program: {}", m_shaderProgramObj->log().toStdString());
        return false;
    }
    /* 检查链接错误 */
    if (m_shaderProgramObj->log().contains("ERROR")) {
        SPDLOG_ERROR("Shader program link error: {}", m_shaderProgramObj->log().toStdString());
        return false;
    }
    /* 删除着色器对象 */
    delete vertexShader;
    vertexShader = nullptr;
    delete fragmentShader;
    fragmentShader = nullptr;

    return true;
}

/**
 * @brief 初始化纹理，返回值是生成的纹理ID
 * 
 * @param imageFile 纹理图片路径
 * @param uniformName 纹理对应的uniform变量名称
 * @return true 
 * @return false 
 */
bool ShaderBase::createTexture(const QString &imageFile, const QString uniformName)
{
    bool isExist = false;
    for(auto& it : m_listTexture) 
    {
        if(it.first == uniformName) 
        {
            QOpenGLTexture* texture = it.second;
            if (texture != nullptr) {
                texture->destroy();
                delete texture;
                texture = nullptr;
            }
            /* 纹理已存在，删除纹理 */
            m_listTexture.removeOne(it);
            isExist = true;
            break;
        }
    }
    if(!isExist)
    {
        /* 纹理图片不存在，检查是否已经超过最大的纹理数目 */
        int maxTextureUnits = 0;
        // maxTextureUnits 就是当前环境支持的最大纹理单元数
        glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);

        if (m_listTexture.size() >= maxTextureUnits) {
            SPDLOG_ERROR("纹理图片数量超过最大限制");
            return false;
        }
    }
    
    /* 加载图片 */
    QImage image;
    image.load(imageFile);
    if (image.isNull()) {
        SPDLOG_ERROR("Failed to load image: {}", imageFile.toStdString());
        return false;
    }
    /* 将图片转换为RGBA格式 */
    image = image.convertToFormat(QImage::Format_RGBA8888);
    /* 这里要垂直翻转 */
    // image = image.mirrored(false, true);

    QOpenGLTexture* texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
    texture->setSize(image.width(), image.height(), 1); // 设置纹理大小
    texture->setFormat(QOpenGLTexture::RGBA8_UNorm); // 设置纹理格式
    texture->allocateStorage(); // 分配纹理存储空间
    texture->setData(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, image.bits()); // 设置纹理数据
    /* 设置纹理参数 */
    texture->setWrapMode(QOpenGLTexture::Repeat); // S轴环绕方式
    texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear); // 纹理缩小过滤方式
    texture->setMagnificationFilter(QOpenGLTexture::Linear); // 纹理放大过滤方式
    
    
    texture->generateMipMaps(); // 生成多级渐远纹理

    printGLerror("ShaderBase::createTextureFile");
    /* 将纹理存储到数组中 */
    m_listTexture.push_back(QPair<QString, QOpenGLTexture*>(uniformName, texture));

    return true;
}

/* 初始化纹理，直接传入图片 */
bool ShaderBase::createTexture(const QImage &image, const QString uniformName)
{
    if(image.isNull()) {
        SPDLOG_WARN("Texture Image is null");
        return false;
    }
    QOpenGLTexture* texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
    texture->setSize(image.width(), image.height(), 1); // 设置纹理大小
    texture->setFormat(QOpenGLTexture::RGBA8_UNorm); // 设置纹理格式
    texture->allocateStorage(); // 分配纹理存储空间
    texture->setData(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, image.convertToFormat(QImage::Format_RGBA8888).bits()); // 设置纹理数据
    /* 设置纹理参数 */
    texture->setWrapMode(QOpenGLTexture::Repeat); // S轴环绕方式
    texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear); // 纹理缩小过滤方式
    texture->setMagnificationFilter(QOpenGLTexture::Linear); // 纹理放大过滤方式
    
    
    texture->generateMipMaps(); // 生成多级渐远纹理

    printGLerror("ShaderBase::createTextureImage");
    /* 将纹理存储到数组中 */
    m_listTexture.push_back(QPair<QString, QOpenGLTexture*>(uniformName, texture));

    return true;
}

/* 清空纹理 */
void ShaderBase::clearTexture()
{
    for(auto& it : m_listTexture) 
    {
        if(it.second != nullptr) 
        {
            it.second->destroy();
            delete it.second;
            it.second = nullptr;
        }
    }
    m_listTexture.clear();
}

/* 使用着色器 */
void ShaderBase::useShader()
{
    if (m_shaderProgramObj == nullptr) {
        SPDLOG_ERROR("Shader program object is null");
        return;
    }
    /* 使用着色器程序 */
    m_shaderProgramObj->bind();
    /* 使用纹理 */
    if(m_listTexture.size() > 0) 
    {
        int currentTextureUnit = 0;
        for (auto it = m_listTexture.begin(); it != m_listTexture.end(); ++it) 
        {
            it->second->bind(currentTextureUnit);
            /* 绑定纹理 */
            int location = m_shaderProgramObj->uniformLocation(it->first);
            if (location < 0) {
                SPDLOG_ERROR("Failed to get uniform location for texture: {}", it->first.toStdString());
                continue;
            }
            /* 设置纹理单元 */
            m_shaderProgramObj->setUniformValue(location, currentTextureUnit); 

            currentTextureUnit++;
        }
    }
}

/* 打印OpenGL错误 */
void ShaderBase::printGLerror(const std::string functionName)
{
    GLenum error = glGetError();
    if (error == GL_NO_ERROR) {
        return;
    }

    /* 打印出字符串 */
    std::string errorString;
    switch (error) 
    {
        case GL_INVALID_ENUM:
            errorString = "GL_INVALID_ENUM";
            break;
        case GL_INVALID_VALUE:
            errorString = "GL_INVALID_VALUE";
            break;
        case GL_INVALID_OPERATION:
            errorString = "GL_INVALID_OPERATION";
            break;
        case GL_STACK_OVERFLOW:
            SPDLOG_ERROR("GL_STACK_OVERFLOW");
            break;
        case GL_STACK_UNDERFLOW:
            SPDLOG_ERROR("GL_STACK_UNDERFLOW");
            break;
        case GL_OUT_OF_MEMORY:
            SPDLOG_ERROR("GL_OUT_OF_MEMORY");
            break;
        default:
            SPDLOG_ERROR("Unknown OpenGL error: 0x{:X}", error);
            break;
    }
    SPDLOG_ERROR("OpenGL error in {}: 0x{:X}, {}", functionName, error, errorString);
    
}