GraphRegion.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_REGION_HPP_
#define JAU_GAMP_GRAPH_GL_REGION_HPP_
 
#include <string>
 
#include <jau/enum_util.hpp>
#include <jau/math/geom/aabbox3f.hpp>
 
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/render/gl/data/GLArrayDataServer.hpp>
#include <gamp/render/gl/glsl/ShaderState.hpp>
 
#include <gamp/graph/OutlineShape.hpp>
#include <gamp/graph/OutlineShape.hpp>
#include <gamp/graph/RenderMode.hpp>
#include <gamp/graph/gl/GraphRenderer.hpp>
 
namespace gamp::graph::gl {
 
    using namespace jau::math;
    using namespace jau::math::geom;
    using namespace jau::enums;
    using jau::math::geom::plane::AffineTransform;
    
    using namespace gamp::render::gl;
    using namespace gamp::render::gl::glsl;
    
    /** \addtogroup Gamp_Graph
     *
     *  @{
     */
 
    class GraphRegion {
      public:
        typedef jau::darray<uint32_t, glmemsize_t> u32buffer_t;
 
        constexpr static int DEFAULT_TWO_PASS_TEXTURE_UNIT = 0;
 
        enum class DirtyBits : uint16_t {
            none = 0,
            shape = 1 << 0,
            state = 1 << 1
        };
        JAU_MAKE_BITFIELD_ENUM_STRING_MEMBER(DirtyBits, shape, state);
        
      private:
        RenderMode m_renderMode;
        GLFloatArrayDataServerRef m_array;
        GLUIntArrayDataServerRef m_indices;
        int m_num_vertices, m_num_indices;
        AABBox3f m_box;
        DirtyBits m_dirty;
    
        constexpr static GLsizei arrayCompsPerElement(RenderMode m) noexcept {
            GLsizei c = 3+3; // vec4 gca_Vertex (skipping 4th comp) + vec3 gca_CurveParam
            if( gamp::graph::hasNormalChannel(m) ) { c+=3; } // vec3 gca_Normal
            if( is_set(m, RenderMode::colorchannel) ) { c+=4; } // vec4 gca_Color
            return c;
        }
    
      public:
        GraphRegion(RenderMode m)
        : m_renderMode(m), m_array(GLFloatArrayDataServer::createGLSLInterleaved(arrayCompsPerElement(m), false, 256, GL_STATIC_DRAW)),
          m_indices(GLUIntArrayDataServer::createData(3, 256, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER)),
          m_num_vertices(0), m_num_indices(0), m_box(), m_dirty(DirtyBits::shape | DirtyBits::state)
        {
            m_array->addGLSLSubArray(RenderNames::gca_Vertex, 3, GL_ARRAY_BUFFER);
            m_array->addGLSLSubArray(RenderNames::gca_CurveParam, 3, GL_ARRAY_BUFFER);
            if( gamp::graph::hasNormalChannel(m) ) {
                m_array->addGLSLSubArray(RenderNames::gca_Normal, 3, GL_ARRAY_BUFFER);
            }
            if( gamp::graph::hasColorChannel(m) ) {
                m_array->addGLSLSubArray(RenderNames::gca_Color, 4, GL_ARRAY_BUFFER);
            }
        }
    
        constexpr RenderMode renderMode() const noexcept { return m_renderMode; }
        constexpr bool hasNormalChannel() const noexcept { return gamp::graph::hasNormalChannel(m_renderMode); }
        constexpr bool hasColorChannel() const noexcept { return gamp::graph::hasColorChannel(m_renderMode); }
        constexpr GLsizei arrayCompsPerElement() const noexcept { return arrayCompsPerElement(m_renderMode); }
        
        GLsizei indexCount() const noexcept { return m_num_indices; }
        GLsizei vertexCount() const noexcept { return m_num_vertices; }
        
        void clear(GL& gl) {
            m_array->clear(gl);
            m_indices->clear(gl);
            m_num_indices = 0;
            m_num_vertices = 0;
        }
        void seal(GL& gl, bool seal_) {
            m_array->seal(gl, seal_);
            m_indices->seal(gl, seal_);
            // m_array->enableBuffer(gl, false);
            // m_indices->enableBuffer(gl, false);
        }
        
      private:    
        void pushVertex(const Vertex& v, const Vec3f& normal) {
            // jau::PLAIN_PRINT(true, "pushVertex.0[%d]: v %s]", m_num_vertices, v.toString().c_str());
            m_array->put3f(v.coord());
            m_array->put3f(v.texCoord());
            if( hasNormalChannel() ) {
                m_array->put3f(normal);
            }
            ++m_num_vertices;
        }
        void pushVertex(const Vertex& v, const Vec3f& normal, const Vec4f& color) {
            // jau::PLAIN_PRINT(true, "pushVertex.0[%d]: v %s]", m_num_vertices, v.toString().c_str());
            m_array->put3f(v.coord());
            m_array->put3f(v.texCoord());
            if( hasNormalChannel() ) {
                m_array->put3f(normal);
            }
            if( hasColorChannel() ) {
                m_array->put4f(color);
            }
            ++m_num_vertices;
        }
        void pushIndices(uint32_t i, uint32_t j, uint32_t k) {
            // jau::PLAIN_PRINT(true, "pushIndices.0[%d]: %u, %u, %u]", m_num_indices, i, j, k);
            m_indices->putN(i, j, k);
            m_num_indices += 3;
        }
        void pushNewVerticesIdx(const Vertex& vertIn1, const Vertex& vertIn2, const Vertex& vertIn3, const Vec3f& normal) {
            pushIndices(m_num_vertices, m_num_vertices+1, m_num_vertices+2);
            pushVertex(vertIn1, normal);
            pushVertex(vertIn2, normal);
            pushVertex(vertIn3, normal);
        }
    
