RenderState.hpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com> (C++, Java) and Rami Santina (Java)
 * Copyright Gothel Software e.K. and the authors
 *
 * SPDX-License-Identifier: MIT
 *
 * This Source Code Form is subject to the terms of the MIT License
 * If a copy of the MIT was not distributed with this file,
 * you can obtain one at https://opensource.org/license/mit/.
 */
#ifndef JAU_GAMP_GRAPH_GL_RENDERSTATE_HPP_
#define JAU_GAMP_GRAPH_GL_RENDERSTATE_HPP_
 
#include <string>
#include <string_view>
 
#include <jau/basic_types.hpp>
#include <jau/math/geom/frustum.hpp>
#include <jau/math/vec4f.hpp>
#include <jau/ordered_atomic.hpp>
 
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/render/gl/data/GLUniformData.hpp>
#include <gamp/render/gl/data/GLArrayDataServer.hpp>
#include <gamp/render/gl/glsl/ShaderProgram.hpp>
 
#include <gamp/graph/RenderMode.hpp>
#include <gamp/graph/gl/RenderNames.hpp>
 
namespace gamp::graph::gl {
 
    using namespace gamp::render::gl;
    using namespace gamp::render::gl::glsl;
 
    /** \addtogroup Gamp_Graph
     *
     *  @{
     */
     
    /**
     * The RenderState is owned by GraphRenderer.
     *
     * It holds rendering state data like jau::math::util::PMVMat4f, viewport,
     * but also the current staticColor().
     */
    class RenderState {
      private:
        constexpr static std::string_view thisKey = "gamp.graph.gl.RenderState" ;
        
      public:    
        /** Minimum pass2 AA-quality rendering {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa. */
        constexpr static int MIN_AA_QUALITY  = 0;
        /** Maximum pass2 AA-quality rendering {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa. */
        constexpr static int MAX_AA_QUALITY  = 1;
        /** Default pass2 AA-quality rendering {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa. */
        constexpr static int DEFAULT_AA_QUALITY  = MAX_AA_QUALITY;
        /** Returns clipped AA quality value to [MIN_AA_QUALITY..MAX_AA_QUALITY] */
        constexpr static int clipAAQuality(int v) { return std::min(MAX_AA_QUALITY, std::max(v, MIN_AA_QUALITY)); }
    
        /** Minimum pass2 AA sample count {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa or RenderMode::msaa. */
        constexpr static int MIN_AA_SAMPLE_COUNT  = 1;
        /** Maximum pass2 AA sample count {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa or RenderMode::msaa. */
        constexpr static int MAX_AA_SAMPLE_COUNT  = 8;
        /** Default pass2 AA sample count {@value} for Graph Region AA GraphRegion::renderMode(): RenderMode::vbaa or RenderMode::msaa. */
        constexpr static int DEFAULT_AA_SAMPLE_COUNT = 4;
        /** Returns clipped AA sample-count to [MIN_AA_SAMPLE_COUNT..MAX_AA_SAMPLE_COUNT] */
        constexpr static int clipAASampleCount(int v) { return std::min(MAX_AA_SAMPLE_COUNT, std::max(v, MIN_AA_SAMPLE_COUNT)); }
    
        /**
         * Bitfield hint, {@link #hintBitsSet(int) if set}
         * stating <i>enabled</i> {@link GL#GL_BLEND}, otherwise <i>disabled</i>.
         * <p>
         * Shall be set via {@link #setHintBits(int)} and cleared via {@link #clearHintBits(int)}.
         * </p>
         * <p>
         * If set, {@link GLRegion#draw(GL2ES2, RegionRenderer) GLRegion's draw-method}
         * will set the proper {@link GL#glBlendFuncSeparate(int, int, int, int) blend-function}
         * and the clear-color to <i>transparent-black</i> in case of {@link Region#isTwoPass(int) multipass} FBO rendering.
         * </p>
         * <p>
         * Shall be set by custom code, e.g. via {@link RegionRenderer}'s
         * enable and disable {@link RegionRenderer.GLCallback} as done in
         * {@link RegionRenderer#defaultBlendEnable} and {@link RegionRenderer#defaultBlendDisable}.
         * </p>
         */
        constexpr static int BITHINT_BLENDING_ENABLED = 1 << 0 ;
    
