Qt OpenGL 天空盒

最新推荐文章于 2024-04-19 00:19:11 发布
最新推荐文章于 2024-04-19 00:19:11 发布
阅读量2k 收藏 3
点赞数
分类专栏： OpenGL 文章标签： opengl qt

这里写图片描述

Author

This is the work of Emil Persson, aka Humus.
http://www.humus.name

License

This work is licensed under a Creative Commons Attribution 3.0 Unported License.
http://creativecommons.org/licenses/by/3.0/

main.cpp

#include <QApplication>
#include "glwidget.h"

int main(int argc, char **argv)
{
    QApplication a(argc, argv);

    GLWidget glw;
    glw.resize(600, 600);
    glw.show();

    return a.exec();
}

glwidget.cpp

#include "glwidget.h"
#include "skybox.h"
#include "torus.h"

#include <QMatrix4x4>

struct GLWidgetData
{
    QMatrix4x4 projectionMatrix;
    QMatrix4x4 viewMatrix;

    SkyBox skyBox;
    Torus torus;
};

GLWidget::GLWidget(QWidget *parent) : QOpenGLWidget(parent)
{
    d = new GLWidgetData;

    QSurfaceFormat format;
    format.setSamples(4);
    setFormat(format);
}

GLWidget::~GLWidget()
{
    delete d;
}

void GLWidget::initializeGL()
{
    QOpenGLFunctions::initializeOpenGLFunctions();

    glClearColor(0.25, 0.35, 0.45, 1);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_POLYGON_OFFSET_LINE);
    glPolygonOffset(-0.03125f, -0.03125f);
}

void GLWidget::resizeGL(int w, int h)
{
    glViewport(0, 0, w, h);

    d->projectionMatrix.setToIdentity();
    d->projectionMatrix.perspective(60.0, float(w)/float(h), 0.1f, 20.0f);

    d->viewMatrix.setToIdentity();
}

void GLWidget::paintGL()
{
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    d->skyBox.render(d->viewMatrix, d->projectionMatrix);
    d->torus.render(d->viewMatrix, d->projectionMatrix);
}

skybox.cpp

#include "skybox.h"

#include <QMatrix4x4>
#include <QOpenGLBuffer>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>

struct SkyBoxData
{
    SkyBoxData() {
        for(int i=0; i<6; i++)
            this->textures[i] = 0;
        this->vertexBuffer = 0;
        this->indexBuffer = 0;
        this->shader = 0;
    }
    ~SkyBoxData() {
        delete this->shader;
        delete this->indexBuffer;
        delete this->vertexBuffer;
        for(int i=5; i>=0; i--)
            delete this->textures[i];
    }

    QOpenGLTexture *textures[6];
    QOpenGLBuffer *vertexBuffer;
    QOpenGLBuffer *indexBuffer;
    QOpenGLShaderProgram *shader;
    QMatrix4x4 matrix;
};

SkyBox::SkyBox()
{
    d = new SkyBoxData;
}

SkyBox::~SkyBox()
{
    delete d;
}

void SkyBox::render(const QMatrix4x4 &viewMatrix, const QMatrix4x4 &projectionMatrix)
{
    this->init();

    d->shader->bind();
    d->vertexBuffer->bind();
    d->indexBuffer->bind();

    d->shader->enableAttributeArray("qt_Vertex");
    d->shader->setAttributeBuffer("qt_Vertex", GL_FLOAT, 0, 3, 0);

    d->shader->enableAttributeArray("qt_MultiTexCoord0");
    const int texCoordsOffset = 24 * sizeof(QVector3D);
    d->shader->setAttributeBuffer("qt_MultiTexCoord0", GL_FLOAT, texCoordsOffset, 2, 0);

    d->matrix.rotate(-1, 0, 1, 0);

    QMatrix4x4 modelMatrix = d->matrix;
    modelMatrix.scale(10, 10, 10);

    const QMatrix4x4 mvp = projectionMatrix * viewMatrix * modelMatrix;
    d->shader->setUniformValue("qt_ModelViewProjectionMatrix", mvp);

    for(int i=0; i<6; i++)
    {
        d->textures[i]->bind(i+1);
        d->shader->setUniformValue("qt_Texture0", (i+1));

        const uint triangleOffset = i*6*sizeof(uint);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, (void*)triangleOffset);

        d->textures[i]->release(i+1);
    }

    d->indexBuffer->release();
    d->vertexBuffer->release();
    d->shader->release();
}