      public:
        void addOutlineShape(GL& gl, OutlineShape& shape) {
            addOutlineShape(shape);
            seal(gl, true);
        }
        
        void addOutlineShape(OutlineShape& shape) {
            if( Graph::DEBUG_MODE ) {
                jau::PLAIN_PRINT(true, "add.0 num[vertices %d, indices %d]", m_num_vertices, m_num_indices);
                jau::PLAIN_PRINT(true, "add.0 array: %s", m_array->toString().c_str());
                jau::PLAIN_PRINT(true, "add.0 indices: %s", m_indices->toString().c_str());
            }
            const TriangleRefList& trisIn = shape.getTriangles();
            const VertexList& vertsIn = shape.getVertices();
            if( Graph::DEBUG_MODE ) {
                jau::PLAIN_PRINT(true, "add.0 triangles %u, vertices %u", trisIn.size(), vertsIn.size());
            }
            {
                glmemsize_t verticeCount = (glmemsize_t)vertsIn.size() + shape.addedVertexCount();
                glmemsize_t indexCount = (glmemsize_t)trisIn.size() * 3;
                m_array->growIfNeeded(verticeCount * m_array->compsPerElem());
                m_indices->growIfNeeded(indexCount); //  * m_indices->compsPerElem());
            }
            uint32_t idxOffset = m_num_vertices;
            if( vertsIn.size() >= 3 ) {
                //
                // Processing Vertices
                //
                for(const Vertex& v : vertsIn) {
                    pushVertex(v, shape.normal());
                }
                constexpr static uint32_t max_index = std::numeric_limits<uint32_t>::max() / sizeof(uint32_t);
                OutlineShape::size_type trisIn_sz = trisIn.size();
                for(OutlineShape::size_type i=0; i < trisIn_sz; ++i) {
                    const TriangleRef& triIn = trisIn[i];
                    // triEx.addVertexIndicesOffset(idxOffset);
                    // triangles.add( triEx );
                    Triangle::trivert_t& triInVertices = triIn->vertices();
                    uint32_t tv0Idx = triInVertices[0].id();
                    if ( max_index - idxOffset > tv0Idx ) {
                        // valid 'known' idx - move by offset
                        pushIndices(tv0Idx+idxOffset,
                                    triInVertices[1].id()+idxOffset,
                                    triInVertices[2].id()+idxOffset);
                    } else {
                        // FIXME: If exceeding max_indices, we would need to generate a new buffer w/ indices
                        pushNewVerticesIdx(triInVertices[0], triInVertices[1], triInVertices[2], shape.normal());
                    }
                }
            }
            markShapeDirty();
            if( Graph::DEBUG_MODE ) {
                jau::PLAIN_PRINT(true, "add.x num[vertices %d, indices %d (%d)]", m_num_vertices, 
                    m_num_indices, m_indices->elemCount() * m_indices->compsPerElem());
                jau::PLAIN_PRINT(true, "add.x array: %s", m_array->toString().c_str());
                jau::PLAIN_PRINT(true, "add.x indices: %s", m_indices->toString().c_str());
            }
            assert(m_num_indices == m_indices->elemCount() * m_indices->compsPerElem());
        }
    
