open_gl_component.h

Go to the documentation of this file.

#pragma once
 
#include "common.h"
#include "shaders.h"
#include "skin.h"
#include "synth_module.h"
 
class SynthSection;
class OpenGlCorners;
 
class OpenGlComponent : public Component {
public:
    static bool setViewPort(Component* component, Rectangle<int> bounds, OpenGlWrapper& open_gl);
 
    static bool setViewPort(Component* component, OpenGlWrapper& open_gl);
 
    static void setScissor(Component* component, OpenGlWrapper& open_gl);
 
    static void setScissorBounds(Component* component, Rectangle<int> bounds, OpenGlWrapper& open_gl);
 
    static std::unique_ptr<OpenGLShaderProgram::Uniform> getUniform(const OpenGlWrapper& open_gl,
                                                                    const OpenGLShaderProgram& program,
                                                                    const char* name) {
        if (open_gl.context.extensions.glGetUniformLocation(program.getProgramID(), name) >= 0)
            return std::make_unique<OpenGLShaderProgram::Uniform>(program, name);
        return nullptr;
    }
 
    static std::unique_ptr<OpenGLShaderProgram::Attribute> getAttribute(const OpenGlWrapper& open_gl,
                                                                        const OpenGLShaderProgram& program,
                                                                        const char* name) {
        if (open_gl.context.extensions.glGetAttribLocation(program.getProgramID(), name) >= 0)
            return std::make_unique<OpenGLShaderProgram::Attribute>(program, name);
        return nullptr;
    }
 
    OpenGlComponent(String name = "");
 
    virtual ~OpenGlComponent();
 
    virtual void resized() override;
 
    virtual void parentHierarchyChanged() override;
 
    void addRoundedCorners();
 
    void addBottomRoundedCorners();
 
    virtual void init(OpenGlWrapper& open_gl);
 
    virtual void render(OpenGlWrapper& open_gl, bool animate) = 0;
 
    void renderCorners(OpenGlWrapper& open_gl, bool animate, Colour color, float rounding);
 
    void renderCorners(OpenGlWrapper& open_gl, bool animate);
 
    virtual void destroy(OpenGlWrapper& open_gl);
 
    virtual void paintBackground(Graphics& g);
 
    void repaintBackground();
 
    Colour getBodyColor() const { return body_color_; }
 
    void setParent(const SynthSection* parent) { parent_ = parent; }
 
    float findValue(Skin::ValueId value_id);
 
    void setSkinValues(const Skin& skin) {
        skin.setComponentColors(this, skin_override_, false);
    }
 
    void setSkinOverride(Skin::SectionOverride skin_override) { skin_override_ = skin_override; }
 
    static inline String translateFragmentShader(const String& code) {
#if OPENGL_ES
        return String("#version 300 es\n") + "out mediump vec4 fragColor;\n" +
             code.replace("varying", "in").replace("texture2D", "texture").replace("gl_FragColor", "fragColor");
#else
        return OpenGLHelpers::translateFragmentShaderToV3(code);
#endif
    }
 
    static inline String translateVertexShader(const String& code) {
#if OPENGL_ES
        return String("#version 300 es\n") + code.replace("attribute", "in").replace("varying", "out");
#else
        return OpenGLHelpers::translateVertexShaderToV3(code);
#endif
    }
 
    force_inline void checkGlError() {
#if DEBUG
        int error = glGetError();
      assert(error == GL_NO_ERROR);
#endif
    }
 
    void setBackgroundColor(const Colour& color) { background_color_ = color; }
 
protected:
    bool setViewPort(OpenGlWrapper& open_gl);
 
    std::unique_ptr<OpenGlCorners> corners_; 
    bool only_bottom_corners_;               
    Colour background_color_;                
    Colour body_color_;                      
    const SynthSection* parent_;             
    Skin::SectionOverride skin_override_;    
    const vital::StatusOutput* num_voices_readout_; 
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(OpenGlComponent)
};