void SkyBox::init()
{
    if(d->shader)
        return;

    QOpenGLFunctions::initializeOpenGLFunctions();

    // Load all texture images
    const QImage posx = QImage(":/images/posx.jpg").mirrored();
    const QImage posy = QImage(":/images/posy.jpg").mirrored();
    const QImage posz = QImage(":/images/posz.jpg").mirrored();
    const QImage negx = QImage(":/images/negx.jpg").mirrored();
    const QImage negy = QImage(":/images/negy.jpg").mirrored();
    const QImage negz = QImage(":/images/negz.jpg").mirrored();

    // Load images as independent texture objects
    d->textures[0] = new QOpenGLTexture(posx);
    d->textures[1] = new QOpenGLTexture(posy);
    d->textures[2] = new QOpenGLTexture(posz);
    d->textures[3] = new QOpenGLTexture(negx);
    d->textures[4] = new QOpenGLTexture(negy);
    d->textures[5] = new QOpenGLTexture(negz);
    for(int i=0; i<6; i++)
    {
        d->textures[i]->setWrapMode(QOpenGLTexture::ClampToEdge);
        d->textures[i]->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
        d->textures[i]->setMagnificationFilter(QOpenGLTexture::Linear);
    }

    // Construct a template square of size 2x2
    const QVector3D p1(-1, 1, 0); // top-left
    const QVector3D p2(-1, -1, 0); // bottom-left
    const QVector3D p3(1, -1, 0); // bottom-right
    const QVector3D p4(1, 1, 0); // top-right

    // Array for storing geometry of the cube
    QVector<QVector3D> geometry;
    geometry.reserve(24);

    // Transform p1 ... p4 for posx
    QMatrix4x4 mat;
    mat.translate(1, 0, 0);
    mat.rotate(-90, 0, 1, 0);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Transform p1 ... p4 for posy
    mat.setToIdentity();
    mat.translate(0, 1, 0);
    mat.rotate(90, 1, 0, 0);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Transform p2 ... p4 for posz
    mat.setToIdentity();
    mat.translate(0, 0, -1);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Transform p2 ... p4 for negx
    mat.setToIdentity();
    mat.translate(-1, 0, 0);
    mat.rotate(90, 0, 1, 0);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Transform p2 ... p4 for negy
    mat.setToIdentity();
    mat.translate(0, -1, 0);
    mat.rotate(-90, 1, 0, 0);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Transform p2 ... p4 for negz
    mat.setToIdentity();
    mat.translate(0, 0, 1);
    mat.rotate(180, 0, 1, 0);
    geometry << mat.map(p1) << mat.map(p2)
             << mat.map(p3) << mat.map(p4);

    // Texture coordinates
    QVector<QVector2D> texCoords;
    texCoords.reserve(24);
    for(int i=0; i<6; i++)
    {
        texCoords << QVector2D(0, 1)
                  << QVector2D(0, 0)
                  << QVector2D(1, 0)
                  << QVector2D(1, 1);
    }

    // Triangles
    QVector<uint> triangles;
    triangles.reserve(36);
    for(int i=0; i<6; i++)
    {
        const int base = i*4;
        triangles << base << base+1 << base+2;
        triangles << base << base+2 << base+3;
    }

    // Store the arrays in buffers
    d->vertexBuffer = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    d->vertexBuffer->create();
    d->vertexBuffer->bind();
    d->vertexBuffer->allocate( geometry.size()*sizeof(QVector3D) +
                               texCoords.size()*sizeof(QVector2D) );
    d->vertexBuffer->write(0, (const void *)geometry.constData(),
                           geometry.size()*sizeof(QVector3D) );
    d->vertexBuffer->write(geometry.size()*sizeof(QVector3D),
                           (const void *)texCoords.constData(),
                           texCoords.size()*sizeof(QVector2D) );
    d->vertexBuffer->release();

    d->indexBuffer = new QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);
    d->indexBuffer->create();
    d->indexBuffer->bind();
    d->indexBuffer->allocate((const void*)triangles.constData(),
                             triangles.size()*sizeof(uint));
    d->indexBuffer->release();

    // Create shaders
    d->shader = new QOpenGLShaderProgram;
    d->shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/skybox_vertex.glsl");
    d->shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/skybox_fragment.glsl");
    d->shader->link();
}

