GraphRenderer.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_RENDERER_HPP_
#define JAU_GAMP_GRAPH_GL_RENDERER_HPP_
 
#include <string_view>
#include <jau/basic_types.hpp>
#include <jau/math/recti.hpp>
 
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/render/gl/data/GLArrayDataServer.hpp>
#include <gamp/render/gl/texture/TextureSequence.hpp>
 
#include <gamp/graph/RenderMode.hpp>
#include <gamp/graph/gl/RenderNames.hpp>
#include <gamp/graph/gl/RenderState.hpp>
 
namespace gamp::graph::gl {
 
    using namespace jau::math;
    using namespace jau::math::geom;
    using namespace jau::enums;
    
    using namespace gamp::render::gl;
    using namespace gamp::render::gl::glsl;
 
    /** \addtogroup Gamp_Graph
     *
     *  @{
     */
 
    /**
     * OpenGL GraphRenderer
     *
     * All GraphRegion rendering operations utilize a GraphRenderer.
     *
     * The GraphRenderer owns its {@link RenderState}, a composition.
     *
     * The GraphRenderer manages and owns all used ShaderProgram instances, a composition.
     *
     * At its {@link #destroy(GL2ES2) destruction}, all {@link ShaderProgram}s and its {@link RenderState}
     * will be destroyed and released.
     */
    class GraphRenderer {
      public:
        /**
         * May be passed to
         * {@link RegionRenderer#create(Vertex.Factory<? extends Vertex>, RenderState, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback) RegionRenderer ctor},
         * e.g.
         * <ul>
         *   <li>{@link RegionRenderer#defaultBlendEnable}</li>
         *   <li>{@link RegionRenderer#defaultBlendDisable}</li>
         * </ul>
         *
         * @param gl a current GL context
         * @param renderer GraphRenderer calling this method.
         */
        typedef jau::function<bool(GL& gl, GraphRenderer& renderer)> GLCallback;
 
        /**
         * Default {@link GL#GL_BLEND} <i>enable</i> {@link GLCallback},
         * turning-off depth writing via {@link GL#glDepthMask(bool)} if {@link RenderState#BITHINT_GLOBAL_DEPTH_TEST_ENABLED} is set
         * and turning-on the {@link GL#GL_BLEND} state.
         * <p>
         * Implementation also sets {@link RegionRenderer#getRenderState() RenderState}'s {@link RenderState#BITHINT_BLENDING_ENABLED blending bit-hint},
         * which will cause {@link GLRegion#draw(GL2ES2, RegionRenderer) GLRegion's draw-method}
         * to 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>
         * @see #create(GLCallback, GLCallback)
         * @see #enable(GL2ES2, bool)
         */
        static GLCallback defaultBlendEnable;
    
        /**
         * Default {@link GL#GL_BLEND} <i>disable</i> {@link GLCallback},
         * simply turning-off the {@link GL#GL_BLEND} state
         * and turning-on depth writing via {@link GL#glDepthMask(bool)} if {@link RenderState#BITHINT_GLOBAL_DEPTH_TEST_ENABLED} is set.
         * <p>
         * Implementation also clears {@link RegionRenderer#getRenderState() RenderState}'s {@link RenderState#BITHINT_BLENDING_ENABLED blending bit-hint}.
         * </p>
         * @see #create(GLCallback, GLCallback)
         * @see #enable(GL2ES2, bool)
         */
        static GLCallback defaultBlendDisable;
        
        static constexpr bool DEBUG_MODE = true;
        static constexpr std::string_view GLSL_PARAM_COMMENT_START = "\n// Gamp Graph Parameter Start\n";
        static constexpr std::string_view GLSL_PARAM_COMMENT_END = "// Gamp Graph Parameter End\n\n";
        static constexpr std::string_view GLSL_USE_COLOR_CHANNEL = "#define USE_COLOR_CHANNEL 1\n";
        static constexpr std::string_view GLSL_USE_NORMAL_CHANNEL = "#define USE_NORMAL_CHANNEL 1\n";
        static constexpr std::string_view GLSL_USE_LIGHT0 = "#define USE_LIGHT0 1\n";
        static constexpr std::string_view GLSL_USE_COLOR_TEXTURE = "#define USE_COLOR_TEXTURE 1\n";
        static constexpr std::string_view GLSL_USE_FRUSTUM_CLIPPING = "#define USE_FRUSTUM_CLIPPING 1\n";
        static constexpr std::string_view GLSL_DEF_SAMPLE_COUNT = "#define SAMPLE_COUNT ";
        static constexpr std::string_view GLSL_CONST_SAMPLE_COUNT = "const float sample_count = ";
        static constexpr std::string_view GLSL_MAIN_BEGIN = "void main (void)\n{\n";
        static constexpr std::string_view gcuTexture2D = "gcuTexture2D";
        static constexpr std::string_view colTexLookupFuncName = "texture2D";
        static constexpr std::string_view GLSL_USE_DISCARD = "#define USE_DISCARD 1\n";
        static constexpr std::string_view shader_basename = "curverenderer01";
        static constexpr std::string_view source_dir = "impl/graph/glsl";
        static constexpr std::string_view bin_dir = "impl/graph/glsl/bin";
    
