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;
 
namespace DISP3DLIB
{
 
class BrainSurface;
class DipoleObject;
class NetworkObject;
class PolylineObject;
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 = DISP3DLIB::ShaderMode;
    static constexpr ShaderMode Standard = DISP3DLIB::Standard;
    static constexpr ShaderMode Holographic = DISP3DLIB::Holographic;
    static constexpr ShaderMode Anatomical = DISP3DLIB::Anatomical;
    static constexpr ShaderMode Dipole = DISP3DLIB::Dipole;
    static constexpr ShaderMode XRay = DISP3DLIB::XRay;
    static constexpr ShaderMode ShowNormals = DISP3DLIB::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 renderPolyline(QRhiCommandBuffer* cb, QRhi* rhi, const SceneData& data, PolylineObject* polyline);
 
    //=========================================================================================================
    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;
};
 
} // namespace DISP3DLIB
 
#endif // BRAINRENDERER_H