        /**
         * Bitfield hint, {@link #hintBitsSet(int) if set}
         * stating globally <i>enabled</i> {@link GL#GL_DEPTH_TEST}, otherwise <i>disabled</i>.
         * <p>
         * Shall be set via {@link #setHintBits(int)} and cleared via {@link #clearHintBits(int)}.
         * </p>
         * <p>
         * {@link GLRegion#draw(GL2ES2, RegionRenderer) GLRegion's draw-method}
         * may toggle depth test, and reset it's state according to this hint.
         * </p>
         * <p>
         * Shall be set by custom code, e.g. after {@link RenderState} or {@link RegionRenderer} construction.
         * </p>
         */
        constexpr static int BITHINT_GLOBAL_DEPTH_TEST_ENABLED = 1 << 1 ;
    
        constexpr static int DEBUG_LINESTRIP = 1 << 0 ;
    
        /**
         * Representation of {@link RenderState} data per {@link ShaderProgram}
         * as {@link GLUniformData}.
         * <p>
         * FIXME: Utilize 'ARB_Uniform_Buffer_Object' where available!
         * </p>
         */
        class ProgramLocal {
          private:
            RenderState& m_rs;
            GLUniformSyncPMVMat4fRef gcu_PMVMatrix;
            GLUniformScalarF32Ref gcu_Weight;
            GLUniformVec4fRef gcu_StaticColor;
            int rsId = -1;
            
          public:    
            ProgramLocal(RenderState& rs)
            : m_rs(rs), gcu_PMVMatrix(rs.gcu_PMVMatrix)
            {
                gcu_Weight = GLUniformScalarF32::create(RenderNames::gcu_Weight, m_rs.m_weight);
                gcu_StaticColor = GLUniformVec4f::create(RenderNames::gcu_StaticColor, m_rs.m_staticColor);
            }
    
            constexpr int getRenderStateId() const noexcept { return rsId; }
    
            /**
             * <p>
             * Since {@link RenderState} data is being used in multiple
             * {@link ShaderProgram}s the data must always be written.
             * </p>
             * @param gl
             * @param updateLocation
             * @param renderModes
             * @param setPMVMat01
             * @param throwOnError
             * @return true if no error occurred, i.e. all locations found, otherwise false.
             */
            bool update(GL& gl, RenderState& rs, bool updateLocation, RenderMode renderMode,
                        bool setPMVMat01, bool pass1, bool throwOnError) {
                if( rs.m_id != rsId ) {
                    // Assignment of Renderstate buffers to uniforms (no copy, direct reference)
                    gcu_PMVMatrix = rs.gcu_PMVMatrix;
                    gcu_Weight->scalar() = rs.m_weight;
                    gcu_StaticColor->vec4f() = rs.m_staticColor;
                    rsId = rs.m_id;
                }
                bool res = true;
                if( rs.m_sp && rs.m_sp->inUse() ) {
                    if( setPMVMat01 ) {
                        bool r0 = rs.updateUniformDataLoc(gl, updateLocation, true, *gcu_PMVMatrix, throwOnError);
                        res = res && r0;
                    }
                    if( pass1 ) {
                        if( gamp::graph::hasVariableWeight( renderMode ) ) {
                            const bool r0 = rs.updateUniformDataLoc(gl, updateLocation, true, *gcu_Weight, throwOnError);
                            res = res && r0;
                        }
                        {
                            const bool r0 = rs.updateUniformDataLoc(gl, updateLocation, true, *gcu_StaticColor, throwOnError);
                            res = res && r0;
                        }
                    }
                }
                return res;
            }
    
            std::string toString() {
                std::string sb("ProgramLocal[rsID ");
                sb.append(std::to_string(rsId)).append("\n");                
                // pmvMatrix.toString(sb, "%.2f");
                sb.append(gcu_PMVMatrix->toString()).append(", ").append("\n");
                sb.append(gcu_StaticColor->toString()).append(", ");
                sb.append(gcu_Weight->toString()).append("]");
                return sb;
            }    
        };
    
      private:
        int m_id;
        GLUniformSyncPMVMat4fRef gcu_PMVMatrix;
        float m_weight;
        jau::math::Vec4f m_staticColor;
        /** Pass2 AA-quality rendering {@value} for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link Region#VBAA_RENDERING_BIT}. */
        int m_aaQuality;        
        /** Default pass2 AA sample count {@value} for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link Region#VBAA_RENDERING_BIT} or {@link Region#MSAA_RENDERING_BIT}. */
        int m_sampleCount;
        /** Optional clipping {@link Frustum}, which shall be pre-multiplied with the Mv-matrix. Null if unused. */
        jau::math::geom::Frustum m_clipFrustum;
        bool m_useFrustumClipping;
        int m_hintBits;
        int m_debugBits;
        ShaderProgramRef m_sp;
        static jau::sc_atomic_int nextID;
    
