ViewPortSmoothShaderLogic.h

#pragma once
#include <NDEVR/GLComputeShader.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/PointContainer.h>
#include <NDEVR/RGBColor.h>
namespace NDEVR
{
    class ViewPortSmoothShaderLogic : public GLComputeShader
    {
    public:
        ViewPortSmoothShaderLogic();
        struct alignas(16) UBO {
            // 0..63
            Matrix<fltp04> inv_view;
 
            // 64..111 (vec2s back-to-back)
            Vector<2, fltp04> pp;
            Vector<2, fltp04> f;
            Vector<2, fltp04> inv_f;
            Vector<2, fltp04> size_f;
            Vector<2, fltp04> size_fr;
            Vector<2, uint04> size_i;
 
            // 112..127
            Vector<4, fltp04> k12p1p2;
 
            // 128..143
            Vector<4, fltp04> cam_pos4;
 
            // 144..159 (four floats)
            float k3, max_dist2, max_dist2_relax, max_error_percent_sqrd;
 
            // 160..175
            Vector<4, uint04> weightsA; // record, discard, max, reduce
 
            // 192..207
            Vector<4, uint04>  counts;
        };
        static_assert(sizeof(UBO) == 192, "UBO size mismatch");
        static_assert(alignof(UBO) == 16, "bad alignment");
        static_assert(offsetof(UBO, pp) == 64, "bad offset pp");
        static_assert(offsetof(UBO, size_i) == 104, "bad offset size_i");
        static_assert(offsetof(UBO, k12p1p2) == 112, "bad offset k12p1p2");
        static_assert(offsetof(UBO, cam_pos4) == 128, "bad offset cam_pos4");
        static_assert(offsetof(UBO, k3) == 144, "bad offset k3");
        static_assert(offsetof(UBO, weightsA) == 160, "bad offset weightsA");
        static_assert(offsetof(UBO, counts) == 176, "bad offset counts");
        void runAll(uint04 count);
        void createUBOBuffer();
        void buildShader();

        template<class t_point_type>
        void getInput(PointContainer<t_point_type>& active, PointContainer<t_point_type>& inactive, uint04 record_weight)
        {
            //wait for previous calc to finish
            m_gl->glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_BUFFER_UPDATE_BARRIER_BIT);
            m_temp_idx.setSize(m_last_size);
            m_colors.setSize(m_last_size);
            active.setSize(m_last_size);
            readBytes(m_ssboOutIdx, m_temp_idx.begin(), GLsizeiptr(sizeof(uint04) * active.size()));
            readBytes(m_ssboInW, active.weights.begin(), GLsizeiptr(sizeof(uint04) * active.size()));
            readBytes(m_ssboInPos, active.locations.begin(), GLsizeiptr(sizeof(Vector<3, fltp04>) * active.size()));
            readBytes(m_ssboInColor, m_colors.begin(), GLsizeiptr(sizeof(uint04) * active.size()));
            uint04 offset = 0;
            const uint04 count = active.size();
            for (uint04 i = 0; i < count; i++)
            {
                active.data[i].setColor(m_colors[i]);
                if (m_temp_idx[i] == 0)
                {
                    if (active.weights[i] >= record_weight)
                    {
                        inactive.locations.add(active.locations[i]);
                        inactive.data.add(active.data[i]);
                        inactive.weights.add(active.weights[i]);
                    }
                }
                else
                {
                    active.locations[offset] = active.locations[i];
                    active.data[offset] = active.data[i];
                    active.weights[offset] = active.weights[i];
                    ++offset;
                }
            }
            active.setSize(offset);
        }

        template<class t_point_type>
        void uploadInputs(const PointContainer<t_point_type>& active, uint04 pix_count)
        {
            if (!m_ssboPxKey)
                m_gl->glGenBuffers(1, &m_ssboPxKey);
            m_colors.setSize(active.size());
            for (uint04 i = 0; i < m_colors.size(); i++)
                m_colors[i] = active.data[i].color();
            m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboPxKey);
            if (m_px_key_size < pix_count)
            {
                m_px_key_size = pix_count;
                m_gl->glBufferData(GL_SHADER_STORAGE_BUFFER
                    , GLsizeiptr(sizeof(uint04) * pix_count)
                    , nullptr, GL_DYNAMIC_DRAW);
            }
            const GLuint fill = 0xFFFFFFFFu;
            m_gl->glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R32UI,
                GL_RED_INTEGER, GL_UNSIGNED_INT, &fill);
 
            if (m_out_size < active.size())
            {
                m_out_size = 2 * active.size();
                if (!m_ssboOutIdx)
                    m_gl->glGenBuffers(1, &m_ssboOutIdx);
                m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboOutIdx);
                m_gl->glBufferData(GL_SHADER_STORAGE_BUFFER
                    , GLsizeiptr(sizeof(uint04)) * m_out_size
                    , nullptr, GL_DYNAMIC_DRAW);
                //position
                if (!m_ssboInPos)
                    m_gl->glGenBuffers(1, &m_ssboInPos);
                m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInPos);
                m_gl->glBufferData(GL_SHADER_STORAGE_BUFFER
                    , GLsizeiptr(sizeof(Vertex<3, fltp04>)) * m_out_size
                    , nullptr, GL_DYNAMIC_DRAW);
                //color
                if (!m_ssboInColor)
                    m_gl->glGenBuffers(1, &m_ssboInColor);
                m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInColor);
                m_gl->glBufferData(GL_SHADER_STORAGE_BUFFER
                    , GLsizeiptr(sizeof(uint04)) * m_out_size
                    , nullptr, GL_DYNAMIC_DRAW);
                //weight
                if (!m_ssboInW)
                    m_gl->glGenBuffers(1, &m_ssboInW);
                m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInW);
                m_gl->glBufferData(GL_SHADER_STORAGE_BUFFER
                    , GLsizeiptr(sizeof(uint04)) * m_out_size
                    , nullptr, GL_DYNAMIC_DRAW);
            }
            m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInPos);
            m_gl->glBufferSubData(GL_SHADER_STORAGE_BUFFER
                , 0, GLsizeiptr(sizeof(Vertex<3, fltp04>)) * active.size()
                , active.locations.begin());
 
            m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInColor);
            m_gl->glBufferSubData(GL_SHADER_STORAGE_BUFFER
                , 0, GLsizeiptr(sizeof(uint04)) * active.size()
                , m_colors.begin());
 
            m_gl->glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssboInW);
            m_gl->glBufferSubData(GL_SHADER_STORAGE_BUFFER
                , 0, GLsizeiptr(sizeof(uint04)) * active.size()
                , active.weights.begin());
            m_last_size = active.size();
 
        }

        void setUBO(const UBO& u);
        void setQtGL(QOpenGLFunctions_4_3_Core* gl);
        static void ReadBytes(QOpenGLFunctions_4_3_Core* gl, GLenum target, GLuint buf, void* dst, GLsizeiptr bytes);
    protected:
        uint04 m_px_key_size = 0;           
        uint04 m_out_size = 0;              
        uint04 m_last_size = 0;             
        QOpenGLShaderProgram* m_shader;     
        GLuint m_csA = 0;                   
        GLuint m_uboU = 0;                  
        GLuint m_ssboInPos = 0;             
        GLuint m_ssboInColor = 0;           
        GLuint m_ssboInW = 0;               
        GLuint m_ssboPxKey = 0;             
        GLuint m_ssboOutIdx = 0;            
        Buffer<uint04> m_temp_idx;          
        Buffer<RGBColor> m_colors;          
    };
}