torus.cpp

#include "torus.h"

#include <QColor>
#include <QMatrix4x4>
#include <QOpenGLBuffer>
#include <QOpenGLShaderProgram>
#include <QOpenGLTexture>

struct TorusData
{
    TorusData() :
        tubeRadius(0.3), torusRadius(1.0),
        tubeResolution(20), torusResolution(40),
        vertexBuffer(0), indexBuffer(0), shader(0),
        angle(0) { }
    ~TorusData() {
        delete vertexBuffer;
        delete indexBuffer;
        delete shader;
    }

    const float tubeRadius;
    const float torusRadius;
    const int tubeResolution;
    const int torusResolution;

    QOpenGLTexture *environment;
    QOpenGLBuffer *vertexBuffer;
    QOpenGLBuffer *indexBuffer;
    QOpenGLShaderProgram *shader;

    float angle;
};

Torus::Torus()
{
    d = new TorusData;
}

Torus::~Torus()
{
    delete d;
}

void Torus::render(const QMatrix4x4 &viewMatrix, const QMatrix4x4 &projectionMatrix)
{
    this->init();

    d->shader->bind();
    d->vertexBuffer->bind();
    d->indexBuffer->bind();

    d->shader->enableAttributeArray("qt_Vertex");
    d->shader->setAttributeBuffer("qt_Vertex", GL_FLOAT, 0, 3, 2*sizeof(QVector3D));

    d->shader->enableAttributeArray("qt_Normal");
    d->shader->setAttributeBuffer("qt_Normal", GL_FLOAT, sizeof(QVector3D), 3, 2*sizeof(QVector3D));

    QMatrix4x4 modelMatrix;
    modelMatrix.translate(0, 0, -3.0);
    modelMatrix.rotate(d->angle, 0, 1, 0);
    d->angle += 5;

    const QMatrix4x4 mvMat = viewMatrix * modelMatrix;
    const QMatrix4x4 normalMat = mvMat.inverted().transposed();
    d->shader->setUniformValue("qt_ModelViewMatrix", mvMat);
    d->shader->setUniformValue("qt_ProjectionMatrix", projectionMatrix);
    d->shader->setUniformValue("qt_NormalMatrix", normalMat);

    d->shader->setUniformValue("qt_EyePosition", QVector3D(0,0,-1));

    d->shader->setUniformValue("qt_Light.direction", QVector3D(1,1,1));
    d->shader->setUniformValue("qt_Light.ambientColor", QColor(Qt::gray));
    d->shader->setUniformValue("qt_Light.diffuseColor", QColor(Qt::white));
    d->shader->setUniformValue("qt_Light.specularColor", QColor(Qt::white));

    d->shader->setUniformValue("qt_Material.ambientColor", QColor(Qt::gray).darker());
    d->shader->setUniformValue("qt_Material.diffuseColor", QColor(Qt::gray).lighter());
    d->shader->setUniformValue("qt_Material.specularColor", QColor(Qt::white));
    d->shader->setUniformValue("qt_Material.specularPower", 0.9f);
    d->shader->setUniformValue("qt_Material.opacity", 1.0f);
    d->shader->setUniformValue("qt_Material.brightness", 2.0f);

    d->environment->bind(0);
    d->shader->setUniformValue("qt_Environment", 0);

    glEnable(GL_CULL_FACE);
    glCullFace(GL_CCW);

    const int nrIndicies = d->torusResolution * d->tubeResolution * 6;
    glDrawElements(GL_TRIANGLES, nrIndicies, GL_UNSIGNED_INT, (void*)0);

    glDisable(GL_CULL_FACE);

    d->indexBuffer->release();
    d->vertexBuffer->release();
    d->environment->release(0);
    d->shader->release();
}