        static int getNextID() { return nextID++; }
        
      public:    
        /**
         * Create a RenderState, a composition of RegionRenderer
         * @param pmvMat used PMVMatrix4f, could be shared
         */
        RenderState(jau::math::util::PMVMat4f& pmvMat)
        : m_id( getNextID() ), 
          gcu_PMVMatrix(GLUniformSyncPMVMat4fExt::create(RenderNames::gcu_PMVMatrix, pmvMat, pmvMat.getSyncPMvMviMvit())), // P, Mv, Mvi and Mvit
          m_weight(1), m_staticColor(1, 1, 1, 1),
          m_aaQuality(DEFAULT_AA_QUALITY), m_sampleCount(DEFAULT_AA_SAMPLE_COUNT),
          m_clipFrustum(), m_useFrustumClipping(false),
          m_hintBits(0), m_debugBits(0), m_sp(nullptr)  
        {  }
    
        constexpr int id() const noexcept { return m_id; }
    
        /** Return the current {@link ShaderProgram} */
        constexpr const ShaderProgramRef& shaderProgram() const noexcept { return m_sp; }
        /** Return the current {@link ShaderProgram} */
        constexpr ShaderProgramRef& shaderProgram() noexcept { return m_sp; }
    
        /** Return whether the current {@link ShaderProgram} is {@link ShaderProgram#inUse() in use}. */
        constexpr bool isShaderProgramInUse() const noexcept { return m_sp ? m_sp->inUse() : false; }
    
        /**
         * Sets the current {@link ShaderProgram} and enables it.
         *
         * If the given {@link ShaderProgram} is not {@link #getShaderProgram() the current}, method returns true, otherwise false.
         *
         * @param gl
         * @param spNext the next current {@link ShaderProgram} to be set and enabled
         * @return true if a new shader program is being used and hence external uniform-data and -location,
         *         as well as the attribute-location must be updated, otherwise false.
         */
        bool setShaderProgram(GL& gl, ShaderProgramRef& spNext) {
            if( *spNext == *m_sp ) {
                m_sp->useProgram(gl, true);
                return false;
            }
            if( m_sp ) {
                m_sp->notifyNotInUse();
            }
            m_sp = spNext;
            m_sp->useProgram(gl, true);
            return true;
        }
    
        const jau::math::util::PMVMat4f& getMatrix() const noexcept { return gcu_PMVMatrix->pmv(); }
        jau::math::util::PMVMat4f& getMatrix() noexcept  { return gcu_PMVMatrix->pmv(); }
    
        static bool isWeightValid(float v) { return 0.0f <= v && v <= 1.9f ; }
        float getWeight() { return m_weight; }
        void setWeight(float v) {
            if( !isWeightValid(v) ) {
                 throw jau::IllegalArgumentError("Weight out of range", E_FILE_LINE);
            }
            m_weight = v;
        }
    
        const jau::math::Vec4f& staticColor() const noexcept { return m_staticColor; }
        jau::math::Vec4f& staticColor() noexcept { return m_staticColor; }
 
        constexpr float weight() const noexcept { return m_weight; }
                    
        /** Sets pass2 AA-quality rendering value clipped to the range [{@link Region#MIN_AA_QUALITY}..{@link Region#MAX_AA_QUALITY}] for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link Region#VBAA_RENDERING_BIT}. */
        int setAAQuality(int v) { int q=clipAAQuality(v); m_aaQuality=q; return q;}
        /** Returns pass2 AA-quality rendering value for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link Region#VBAA_RENDERING_BIT}. */
        constexpr int aaQuality() const noexcept { return m_aaQuality; }
    
        /** Sets pass2 AA sample count clipped to the range [{@link Region#MIN_AA_SAMPLE_COUNT}..{@link Region#MAX_AA_SAMPLE_COUNT}] for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link #VBAA_RENDERING_BIT} or {@link Region#MSAA_RENDERING_BIT}. */
        int setSampleCount(int v) { int s=clipAASampleCount(v); m_sampleCount=s; return s;}
        /** Returns pass2 AA sample count for Graph Region AA {@link Region#getRenderModes() render-modes}: {@link #VBAA_RENDERING_BIT} or {@link Region#MSAA_RENDERING_BIT}. */
        constexpr int sampleCount() const noexcept { return m_sampleCount; }
    
