brainrenderer.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef BRAINRENDERER_H
#define BRAINRENDERER_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../disp3D_global.h"
 
#include "../core/rendertypes.h"
 
#include <QMatrix4x4>
#include <QVector3D>
#include <memory>
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class QRhi;
class QRhiCommandBuffer;
class QRhiRenderTarget;
class QRhiRenderPassDescriptor;
class QRhiResourceUpdateBatch;
class QRhiTexture;
class QRhiRenderBuffer;
class QRhiTextureRenderTarget;
class BrainSurface;
class DipoleObject;
class NetworkObject;
namespace DISP3DLIB { class VideoOverlay; class SliceObject; }
 
//=============================================================================================================
class DISP3DSHARED_EXPORT BrainRenderer
{
public:
    //=========================================================================================================
    BrainRenderer();
 
    //=========================================================================================================
    ~BrainRenderer();
 
    // ShaderMode is defined in core/rendertypes.h for lightweight inclusion.
    // These aliases preserve backward compatibility.
    using ShaderMode = ::ShaderMode;
    static constexpr ShaderMode Standard     = ::Standard;
    static constexpr ShaderMode Holographic  = ::Holographic;
    static constexpr ShaderMode Anatomical   = ::Anatomical;
    static constexpr ShaderMode Dipole       = ::Dipole;
    static constexpr ShaderMode XRay         = ::XRay;
    static constexpr ShaderMode ShowNormals  = ::ShowNormals;

    struct SceneData {
        QMatrix4x4 mvp;
        QVector3D cameraPos;
        QVector3D lightDir;
        bool lightingEnabled;
        float overlayMode = 0.0f;       // 0=FsSurface, 1=FsAnnotation, 2=Scientific, 3=STC
 
        // Viewport rectangle (floating-point, pixels)
        float viewportX = 0, viewportY = 0, viewportW = 0, viewportH = 0;
        // Scissor rectangle (integer, pixels)
        int scissorX = 0, scissorY = 0, scissorW = 0, scissorH = 0;
    };
    
    //=========================================================================================================
    void initialize(QRhi *rhi, QRhiRenderPassDescriptor *rp, int sampleCount);
 
    //=========================================================================================================
    void ensureRenderTargets(QRhi *rhi, QRhiTexture *colorTex, const QSize &pixelSize);
 
    //=========================================================================================================
    QRhiRenderTarget *rtClear() const;

    QRhiRenderTarget *rtPreserve() const;
 
    //=========================================================================================================
    void beginFrame(QRhiCommandBuffer *cb);
 
    //=========================================================================================================
    void beginPreservingPass(QRhiCommandBuffer *cb);
 
    //=========================================================================================================
    void updateSceneUniforms(QRhi *rhi, const SceneData &data);
 
    //=========================================================================================================
    void renderSurface(QRhiCommandBuffer *cb, QRhi *rhi, const SceneData &data, BrainSurface *surface, ShaderMode mode);
 
    //=========================================================================================================
    int prepareSurfaceDraw(QRhiResourceUpdateBatch *u, const SceneData &data, BrainSurface *surface);

    void issueSurfaceDraw(QRhiCommandBuffer *cb, BrainSurface *surface, ShaderMode mode, int uniformOffset);
 
    //=========================================================================================================
    // ── WORKAROUND(QRhi-GLES2) ──────────────────────────────────────────
    // The Qt QRhi GLES2/WebGL backend has a bug where only the first
    // drawIndexed() per render pass produces visible output.  On WASM we
    // work around this by merging all brain surfaces into a single VBO/IBO
    // and issuing one drawIndexed().  When the upstream bug is fixed these
    // two methods (and the merged buffers in Impl) can be removed.
    //
    void prepareMergedSurfaces(QRhi *rhi, QRhiResourceUpdateBatch *u,
                               const QVector<BrainSurface*> &surfaces,
                               const QString &groupName = QStringLiteral("default"));

    void invalidateMergedGroup(const QString &groupName = QStringLiteral("default"));

    bool hasMergedContent(const QString &groupName) const;

    void drawMergedSurfaces(QRhiCommandBuffer *cb, QRhi *rhi,
                            const SceneData &data, ShaderMode mode,
                            const QString &groupName = QStringLiteral("default"));
 
    //=========================================================================================================
    void renderDipoles(QRhiCommandBuffer *cb, QRhi *rhi, const SceneData &data, DipoleObject *dipoles);
 
    //=========================================================================================================
    void renderNetwork(QRhiCommandBuffer *cb, QRhi *rhi, const SceneData &data, NetworkObject *network);
 
    //=========================================================================================================
    void prepareVideoOverlay(QRhi *rhi,
                             QRhiResourceUpdateBatch *u,
                             DISP3DLIB::VideoOverlay *overlay);
 
    //=========================================================================================================
    void renderVideoOverlay(QRhiCommandBuffer *cb, QRhi *rhi,
                             const SceneData &data,
                             DISP3DLIB::VideoOverlay *overlay);

    void renderVideoOverlayOnSurface(QRhiCommandBuffer *cb, QRhi *rhi,
                                     const SceneData &data,
                                     DISP3DLIB::VideoOverlay *overlay,
                                     BrainSurface *surface);
 
    //=========================================================================================================
    void prepareSlice(QRhi *rhi,
                      QRhiResourceUpdateBatch *u,
                      DISP3DLIB::SliceObject *slice,
                      int slotIndex);
 
    //=========================================================================================================
    int prepareSliceDraw(QRhiResourceUpdateBatch *u,
                         const SceneData &data,
                         int slotIndex);
 
    //=========================================================================================================
    void issueSliceDraw(QRhiCommandBuffer *cb,
                        int slotIndex,
                        int uniformOffset);
 
    //=========================================================================================================
    void endPass(QRhiCommandBuffer *cb);
    
private:
    struct Impl;
    std::unique_ptr<Impl> d;
};
 
#endif // BRAINRENDERER_H