void Torus::init()
{
    if(d->shader)
        return;

    QOpenGLFunctions::initializeOpenGLFunctions();

    d->vertexBuffer = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    d->vertexBuffer->create();
    d->vertexBuffer->bind();
    d->vertexBuffer->allocate(d->tubeResolution * d->torusResolution * sizeof(QVector3D) * 2);

    d->indexBuffer = new QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);
    d->indexBuffer->create();
    d->indexBuffer->bind();
    d->indexBuffer->allocate( d->torusResolution * d->tubeResolution * 6 * sizeof(uint) );

    QMatrix4x4 matrix;
    const float tubeAngleStep = 360.0f / float(d->tubeResolution-1);
    const float torusAngleStep = 360.0f / float(d->torusResolution-1);

    int vertexBufferOffset = 0;
    for(int i=0; i<d->torusResolution; i++)
    {
        QMatrix4x4 tmp = matrix;
        tmp.translate(d->torusRadius, 0, 0);

        const QVector3D centerPt = tmp.map(QVector3D(0,0,0));
        for(int j=0; j<d->tubeResolution; j++)
        {
            const QVector3D pt = tmp.map( QVector3D(d->tubeRadius, 0, 0) );
            d->vertexBuffer->write(vertexBufferOffset, &pt, sizeof(pt));
            vertexBufferOffset += sizeof(pt);

            const QVector3D normal = (pt - centerPt).normalized();
            d->vertexBuffer->write(vertexBufferOffset, &normal, sizeof(normal));
            vertexBufferOffset += sizeof(normal);
            tmp.rotate(tubeAngleStep, QVector3D(0,1,0));
        }

        matrix.rotate(torusAngleStep, QVector3D(0,0,1));
    }

    int indexBufferOffset = 0;
    int base = 0;
    const int nrPoints = (d->torusResolution * d->tubeResolution);
#define P(x) (x)%nrPoints
    for(int i=0; i<d->torusResolution; i++)
    {
        for(int j=0; j<d->tubeResolution; j++)
        {
            const uint tgls[] = {
                                    P(base),
                                    P(base+1),
                                    P(base+1+d->tubeResolution),
                                    P(base),
                                    P(base+1+d->tubeResolution),
                                    P(base+d->tubeResolution)
                                };
            d->indexBuffer->write(indexBufferOffset, (const void*)tgls, sizeof(uint)*6);
            indexBufferOffset += sizeof(uint)*6;
            ++base;
        }
#undef P
    }

    d->indexBuffer->release();
    d->vertexBuffer->release();

    // Load all environment texture images
    const QImage posx = QImage(":/images/posx.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);
    const QImage posy = QImage(":/images/posy.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);
    const QImage posz = QImage(":/images/posz.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);
    const QImage negx = QImage(":/images/negx.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);
    const QImage negy = QImage(":/images/negy.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);
    const QImage negz = QImage(":/images/negz.jpg").mirrored().convertToFormat(QImage::Format_RGBA8888);

    // Construct the environment texture
    d->environment = new QOpenGLTexture(QOpenGLTexture::TargetCubeMap);
    d->environment->create();
    d->environment->setSize(posx.width(), posx.height(), posx.depth());
    d->environment->setFormat(QOpenGLTexture::RGBA8_UNorm);
    d->environment->allocateStorage();
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapPositiveX,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)posx.constBits(), 0);
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapPositiveY,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)posy.constBits(), 0);
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapPositiveZ,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)posz.constBits(), 0);
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapNegativeX,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)negx.constBits(), 0);
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapNegativeY,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)negy.constBits(), 0);
    d->environment->setData(0, 0, QOpenGLTexture::CubeMapNegativeZ,
                            QOpenGLTexture::RGBA, QOpenGLTexture::UInt8,
                            (const void*)negz.constBits(), 0);
    d->environment->generateMipMaps();
    d->environment->setWrapMode(QOpenGLTexture::ClampToEdge);
    d->environment->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
    d->environment->setMagnificationFilter(QOpenGLTexture::LinearMipMapLinear);

    // Load and link shader programs
    d->shader = new QOpenGLShaderProgram;
    d->shader->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/torus_vertex.glsl");
    d->shader->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/torus_fragment.glsl");
    d->shader->link();

    glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
}