        /** Set the optional clipping {@link Frustum}, which shall be pre-multiplied with the Mv-matrix or null to disable. */
        void setFrustumClipping(const jau::math::geom::Frustum& clipFrustum) noexcept {            
            m_clipFrustum = clipFrustum;
            m_useFrustumClipping=true;
        }
        void disableFrustumClipping() noexcept { m_useFrustumClipping = false; }
        constexpr bool usesFrustumClipping() const noexcept { return m_useFrustumClipping; }
        
        /** Returns the optional Mv-premultiplied clipping {@link Frustum} or nullptr if unused. */
        jau::math::geom::Frustum* clipFrustum() { return m_useFrustumClipping ? &m_clipFrustum : nullptr; }
    
        constexpr int hintBits() const noexcept { return m_hintBits; }
        constexpr bool hintBitsSet(int bits) const noexcept { return bits == ( m_hintBits & bits ); }
        void setHintBits(int bits) noexcept { m_hintBits |= bits; }
        void clearHintBits(int bits) noexcept { m_hintBits &= ~bits; }
    
        constexpr int debugBits() const noexcept { return m_debugBits; }
        constexpr bool debugBitsSet(int mask) const noexcept { return mask == ( m_debugBits & mask ); }
        void setDebugBits(int mask) noexcept { m_debugBits |= mask; }
        void clearDebugBits(int mask) noexcept { m_debugBits &= ~mask; }
    
        /**
         *
         * @param gl
         * @param updateLocation
         * @param data
         * @param throwOnError
         * @return true if no error occured, i.e. all locations found, otherwise false.
         */
        bool updateUniformLoc(GL& gl, bool updateLocation, GLUniformData& data, bool throwOnError) {
            if( m_sp && ( updateLocation || 0 > data.location() ) ) {
                const bool ok = 0 <= data.setLocation(gl, m_sp->program());
                if( throwOnError && !ok ) {
                    m_sp->dumpSource();
                    throw RenderException("Could not locate "+data.name()+" in "+m_sp->toString()+", "+data.toString(), E_FILE_LINE);
                }
                return ok;
            } else {
                return true;
            }
        }
    
        /**
         *
         * @param gl
         * @param updateLocation
         * @param updateData
         * @param data
         * @param throwOnError
         * @return true if no error occured, i.e. all locations found, otherwise false.
         */
        bool updateUniformDataLoc(GL& gl, bool updateLocation, bool updateData, GLUniformData& data, bool throwOnError) {
            updateLocation = updateLocation || 0 > data.location();
            if( m_sp && updateLocation ) {
                updateData = 0 <= data.setLocation(gl, m_sp->program());
                if( throwOnError && !updateData ) {
                    m_sp->dumpSource();
                    throw RenderException("Could not locate "+data.name()+" in "+m_sp->toString()+", "+data.toString(), E_FILE_LINE);
                }
            }
            if( updateData ){
                data.send(gl);
                return true;
            } else {
                return !updateLocation;
            }
        }
    
        /**
         * @param gl
         * @param data
         * @param throwOnError
         * @return true if no error occured, i.e. all locations found, otherwise false.
         */
        bool updateAttributeLoc(GL& gl, bool updateLocation, GLArrayData& data, bool throwOnError) {
            if( m_sp && ( updateLocation || 0 > data.location() ) ) {
                const bool ok = 0 <= data.setLocation(gl, m_sp->program());
                if( throwOnError && !ok ) {
                    m_sp->dumpSource();
                    throw RenderException("Could not locate "+data.name()+" in "+m_sp->toString()+", "+data.toString(), E_FILE_LINE);
                }
                return ok;
            } else {
                return true;
            }
        }
    
        /**
         * Only nullifies {@link ShaderProgram} reference owned by {@link RegionRenderer}.
         */
        /* pp */ void destroy() {
            m_sp = nullptr; // owned by RegionRenderer
        }
    
        std::string toString() {
            return "RenderState["+(m_sp ? m_sp->toString() : "n/a")+"]";
        }
    };
 
    /**@}*/
 
} // namespace gamp::graph::gl
 
#endif // JAU_GAMP_GRAPH_GL_RENDERSTATE_HPP_