        GraphRenderer(jau::math::util::PMVMat4f& pmvMat)
        : m_rs(pmvMat), m_viewport(),
          m_initialized(false)
        {}
 
        const RenderState& renderState() const noexcept { return m_rs; }
        RenderState& renderState() noexcept { return m_rs; }
        const Recti& viewport() const noexcept { return m_viewport; } 
        constexpr bool initialized() const noexcept { return m_initialized; }
    
      private:
        //
        //
        //
 
        // FIXME: Really required to have sampler2D def. precision ? If not, we can drop getFragmentShaderPrecision(..) and use default ShaderCode ..
        static constexpr std::string_view es2_precision_fp = "\nprecision mediump float;\nprecision mediump int;\nprecision mediump sampler2D;\n";
    
        std::string_view getFragmentShaderPrecision(GL& gl) const noexcept {
            if( gl.glProfile().isGLES() ) {
                return es2_precision_fp;
            }
            if( ShaderCode::requiresGL3DefaultPrecision(gl) ) {
                return ShaderCode::gl3_default_precision_fp;
            }
            return "";
        }
 
        
        class ShaderModeSelector1 {
          public:
            std::string_view tech;
            std::string_view sub;
            int sampleCount;
                        
            static ShaderModeSelector1 selectPass1(RenderMode renderMode) {
                return hasVariableWeight(renderMode) ? PASS1_WEIGHT : PASS1_SIMPLE;
            }
    
            static ShaderModeSelector1 selectPass2(RenderMode renderMode, int quality, int sampleCount) {
                if( isVBAA(renderMode) ) {
                    if( 0 == quality ) {
                        if( sampleCount < 2 ) {
                            return PASS2_VBAA_QUAL0_SAMPLES1;
                        } else if( sampleCount < 4 ) {
                            return PASS2_VBAA_QUAL0_SAMPLES2;
                        } else if( sampleCount < 8 ) {
                            return PASS2_VBAA_QUAL0_SAMPLES4;
                        } else {
                            return PASS2_VBAA_QUAL0_SAMPLES8;
                        }
                    } else {
                        switch( sampleCount ) {
                            case 0: // Fall through intended
                            case 1:  return PASS2_VBAA_QUAL1_SAMPLES1;
                            case 2:  return PASS2_VBAA_QUAL1_SAMPLES2;
                            case 3:  return PASS2_VBAA_QUAL1_SAMPLES3;
                            case 4:  return PASS2_VBAA_QUAL1_SAMPLES4;
                            case 5:  return PASS2_VBAA_QUAL1_SAMPLES5;
                            case 6:  return PASS2_VBAA_QUAL1_SAMPLES6;
                            case 7:  return PASS2_VBAA_QUAL1_SAMPLES7;
                            default: return PASS2_VBAA_QUAL1_SAMPLES8;
                        }
                    }
                } else {
                    return PASS2_MSAA; // Region.isMSAA(renderModes) and default
                }
            }            
        };
        /** Pass-1: Curve Simple */
        constexpr static ShaderModeSelector1 PASS1_SIMPLE { "curve", "_simple", 0 };
        