        /**
         * Renders the associated OGL objects specifying
         * current width/hight of window for optional multi pass rendering of the region.
         *
         * User shall consider {@link RegionRenderer#enable(GL2ES2, boolean) enabling}
         * the renderer beforehand and {@link RegionRenderer#enable(GL2ES2, boolean) disabling}
         * it afterwards when used in conjunction with other renderer.
         *
         * Users shall also consider setting the {@link GL#glClearColor(float, float, float, float) clear-color}
         * appropriately:
         * - If {@link GL#GL_BLEND blending} is enabled, <i>RGB</i> shall be set to text color, otherwise
         *   blending will reduce the alpha seam's contrast and the font will appear thinner.
         * - If {@link GL#GL_BLEND blending} is disabled, <i>RGB</i> shall be set to the actual desired background.
         * The <i>alpha</i> component shall be set to zero.
         * Note: If {@link GL#GL_BLEND blending} is enabled, the
         * {@link RegionRenderer} might need to be
         * {@link RegionRenderer#create(Vertex.Factory<? extends Vertex>, RenderState, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback) created}
         * with the appropriate {@link RegionRenderer.GLCallback callbacks}.
         * @param gl current {@link GL2ES2}.
         * @param renderer the GraphRenderer to be used
         * @see RegionRenderer#enable(GL2ES2, boolean)
         * @see RegionRenderer#setAAQuality(int)
         * @see RegionRenderer#setSampleCount(int)
         * @see RegionRenderer#setClipBBox(com.jogamp.math.geom.AABBox)
         */
        void draw(GL &gl, GraphRenderer& renderer) {
            const RenderState& rs = renderer.renderState(); 
            int pass2Quality = rs.aaQuality();
            int pass2SampleCount = rs.sampleCount();
            RenderMode curRenderMode = RenderMode::none;
            if( 0 == pass2SampleCount ) {
                // no sampling, reduce to pass1
                curRenderMode = renderMode() & ~( RenderMode::vbaa | RenderMode::msaa );
            } else {
                // normal 2-pass sampling
                curRenderMode = renderMode();
            }
            // System.err.println("XXX.0 "+Region.getRenderModeString(getRenderModes(), sampleCount[0], 0)+": "+
            //        Region.getRenderModeString(lastRenderModes, sampleCount[0], 0)+" -> "+Region.getRenderModeString(curRenderModes, sampleCount[0], 0));
    
            if( m_lastRenderMode != curRenderMode ) {
                markShapeDirty();
                markStateDirty();
            } else if( Region.isGraphAA(curRenderModes) &&
                       ( lastPass2Quality != pass2Quality || lastPass2SampleCount != pass2SampleCount ) ) {
                markStateDirty();
            }
            if( isShapeDirty() ) {
                updateImpl(gl, renderer, curRenderModes);
            }
            drawImpl(gl, renderer, curRenderModes);
            clearDirtyBits(DIRTY_SHAPE|DIRTY_STATE);
            lastRenderModes = curRenderModes;
            lastPass2Quality = pass2Quality;
            lastPass2SampleCount = pass2SampleCount;
            
            renderer.useProgram(gl, true);
    
            m_array->enableBuffer(gl, true);
            m_indices->bindBuffer(gl, true); // keeps VBO binding
    
            ::glEnable(GL_BLEND);
            ::glBlendEquation(GL_FUNC_ADD); // default
            ::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
            ::glDrawElements(GL_TRIANGLES, m_indices->elemCount() * m_indices->compsPerElem(), GL_UNSIGNED_INT, nullptr);
    
    
            m_indices->bindBuffer(gl, false);
            m_array->enableBuffer(gl, false);
            // renderer.useProgram(gl, false);
        }
        
      private:
        RenderMode m_lastRenderMode = RenderMode::none;
        int m_lastPass2Quality = -1;
        int m_lastPass2SampleCount = -1;
        
      public:         
        /** @return the AxisAligned bounding box of current region */
        constexpr const AABBox3f& bounds() const noexcept { return m_box; }
    
        /**
         * Mark this region's shape dirty,
         * i.e. its vertices, triangles, lines and/or color-texture coordinates changed.
         * <p>
         * The data will be re-uploaded to the GPU at next {@link GLRegion#draw(com.jogamp.opengl.GL2ES2, com.jogamp.graph.curve.opengl.RegionRenderer) draw(..)}.
         * </p>
         * <p>
         * In 2-pass mode, this implies updating the FBO itself as well.
         * </p>
         */
        void markShapeDirty() noexcept { m_dirty |= DirtyBits::shape; }
        
        /** Returns true if this region's shape are dirty, see {@link #markShapeDirty()}. */
        constexpr bool isShapeDirty() const noexcept { return is_set(m_dirty, DirtyBits::shape); }
        
        /**
         * Mark this region's render-state dirty, i.e. re-selecting a shader program regarding color-texture and -channel,
         * and rendering the region into the FBO in 2-pass mode.
         * <p>
         * In 1-pass mode, re-selection of the shader-program is based on color-texture and -channel only.
         * </p>
         */
        void markStateDirty() noexcept { m_dirty |= DirtyBits::state; }
        
        /** Returns true if this region's state is dirty, see {@link #markStateDirty()}. */
        constexpr bool isStateDirty() const noexcept { return is_set(m_dirty, DirtyBits::state); }
    
        constexpr DirtyBits dirtyBits() const noexcept { return m_dirty; }
        
      private:
        /**
         * See {@link #markShapeDirty()} and {@link #markStateDirty()}.
         */
        void clearDirtyBits(DirtyBits v) { m_dirty &= ~v; }
    
      public:
        std::string toString() noexcept {
            std::string r("Region[");
            r.append(jau::to_string(this)).append(", ").append(to_string(m_renderMode))
             .append(", dirty "+to_string(m_dirty)).append(", vertices ").append(std::to_string(m_num_vertices))
             .append(", indices ").append(std::to_string(m_num_indices))
             .append(", box ").append(m_box.toString()).append("]");
            return r;
        }
    };
 
    /**@}*/
 
} // namespace gamp::graph::gl
 
#endif // JAU_GAMP_GRAPH_GL_REGION_HPP_