分类导航

程序问答发布时间：2022-06-02 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了关于 QT 中的 QSGGeometryNode 和 WebAssembly，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

如何解决关于 QT 中的 QSGGeometryNode 和 WebAssembly？

开发过程中遇到关于 QT 中的 QSGGeometryNode 和 WebAssembly的问题如何解决？下面主要结合日常开发的经验，给出你关于关于 QT 中的 QSGGeometryNode 和 WebAssembly的解决方法建议，希望对你解决关于 QT 中的 QSGGeometryNode 和 WebAssembly有所启发或帮助；

我正在尝试使用 WebAssembly 在 Web 上部署我的项目，但遇到了一些问题。

该项目使用 QSGRenderNode 进行了自定义渲染并在网络上运行。

而且我收到错误“无效操作缓冲区大小不足”。

下面是我的代码。

openglerenderer.h

#ifndef OPENglrENDERER_H
#define OPENglrENDERER_H

#include <qsgrendernode.h>
#include <QQuickItem>
#include "weBACcess/render/baserender.h"

#if QT_CONfig(opengl)


class OpenglrenderNode : public QSGRenderNode
{
public:
    ~OpenglrenderNode();

    voID render(const RenderState *statE) overrIDe;
    voID releaseresources() overrIDe;
    StateFlags changedStates() const overrIDe;
    RenderingFlags flags() const overrIDe;
    QRectF rect() const overrIDe;

    voID sync(QQuickItem *item);

private:
    voID init();
    int m_wIDth = 0;
    int m_height = 0;
    bool beInit = false;
    BaseRender* m_render = nullptr;
};

#endif

#endif // OPENglrENDERER_H

openglerenderer.cpp

#include "openglrenderer.h"
#include <QQuickItem>

#if QT_CONfig(opengl)

#include <QOpenGLFunctions>
#include <QOpenGLExtraFunctions>
#include <QQuickWindow>

#include "weBACcess/render/tutorial/les1.h"
#include "weBACcess/render/tutorial/les2.h"
#include "weBACcess/render/tutorial/les3.h"
#include "weBACcess/render/tutorial/les4.h"

OpenglrenderNode::~OpenglrenderNode()
{
    releaseresources();
}

voID OpenglrenderNode::releaseresources()
{
    if (m_render) {
        m_render->releaseresources();
    }
}

voID OpenglrenderNode::init()
{
    if (m_render) {
        m_render->init();
        beInit = true;
    }
}

voID OpenglrenderNode::render(const RenderState *statE)
{
    if (!beInit)
        init();
    if (m_render) {
        m_render->render(statE);
    }
}

QSGRenderNode::StateFlags OpenglrenderNode::changedStates() const
{
    return BlendState | ScissorState | stencilstate;
}

QSGRenderNode::renderingFlags OpenglrenderNode::flags() const
{
    return BoundedRectRendering | DepthAwareRendering;
}

QRectF OpenglrenderNode::rect() const
{
    return QRect(0,m_wIDth,m_height);
}

voID OpenglrenderNode::sync(QQuickItem *item)
{
    m_wIDth = static_cast<int>(item->wIDth());
    m_height = static_cast<int>(item->height());
    if (!m_render) {
        m_render = static_cast<BaseRender*>(new les4{});
        if (m_render) {
            QObject::connect(item->window(),&QQuickWindow::beforeRendering,m_render,[&]() { m_render->beforeRender(); },Qt::DirectConnection);
        }
    }
    if (m_render) {
        m_render->sync(item);
        m_render->setVIEwportSize(item->size().toSize() * item->window()->devicePixelRatio());
        m_render->setposition(item->position().topoint());
        m_render->setwindow(item->window());
    }
}

#endif

les4.h

#ifndef LES4_H
#define LES4_H

#include "../baserender.h"

class QOpenGLTexture;
class QOpenGLShaderProgram;
class QOpenGLBuffer;
class QOpenGLVertexArrayObject;

class les4 : public BaseRender
{
public:
    les4();

    ~les4() overrIDe;
    virtual voID init() overrIDe;
    virtual voID render(const QSGRenderNode::renderState *statE) overrIDe;
    virtual voID sync(QQuickItem *item) overrIDe;
    virtual voID releaseresources() overrIDe;

    virtual voID setVIEwportSize(QSize sizE) overrIDe { m_vIEwportSize = size; }
    virtual voID setposition(QPoint point) overrIDe { m_position = point; }
    virtual voID setwindow(QQuickWindow* window) overrIDe { m_window = window; }
    virtual voID beforeRender() overrIDe;

private:
    QSize m_vIEwportSize{};
    QPoint m_position{};
    QQuickWindow* m_window{};

    QOpenGLShaderProgram *m_program = nullptr;
    QOpenGLVertexArrayObject *m_vao = nullptr;
    QOpenGLBuffer *m_vbo = nullptr;
    QOpenGLBuffer *m_ibo = nullptr;

    int m_wIDth = 0;
    int m_height = 0;
};

#endif // LES4_H

les4.cpp

#include "les4.h"
#include <QQuickWindow>
#include <QOpenGLContext>
#include <QOpenGLTexture>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLFunctions>
#include <QGuiApplication>