        /** Pass-1: Curve Varying Weight */
        constexpr static ShaderModeSelector1 PASS1_WEIGHT { "curve", "_weight", 0 };
        /** Pass-2: MSAA */
        constexpr static ShaderModeSelector1 PASS2_MSAA { "msaa", "", 0 };
        /** Pass-2: VBAA Flipquad3, 1 sample */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL0_SAMPLES1 { "vbaa", "_flipquad3", 1 };
        /** Pass-2: VBAA Flipquad3, 2 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL0_SAMPLES2 { "vbaa", "_flipquad3", 2 };
        /** Pass-2: VBAA Flipquad3, 4 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL0_SAMPLES4 { "vbaa", "_flipquad3", 4 };
        /** Pass-2: VBAA Flipquad3, 8 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL0_SAMPLES8 { "vbaa", "_flipquad3", 8 };
 
        /** Pass-2: VBAA Brute-Force, Odd, 1 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES1 { "vbaa", "_bforce_odd",  1 };
        /** Pass-2: VBAA Brute-Force, Even, 2 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES2 { "vbaa", "_bforce_even", 2 };
        /** Pass-2: VBAA Brute-Force, Odd, 3 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES3 { "vbaa", "_bforce_odd",  3 };
        /** Pass-2: VBAA Brute-Force, Even, 4 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES4 { "vbaa", "_bforce_even", 4 };
        /** Pass-2: VBAA Brute-Force, Odd, 5 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES5 { "vbaa", "_bforce_odd",  5 };
        /** Pass-2: VBAA Brute-Force, Even, 6 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES6 { "vbaa", "_bforce_even", 6 };
        /** Pass-2: VBAA Brute-Force, Odd, 7 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES7 { "vbaa", "_bforce_odd",  7 };
        /** Pass-2: VBAA Brute-Force, Even, 8 samples */
        constexpr static ShaderModeSelector1 PASS2_VBAA_QUAL1_SAMPLES8 { "vbaa", "_bforce_even", 8 };    
 
        class ShaderKey {
            bool isTwoPass;
            bool pass1;
            ShaderModeSelector1 sms;
            bool hasFrustumClipping; // pass1 or pass2
            bool hasColorChannel; // pass1 only
            bool hasColorTexture; // pass1 only
            std::string_view colorTexSeqID;
    
            size_t hashValue;
    
            ShaderKey(bool isTwoPass, bool pass1, ShaderModeSelector1 sms,
                      bool hasFrustumClipping, bool hasColorChannel,
                      bool hasColorTexture, TextureSequence colorTexSeq, int colorTexSeqHash)
            {
                this.isTwoPass = isTwoPass;
                this.pass1 = pass1;
                this.sms = sms;
                this.hasFrustumClipping = hasFrustumClipping;
                this.hasColorChannel = hasColorChannel;
                this.hasColorTexture = hasColorTexture;
                if( hasColorTexture ) {
                    this.colorTexSeqID = colorTexSeq.getTextureFragmentShaderHashID();
                } else {
                    this.colorTexSeqID = "";
                }
                hashValue = getShaderKey1(isTwoPass, pass1, hasFrustumClipping, hasColorChannel, hasColorTexture, sms, colorTexSeqHash);
            }
            @Override
            public final int hashCode() { return hashValue; }
            @Override
            public bool equals(final Object other) {
                if( this == other ) { return true; }
                if( !(other instanceof ShaderKey) ) {
                    return false;
                }
                final ShaderKey o = (ShaderKey)other;
                return isTwoPass == o.isTwoPass &&
                       pass1 == o.pass1 &&
                       // pass2Quality == o.pass2Quality && // included in sms
                       // sampleCount == o.sampleCount && // included in sms
                       sms.ordinal() == o.sms.ordinal() &&
                       hasFrustumClipping == o.hasFrustumClipping &&
                       hasColorChannel == o.hasColorChannel &&
                       hasColorTexture == o.hasColorTexture &&
                       colorTexSeqID.equals(o.colorTexSeqID);
            }
            @Override
            public String toString() {
                return shaderHashToString(hashValue, isTwoPass, pass1, hasFrustumClipping, hasColorChannel, hasColorTexture, sms);
            }
        }
        private static final boolean UseShaderPrograms0 = true;
        private final LongObjectHashMap shaderPrograms0;
        private final HashMap<ShaderKey, ShaderProgram> shaderPrograms1;
    