skybox_fragment.glsl

uniform sampler2D qt_Texture0;
varying vec4 qt_TexCoord0;

void main(void)
{
    gl_FragColor = texture2D(qt_Texture0, qt_TexCoord0.st);
}

skybox_vertex.glsl

attribute vec4 qt_Vertex;
attribute vec4 qt_MultiTexCoord0;
uniform mat4 qt_ModelViewProjectionMatrix;
varying vec4 qt_TexCoord0;

void main(void)
{
    gl_Position = qt_ModelViewProjectionMatrix * qt_Vertex;
    qt_TexCoord0 = qt_MultiTexCoord0;
}

torus_vertex.glsl

attribute vec3 qt_Vertex;
attribute vec3 qt_Normal;

uniform mat4 qt_NormalMatrix;
uniform mat4 qt_ModelViewMatrix;
uniform mat4 qt_ProjectionMatrix;

varying vec3 v_Position;
varying vec3 v_Normal;
varying vec3 v_TexCoord;

const float c_zero = 0.0;
const float c_one = 1.0;

void main(void)
{
    vec4 normal = normalize( qt_NormalMatrix * vec4(qt_Normal, c_zero) );
    v_Normal = normal.xyz;

    vec4 position = qt_ModelViewMatrix * vec4(qt_Vertex, c_one);
    v_Position = position.xyz;

    v_TexCoord = v_Normal;

    mat4 mat = qt_ProjectionMatrix * qt_ModelViewMatrix;
    gl_Position = mat * vec4(qt_Vertex, c_one);
}

torus_fragment.glsl

struct directional_light
{
    vec3 direction;
    vec4 ambientColor;
    vec4 diffuseColor;
    vec4 specularColor;
};

struct material_properties
{
    vec4 ambientColor;
    vec4 diffuseColor;
    vec4 specularColor;
    float specularPower;
    float opacity;
    float brightness;
};

uniform directional_light qt_Light;
uniform material_properties qt_Material;
uniform vec3 qt_EyePosition;
uniform samplerCube qt_Environment;

varying vec3 v_Position;
varying vec3 v_Normal;
varying vec3 v_TexCoord;

const float c_zero = 0.0;
const float c_one = 1.0;

vec4 evaluateColor(in vec3 normal, in vec3 texCoord)
{
    // Start with black color
    vec3 finalColor = vec3(c_zero, c_zero, c_zero);

    // Upgrade black color to the base ambient color
    finalColor += qt_Light.ambientColor.rgb * qt_Material.ambientColor.rgb;

    // Add diffuse component to it
    vec3 lightDir = normalize(qt_Light.direction);
    float diffuseFactor = max( c_zero, dot(lightDir, normal) );
    if(diffuseFactor > c_zero)
    {
        finalColor += qt_Light.diffuseColor.rgb *
                qt_Material.diffuseColor.rgb *
                diffuseFactor * qt_Material.brightness;
    }

    // Add specular component to it
    vec3 viewDir = normalize(qt_EyePosition - v_Position);
    vec3 reflectionVec = reflect(viewDir, normal);
    const vec3 blackColor = vec3(c_zero, c_zero, c_zero);
    if( !(qt_Material.specularColor.rgb == blackColor ||
          qt_Light.specularColor.rgb == blackColor ||
          qt_Material.specularPower == c_zero) )
    {
        float specularFactor = max( c_zero, dot(reflectionVec, -viewDir) );
        if(specularFactor > c_zero)
        {
            specularFactor = pow( specularFactor, qt_Material.specularPower );
            finalColor += qt_Light.specularColor.rgb *
                    qt_Material.specularColor.rgb *
                    specularFactor;
        }
    }

    // Texture mapping
    finalColor *= textureCube(qt_Environment, reflectionVec).rgb;

    // All done!
    return vec4( finalColor, c_one );
}

void main(void)
{
    gl_FragColor = evaluateColor(v_Normal, v_TexCoord);
}

源码: http://download.csdn.net/detail/yulinxx/9873347

