open_gl_line_renderer.h

Go to the documentation of this file.

#pragma once
 
#include "JuceHeader.h"
#include "common.h"
#include "open_gl_component.h"
#include "open_gl_multi_quad.h"
 
class OpenGlLineRenderer : public OpenGlComponent {
public:
    static constexpr int kLineFloatsPerVertex = 3;
    static constexpr int kFillFloatsPerVertex = 4;
    static constexpr int kLineVerticesPerPoint = 6;
    static constexpr int kFillVerticesPerPoint = 2;
    static constexpr int kLineFloatsPerPoint = kLineVerticesPerPoint * kLineFloatsPerVertex;
    static constexpr int kFillFloatsPerPoint = kFillVerticesPerPoint * kFillFloatsPerVertex;
 
    OpenGlLineRenderer(int num_points, bool loop = false);
 
    virtual ~OpenGlLineRenderer();
 
    virtual void init(OpenGlWrapper& open_gl) override;
 
    virtual void render(OpenGlWrapper& open_gl, bool animate) override;
 
    virtual void destroy(OpenGlWrapper& open_gl) override;
 
    force_inline void setColor(Colour color) { color_ = color; }
 
    force_inline void setLineWidth(float width) { line_width_ = width; }
 
    force_inline void setBoost(float boost) { boost_ = boost; }
 
    force_inline float boostLeftAt(int index) const { return boost_left_[index]; }
 
    force_inline float boostRightAt(int index) const { return boost_right_[index]; }
 
    force_inline float yAt(int index) const { return y_[index]; }
 
    force_inline float xAt(int index) const { return x_[index]; }
 
    force_inline void setBoostLeft(int index, float val) {
        boost_left_[index] = val;
        dirty_ = true;
        VITAL_ASSERT(num_points_ > index);
    }
 
    force_inline void setBoostRight(int index, float val) {
        boost_right_[index] = val;
        dirty_ = true;
        VITAL_ASSERT(num_points_ > index);
    }
 
    force_inline void setYAt(int index, float val) {
        y_[index] = val;
        dirty_ = true;
        VITAL_ASSERT(num_points_ > index);
    }
 
    force_inline void setXAt(int index, float val) {
        x_[index] = val;
        dirty_ = true;
        VITAL_ASSERT(num_points_ > index);
    }
 
    void setFillVertices(bool left);
 
    void setLineVertices(bool left);
 
    force_inline void setFill(bool fill) { fill_ = fill; }
 
    force_inline void setFillColor(Colour fill_color) {
        setFillColors(fill_color, fill_color);
    }
 
    force_inline void setFillColors(Colour fill_color_from, Colour fill_color_to) {
        fill_color_from_ = fill_color_from;
        fill_color_to_ = fill_color_to;
    }
 
    force_inline void setFillCenter(float fill_center) { fill_center_ = fill_center; }
 
    force_inline void setFit(bool fit) { fit_ = fit; }
 
    force_inline void setBoostAmount(float boost_amount) { boost_amount_ = boost_amount; }
 
    force_inline void setFillBoostAmount(float boost_amount) { fill_boost_amount_ = boost_amount; }
 
    force_inline void setIndex(int index) { index_ = index; }
 
    void boostLeftRange(float start, float end, int buffer_vertices, float min);
 
    void boostRightRange(float start, float end, int buffer_vertices, float min);
 
    void boostRange(float* boosts, float start, float end, int buffer_vertices, float min);
 
    void boostRange(vital::poly_float start, vital::poly_float end, int buffer_vertices, vital::poly_float min);
 
    void decayBoosts(vital::poly_float mult);
 
    void enableBackwardBoost(bool enable) { enable_backward_boost_ = enable; }
 
    force_inline int numPoints() const { return num_points_; }
 
    force_inline Colour color() const { return color_; }
 
    void drawLines(OpenGlWrapper& open_gl, bool left);
 
    bool anyBoostValue() { return any_boost_value_; }
 
private:
    Colour color_;              
    Colour fill_color_from_;    
    Colour fill_color_to_;      
 
    int num_points_;            
    float line_width_;          
    float boost_;               
    bool fill_;                 
    float fill_center_;         
    bool fit_;                  
 
    float boost_amount_;        
    float fill_boost_amount_;   
    bool enable_backward_boost_;
    int index_;                 
 
    bool dirty_;                
    bool last_drawn_left_;      
    bool last_negative_boost_;  
    bool loop_;                 
    bool any_boost_value_;      
    int num_padding_;           
    int num_line_vertices_;     
    int num_fill_vertices_;     
    int num_line_floats_;       
    int num_fill_floats_;       
 
    OpenGLShaderProgram* shader_;                 
    std::unique_ptr<OpenGLShaderProgram::Uniform> scale_uniform_;     
    std::unique_ptr<OpenGLShaderProgram::Uniform> color_uniform_;     
    std::unique_ptr<OpenGLShaderProgram::Uniform> boost_uniform_;     
    std::unique_ptr<OpenGLShaderProgram::Uniform> line_width_uniform_;
    std::unique_ptr<OpenGLShaderProgram::Attribute> position_;        
 
    OpenGLShaderProgram* fill_shader_;             
    std::unique_ptr<OpenGLShaderProgram::Uniform> fill_scale_uniform_; 
    std::unique_ptr<OpenGLShaderProgram::Uniform> fill_color_from_uniform_; 
    std::unique_ptr<OpenGLShaderProgram::Uniform> fill_color_to_uniform_;   
    std::unique_ptr<OpenGLShaderProgram::Uniform> fill_center_uniform_;     
    std::unique_ptr<OpenGLShaderProgram::Uniform> fill_boost_amount_uniform_;
    std::unique_ptr<OpenGLShaderProgram::Attribute> fill_position_;          
 
    GLuint vertex_array_object_; 
    GLuint line_buffer_;         
    GLuint fill_buffer_;         
    GLuint indices_buffer_;      
 
    std::unique_ptr<float[]> x_;           
    std::unique_ptr<float[]> y_;           
    std::unique_ptr<float[]> boost_left_;  
    std::unique_ptr<float[]> boost_right_; 
    std::unique_ptr<float[]> line_data_;   
    std::unique_ptr<float[]> fill_data_;   
    std::unique_ptr<int[]> indices_data_;  
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(OpenGlLineRenderer)
};