        private static String shaderHashToString(final int hashCode, final boolean isTwoPass, final boolean pass1,
                                       final boolean hasFrustumClipping, final boolean hasColorChannel, final boolean hasColorTexture,
                                       final ShaderModeSelector1 sms) {
                return "ShaderHash[hash 0x"+Integer.toHexString(hashCode)+", is2Pass "+isTwoPass+", pass1 "+pass1+
                       ", has[clip "+hasFrustumClipping+", colChan "+hasColorChannel+", colTex "+hasColorTexture+"], "+sms+"]";
        }
        private static String shaderKeyToString(final long key, final boolean isTwoPass, final boolean pass1,
                                       final boolean hasFrustumClipping, final boolean hasColorChannel, final boolean hasColorTexture,
                                       final ShaderModeSelector1 sms) {
                return "ShaderKey[key 0x"+Long.toHexString(key)+", is2Pass "+isTwoPass+", pass1 "+pass1+
                       ", has[clip "+hasFrustumClipping+", colChan "+hasColorChannel+", colTex "+hasColorTexture+"], "+sms+"]";
        }
    
        private static long getShaderKey0(final boolean isTwoPass, final boolean pass1,
                                          final boolean hasFrustumClipping, final boolean hasColorChannel, final boolean hasColorTexture,
                                          final ShaderModeSelector1 sms, final long colorTexSeqHash) {
            //  # |  s |
            //  0 |  1 | isTwoPass
            //  1 |  1 | pass1
            //  2 |  5 | ShaderModeSelector1
            //  7 |  1 | hasFrustumClipping
            //  8 |  1 | hasColorChannel
            //  9 |  1 | hasColorTexture
            // 32 | 32 | colorTexSeqHash
            long hash =  isTwoPass ? 1L : 0L;
            hash |= ( pass1 ? 1L : 0L )               << 1;
            hash |= (long)( sms.ordinal() & 0b11111 ) << 2; // incl. pass2Quality + sampleCount
            hash |= ( hasFrustumClipping ? 1L : 0L )  << 7;
            hash |= ( hasColorChannel ? 1L : 0L )     << 8;
            hash |= ( hasColorTexture ? 1L : 0L )     << 9;
            hash |= ( colorTexSeqHash & 0xFFFFFFL )   << 32;
            return hash;
        }
        private static int getShaderKey1(final boolean isTwoPass, final boolean pass1,
                                         final boolean hasFrustumClipping, final boolean hasColorChannel, final boolean hasColorTexture,
                                         final ShaderModeSelector1 sms, final int colorTexSeqHash) {
            // 31 * x == (x << 5) - x
            int hash = 31 * ( isTwoPass ? 1 : 0 );
            hash = ((hash << 5) - hash) + ( pass1 ? 1 : 0 ) ;
            // hash = ((hash << 5) - hash) + pass2Quality; // included in sms
            // hash = ((hash << 5) - hash) + sampleCount; // included in sms
            hash = ((hash << 5) - hash) + sms.ordinal();
            hash = ((hash << 5) - hash) + ( hasFrustumClipping ? 1 : 0 );
            hash = ((hash << 5) - hash) + ( hasColorChannel ? 1 : 0 );
            hash = ((hash << 5) - hash) + ( hasColorTexture ? 1 : 0 );
            hash = ((hash << 5) - hash) + colorTexSeqHash;
            return hash;
        }
 
        static ShaderProgramRef createShaderProgram(GL& gl, const RenderState& rs, RenderMode renderMode, bool pass1, const jau::fraction_timespec& when) {
            // jau::fraction_timespec when = jau::getMonotonicTime();
            
            std::string vertexShaderName, fragmentShaderName;
            vertexShaderName.append(shader_basename);
            if( isTwoPass(renderMode) ) {
                vertexShaderName.append("-pass").append(pass1 ? "1":"2");
            } else {
                vertexShaderName.append("-single");
            }
            fragmentShaderName.append(shader_basename).append("-segment-head");
    
            ShaderCodeRef rsVp = ShaderCode::create(gl, GL_VERTEX_SHADER, source_dir, bin_dir, vertexShaderName);
            ShaderCodeRef rsFp = ShaderCode::create(gl, GL_FRAGMENT_SHADER, source_dir, bin_dir, fragmentShaderName);
            if( !rsVp || !rsFp ) {
                jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                return nullptr;
            }
            {
                size_t posVp = rsVp->defaultShaderCustomization(gl, true, true);
                size_t posFp = rsFp->defaultShaderCustomization(gl, true, true);
                if( posVp == std::string::npos || posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
    
                // GLSL append from here on
                posFp = -1;
    
                posVp = rsVp->insertShaderSource(0, posVp, GLSL_PARAM_COMMENT_START);
                posFp = rsFp->insertShaderSource(0, posFp, GLSL_PARAM_COMMENT_START);
    
                // if( !gl.getContext().hasRendererQuirk(GLRendererQuirks.GLSLBuggyDiscard) ) {
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_DISCARD);
                // }
    
                if( rs.usesFrustumClipping() ) {
                    posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_FRUSTUM_CLIPPING);
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_FRUSTUM_CLIPPING);
                }
    