cmake.EXE
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
qt opengl 天空盒
wanghualin033的博客
01-01 1223
     这个效果比较简单，用一个立文体把我们要绘制的东西包起来即可，把摄像机的位置放到立文体内，这样就给人一个有天空，有陆地感觉。  我在这个工程中加入了以前的圆环体，其渲染器实现方法，可以查阅以前的文章。效果如下     我使用的是一个包含6个纹理图片的纹理数组，一次性把6个面都画好了，并完成了贴图。其渲染器实现如下： #ifndef BOXSHADER_H #define BOXS...
【小沐学QT】QT学习之OpenGL开发笔记
爱看书的小沐
02-27 1810
Qt提供了与OpenGL实现集成的支持，使开发人员有机会在更传统的用户界面的同时显示硬件加速的3D图形。Qt有两种主要的UI开发方法：QtQuick和QtWidgets。它们的存在是为了支持不同类型的用户界面，并建立在针对每种类型进行了优化的独立图形引擎上。可以将在OpenGL图形API中编写的代码与Qt中的这两种用户界面类型结合起来。当应用程序有自己的OpenGL相关代码时，或者当它与基于OpenGL的第三方渲染器集成时，这可能很有用。Qt OpenGL模块包含方便类，使这种类型的集成更容易、更快。
OpenGL学习（十）天空盒
AKGWSB 's blog
01-03 6787
目录写在前面天空盒简介创建立方体贴图渲染一个立方体立方体贴图着色器开始绘制天空盒完整代码着色器c++ 写在前面 上一篇博客回顾：OpenGL学习（九）阴影映射（shadowMapping） 在昨天我们实现了非常简单的阴影映射特效，今天来更新立方体贴图的内容。这部分的内容相当简单，前提是要对 OpenGL 及其绘制过程有一个基本的理解。 相信我，仅 10 分钟足够你完成一个立方体贴图，并且用于天空盒的渲染。 天空盒简介 注意到我们之前的代码都是利用： glClearColor(1.0, 1.0, 1.0, 1
QT与OpenGL结合实现天空盒
qq_27736025的博客
11-26 2190
    之前捣鼓过一段时间opengl，用的是glad加上glfw库，由于在windows下C++开发用QT较多，所以把QT和opengl结合，因此进行了尝试。     首先QT5.8.0下有自带的opengl控件opengl widget，将这个控件提升为一个自己写的类myOpenGlBox继承于QOpenGLWidget。 然后重载 void initializeGL(); void re...
Qt::QOpenGLWidget 渲染天空壳
D_Guco的专栏
02-28 984
Qt::QOpenGLWidget 渲染天空壳
opengl与QT实现天空盒
11-26
利用QT和opengl实现的天空盒模型，QT版本为5.8.0，可以作为QT上使用opengl的参考。
Qt OpenGL绘制立方体
02-05
1.Qt 5.9 OpenGL3.3 2.绘制带有材质的立方体 3.使用timer 使立方体可以滚动起来
Qt OpenGL 教程
11-23
Qt 开发过程中，如何调用GPU加速界面响应，一直是开发难点，从这个点切入，详细介绍了Qt开发中如何使用OPENGL，混合开发，C++语言，易懂，推荐大家一起学习。
Qt openGL 透视投影例题
02-05
1.Qt + OpenGL开发例题 2.演示 Mperspective * Mview * Mmodel
Qt|OpenGL-天空盒子的创建
IT1995的博客
07-29 5147
程序运行截图如下： 源码如下： myglwidget.h #ifndef MYGLWIDGET_H #define MYGLWIDGET_H #include &lt;QOpenGLWidget&gt; #include &lt;QWidget&gt; class SkyBox; class MyGLWidget : public QOpenGLWidget { Q_O...
Qt Openglwidget 显示图片纹理贴图
12-05
Qt5.7+VS2015 64位的环境，使用Qt的QOpenglWidget，来显示一张图片，采用GLSL。学习入门挺适合的。在网上找了很久资源，还是自己折腾搞定，特地分享出来。
QtOpenGL二维和三维混合的例子（源代码）
01-12
Qt自有一个混图的引擎，这个引擎的核心就是QPainter，我们知道QPainter在渲染二维图形和文字有很大的优势，而OpenGL是当前流行的三维渲染器，怎样才能将两者结合起来，制作更为丰富的应用程序？《C++GUI Programming with Qt 4, secondedition》这本书给了我们一个小的例子，不过我们还要深入地以这个例子为基础进行挖掘，配合Qt的文档，我们才能真正地了解Qt对OpenGL的封装。
Unity高质量天空盒HDRIHaven Skybox_2.rar
09-13
unity天空盒资源太大,分了几部分上传,都在资源里面,有需要可以查看下载 高质量天空盒HDRIHaven Skybox_2
openGL天空盒实现-立方体贴图
aoxuestudy的专栏
03-10 1550
openGL系列文章目录 文章目录openGL系列文章目录前言一、pandas是什么？二、实现步骤1.主程序2.着色器运行效果源码下载 前言 如前所述，天空盒容易受到图像畸变和接缝的影响。接缝指两个纹理图像接触的地方（比 如沿着立方体的边缘）有时出现的可见线条。图9.8 展示了一个图像上半部分出现接缝的示 例，它是运行程序9.1 时出现的伪影。为了避免接缝，需要仔细构建立方体贴图图像，并分 配精确的纹理坐标 一、pandas是什么？ 构建天空盒的另一种方法是使用OpenGL 纹理立方体贴图。OpenGL
opengl天空盒_游戏引擎养成《十三》 天空盒
weixin_39593519的博客
11-23 157
# 四月的天空三月底新项目启动，估计整个Q2都会忙死。上篇搭了一个Input的架子，但是输入很别扭，另外场景上就一个模型显得空荡荡的，今天我们就把天空盒加上。参考 https://learnopengl.com/Advanced-OpenGL/Cubemaps 非常棒的Tutorial.中间场景的一章还没有时间补齐，不过我们先过天空盒吧，以OpenGL为例。# 原理 ## CubeMap 天...
Unity skybox下载-tree下载
热门推荐
心疼你的一切博客
09-16 1万+
几百个天空盒,分了好几份 天空盒下载 1. 太空天空盒下载 2. 白天天空盒下载 3. 夜晚天空盒下载 4. 阴天雾霾天空盒下载 5. HDRI Haven skybox-1 6. HDRI Haven skybox-2 7. 其他天空盒-1 8. 其他天空盒-2 最后是没分的天空盒暂且叫其他天空盒吧,按需下载,喜欢的话请点个赞吧 ! .........
Qt实现XYModem协议(五)
flysnow010的博客
04-18 672
XMODEM协议是一种使用拨号调制解调器的个人计算机通信中广泛使用的异步文件运输协议。这种协议以128字节块的形式传输数据，并且每个块都使用一个校验和过程来进行错误检测。使用循环冗余校验的与XMODEM相应的一种协议称为XMODEM-CRC。还有一种是XMODEM-1K，它以1024字节一块来传输数据。YMODEM也是一种XMODEM的实现。它包括XMODEM-1K的所有特征，另外在一次单一会话期间为发送一组文件，增加了批处理文件传输模式。 本文利用C++实现XYModem-1K协议.
【OpenGL实践08】现代渲染管线在GLUT和Pygame和Qt.QOpenGLWidget上各自的实现代码
最新发布
gongdiwudu的专栏
04-19 897
据说QOpenGLWidget是用来取代QGLWidget的继承者，我们试图将GLUT上的旧代码改成QOpenGLWidget，本以为差别不大，轻易搞定，经实践发现要付出极大努力才能完成。经多次实验发现GLUT窗口、Pygame窗口、Qt.QOpenGLWidget上的实现方法无法兼容，甚至GL方法都不同，经好多天的百度查询，终于总结出各自的实现方法。作文以记录。
qt OpenGl实现天空壳贴图
04-16
在Qt中使用OpenGL实现天空壳贴图可以通过以下步骤进行： 1. 创建一个Qt窗口应用程序项目，并在.pro文件中添加OpenGL模块的依赖。 2. 在Qt窗口中创建一个QOpenGLWidget控件，该控件将用于显示OpenGL渲染的内容。 3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值