static const char *vertexShadersource =
        "#version 100\n"
        "attribute vec3 aPos;\n"
        "attribute vec3 acolor;\n"
        "varying vec3 ourcolor;\n"
        "voID main() {\n"
        "   gl_position = vec4(aPos.xyz,1.0);\n"
        "   ourcolor = acolor;\n"
        "}";

static const char *fragmentShadersource =
        "#version 100\n"
#if Defined(Q_OS_HTML5) or defined(Q_OS_WASM) or defined(__EMSCRIPTEN__)
        "precision mediump float;\n"
#endif
        "varying vec3 ourcolor;\n"
        "voID main() {\n"
        "   gl_Fragcolor = vec4(ourcolor,1.0);\n"
        "}";

static float vertices[] {
    // 位置              // 顏色
     0.5f,-0.5f,0.0f,1.0f,// 右下
    -0.5f,// 左下
     0.0f,0.5f,1.0f    // 頂部
};

static unsigned int inDices[] {
    0,1,2
};

les4::les4()
{

}

les4::~les4()
{

}

voID les4::init() {
    QSurfaceFormat fmt;
    fmt.setVersion(2,0);
    fmt.setRenderableType(QSurfaceFormat::OpenGLES);
    fmt.setMajorVersion(2);
    fmt.setMinorVersion(0);
    fmt.setRedBufferSize(5);
    fmt.setGreenBufferSize(6);
    fmt.setBlueBufferSize(5);
    fmt.setAlphaBufferSize(0);
    fmt.setDepthBufferSize(0);

    QSurfaceFormat::setDefaultFormat(fmt);

    QOpenGLContext *ctx = QOpenGLContext::currentContext();
    ctx->setFormat(fmt);
}

voID les4::releaseresources() {
    delete m_program;
    m_program = nullptr;

    delete m_vbo;
    m_vbo = nullptr;

    delete m_ibo;
    m_ibo = nullptr;

    delete m_vao;
    m_vao = nullptr;
}

voID les4::beforeRender() {

}

voID les4::render(const QSGRenderNode::renderState*) {

    QOpenGLContext *ctx = QOpenGLContext::currentContext();

#if Defined(Q_OS_HTML5) or defined(Q_OS_WASM) or defined(__EMSCRIPTEN__)
const bool iscoreProfile  = false;
#else
const bool iscoreProfile  = ctx->format().profile() == QSurfaceFormat::CoreProfile;
#endif

    QOpenGLFunctions *f = ctx->functions();

    int y = (m_window->size()* m_window->devicePixelRatio()).height() - m_vIEwportSize.height() - m_position.y();
    f->glVIEwport(m_position.x(),y,m_vIEwportSize.wIDth(),m_vIEwportSize.height());
    f->glClearcolor(0.2f,0.3f,1.0f);
    f->glClear(GL_color_BUFFER_BIT);

    auto setupVertAttrs = [this,f] {
        m_vbo->bind();
        f->glVertexAttribPointer(0,3,GL_float,GL_falSE,6*sizeof(float),(void*)0);
        f->glVertexAttribPointer(1,(void*)(3*sizeof(float)));
        f->glEnabLevertexAttribarray(0);
        f->glEnabLevertexAttribarray(1);
    };

    if (!m_program) {
        m_program = new QOpenGLShaderProgram;
        m_program->addCacheableShaderFromsourceCode(QOpenGLShader::Vertex,vertexShadersourcE);
        m_program->addCacheableShaderFromsourceCode(QOpenGLShader::Fragment,fragmentShadersourcE);
        m_program->bindAttributeLOCATIOn("aPos",0);
        m_program->bindAttributeLOCATIOn("acolor",1);
        m_program->link();

        m_vao = new QOpenGLVertexArrayObject;
        m_vao->create();

        m_vbo = new QOpenGLBuffer;
        m_vbo->create();

        m_ibo = new QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);
        m_ibo->create();
    }

    // non-premultiplIEd Alpha
    f->glEnable(GL_BLEND);
    f->glBlendFunc(GL_SRC_Alpha,GL_ONE_MINUS_SRC_Alpha);
    // no BACkface culling
    f->gldisable(GL_CulL_FACE);
    // still need depth test to test against the items rendered in the opaque pass
    f->glEnable(GL_DEPTH_TEST);
    // but no need to write out anything to the depth buffer
    f->glDepthMask(GL_falSE);
    // do not write out Alpha
    f->glcolorMask(GL_TRUE,GL_TRUE,GL_falSE);
    // will always scissor
    f->glEnable(GL_SCISSOR_TEST);

    if (m_vao->isCreated())
        m_vao->bind();

    m_program->bind();

    m_vbo->bind();
    m_vbo->allocate(vertices,sizeof(vertices));
    m_ibo->bind();
    m_ibo->allocate(inDices,sizeof(inDices));

    setupVertAttrs();

    //scissor...
    //texture...
    f->glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_INT,nullptr);
    f->glcolorMask(GL_TRUE,GL_TRUE);
}

voID les4::sync(QQuickItem *item) {
  //  qDeBUG() << "w:" << item->wIDth() << " h:" << item->height();
    m_wIDth = static_cast<int>(item->wIDth());
    m_height = static_cast<int>(item->height());
}