                if( hasNormalChannel(renderMode) ) {
                    posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_NORMAL_CHANNEL);
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_NORMAL_CHANNEL);
                }
                if( hasLight0(renderMode) ) {
                    posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_LIGHT0);
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_LIGHT0);
                }
                if( hasColorChannel(renderMode) ) {
                    posVp = rsVp->insertShaderSource(0, posVp, GLSL_USE_COLOR_CHANNEL);
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_COLOR_CHANNEL);
                }
                if( hasColorTexture(renderMode) ) {
                            rsVp->insertShaderSource(0, posVp, GLSL_USE_COLOR_TEXTURE);
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_USE_COLOR_TEXTURE);
                }
                /*if( !pass1 ) {
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_DEF_SAMPLE_COUNT+sms.sampleCount+"\n");
                    posFp = rsFp->insertShaderSource(0, posFp, GLSL_CONST_SAMPLE_COUNT+sms.sampleCount+".0;\n");
                } */
    
                posVp = rsVp->insertShaderSource(0, posVp, GLSL_PARAM_COMMENT_END);
                if( posVp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
    
                posFp = rsFp->insertShaderSource(0, posFp, GLSL_PARAM_COMMENT_END);
    
                posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/constants.glsl"));
                if( posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
                posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/uniforms.glsl"));
                if( posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
                posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/varyings.glsl"));
                if( posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
                if( hasColorTexture(renderMode) || rs.usesFrustumClipping() ) {
                    posFp = rsFp->insertShaderSourceFile(0, posFp, string_t(source_dir).append("/functions.glsl"));
                    if( posFp == std::string::npos ) {
                        jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                        return nullptr;
                    }
                }
                /*if( hasColorTexture ) {
                    posFp = rsFp->insertShaderSource(0, posFp, "uniform "+colorTexSeq.getTextureSampler2DType()+" "+UniformNames.gcu_ColorTexUnit+";\n");
                    posFp = rsFp->insertShaderSource(0, posFp, colorTexSeq.getTextureLookupFragmentShaderImpl());
                }*/
    
                posFp = rsFp->insertShaderSource(0, posFp, GLSL_MAIN_BEGIN);
    
                std::string passS = pass1 ? "-pass1-" : "-pass2-";
                std::string shaderSegment = string_t(source_dir).append("/").append(shader_basename).append(passS).append("curve_simple").append(".glsl"); // sms.tech+sms.sub+".glsl";
                if(DEBUG_MODE) {
                    jau::PLAIN_PRINT(true, "RegionRenderer.createShaderProgram.1: segment %s", shaderSegment.c_str());
                }
                posFp = rsFp->insertShaderSourceFile(0, posFp, shaderSegment);
                if( posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }
                posFp = rsFp->insertShaderSource(0, posFp, "}\n");
                if( posFp == std::string::npos ) {
                    jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                    return nullptr;
                }   
                if( hasColorTexture(renderMode) ) {
                    rsFp->replaceInShaderSource(std::string(gcuTexture2D), std::string(colTexLookupFuncName));
                }    
            }
            ShaderProgramRef sp0 = ShaderProgram::create();
            if( !sp0->add(gl, rsVp, true) || !sp0->add(gl, rsFp, true) ) {
                jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
                sp0->destroy(gl);
                return nullptr;
            }
            sp0->useProgram(gl, true);
    
            m_initialized = sp0->inUse();
            if( !m_initialized ) {
                jau::fprintf_td(when.to_ms(), stdout, "ERROR %s:%d\n", E_FILE_LINE);
            }
            return sp0;
        }
    
      private:
        RenderState m_rs;
        jau::math::Recti m_viewport;
        bool m_initialized;
    };
 
    /**@}*/
 
} // namespace gamp::graph::gl
 
#endif // JAU_GAMP_GRAPH_GL_RENDERER_HPP_