ColorPositionShaderLogic.h

#pragma once
#include <NDEVR/GLComputeShader.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/PointContainer.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/RGBColor.h>
namespace NDEVR
{
    class ColorPositionShaderLogic : public GLComputeShader
    {
    public:
        ColorPositionShaderLogic();
        struct alignas(16) UBO {
            Matrix<fltp04> view_matrix;     
 
            Vector<2, fltp04> pp;           
            Vector<2, fltp04> f;            
            Vector<2, fltp04> inv_f;        
            Vector<2, fltp04> size_f;       
            Vector<2, uint04> center_i;     
            Vector<2, uint04> size_i;       
 
            Vector<4, fltp04> k12p1p2;      
 
            Vector<4, fltp04> cam_pos4;     
 
            float k3;                       
            float max_dist2;                
            float depth_scale;              
            float max_error_percent_sqrd;   
 
            Vector<4, uint04> weight_info;  
        };
        static_assert(sizeof(UBO) == 176, "UBO size mismatch");

        void runAll(Buffer<RGBColor>& last_colors);
        void createUBOBuffer();
        void buildShader();
        void createImage(const Vector<2, uint04>& size);
        void updateImage(const uint01* data, const Vector<2, uint04>& size);
        template<class t_point_type>
        void getInput(PointContainer<t_point_type>& active)
        {
            if (m_size_i == 0)
            {
                active.clear();
                return;
            }
            active.setSize(m_size_i);
            //wait for previous calc to finish
            m_gl->glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_BUFFER_UPDATE_BARRIER_BIT);
            readBytes(m_ssboPos, active.locations.begin(), GLsizeiptr(sizeof(Vector<3, fltp04>) * m_size_i));
            readBytes(m_ssboW, active.weights.begin(), GLsizeiptr(sizeof(uint04) * m_size_i));
            
        }

        void uploadInputs(const uint01* depth, Vector<2, uint04> size)
        {
            if (m_depth_image == 0)
                createImage(size);
            m_size_i = size[X] * size[Y];
            ensureSSBO(m_ssboPos, GLsizeiptr(sizeof(Vector<3, fltp04>)) * m_size_i, GL_DYNAMIC_DRAW);
            ensureSSBO(m_ssboW, GLsizeiptr(sizeof(uint04) * m_size_i), GL_DYNAMIC_DRAW);
            updateImage(depth, size);
 
        }

        void setUBO(const UBO& u);
        void setQtGL(QOpenGLFunctions_4_3_Core* gl);
    protected:
        Buffer<RGBColor> m_last_colors;             
        QOpenGLShaderProgram* m_shader = nullptr;   
        bool has_normal = false;                    
        GLuint m_depth_image = 0;                   
        GLuint m_csA = 0;                           
        GLuint m_uboU = 0;                          
        GLuint m_ssboPos = 0;                       
        GLuint m_tex = 0;                           
        GLuint m_ssboW = 0;                         
        uint04 m_size_i = 0;                        
    };
}