layer_triangles.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2015-2016 Mario Luzeiro <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef TRIANGLE_DISPLAY_LIST_H
#define TRIANGLE_DISPLAY_LIST_H
 
#include <kicad_gl/kiglad.h> // Must be included first
 
#include <plugins/3dapi/xv3d_types.h>
#include <geometry/shape_line_chain.h>
#include <geometry/shape_poly_set.h>
#include <raytracing/accelerators/container_2d.h>
#include <vector>
#include <mutex>
 
 

class TRIANGLE_LIST
{
public:

    TRIANGLE_LIST( unsigned int aNrReservedTriangles, bool aReserveNormals );

    void Reserve_More( unsigned int aNrReservedTriangles, bool aReserveNormals );
 
    void AddTriangle( const SFVEC3F& aV1, const SFVEC3F& aV2, const SFVEC3F& aV3 );
 
    void AddQuad( const SFVEC3F& aV1, const SFVEC3F& aV2, const SFVEC3F& aV3, const SFVEC3F& aV4 );
 
    void AddNormal( const SFVEC3F& aN1, const SFVEC3F& aN2, const SFVEC3F& aN3 );
 
    void AddNormal( const SFVEC3F& aN1, const SFVEC3F& aN2, const SFVEC3F& aN3,
                    const SFVEC3F& aN4 );

    const float* GetVertexPointer() const { return (const float *)&m_vertexs[0].x; }

    const float* GetNormalsPointer() const { return (const float*) &m_normals[0].x; }
 
    unsigned int GetVertexSize() const { return (unsigned int) m_vertexs.size(); }
 
    unsigned int GetNormalsSize() const { return (unsigned int) m_normals.size(); }
 
private:
    std::vector<SFVEC3F> m_vertexs;  
    std::vector<SFVEC3F> m_normals;  
};
 

class TRIANGLE_DISPLAY_LIST
{
public:
    explicit TRIANGLE_DISPLAY_LIST( unsigned int aNrReservedTriangles );
 
    ~TRIANGLE_DISPLAY_LIST();

    bool IsLayersSizeValid();
 
 
    void AddToMiddleContours( const SHAPE_LINE_CHAIN& outlinePath, float zBot, float zTop,
                              double aBiuTo3Du, bool aInvertFaceDirection,
                              const BVH_CONTAINER_2D* aThroughHoles = nullptr );
 
    void AddToMiddleContours( const SHAPE_POLY_SET& aPolySet, float zBot, float zTop,
                              double aBiuTo3Du, bool aInvertFaceDirection,
                              const BVH_CONTAINER_2D* aThroughHoles = nullptr );
 
    void AddToMiddleContours( const std::vector< SFVEC2F >& aContourPoints, float zBot,
                              float zTop, bool aInvertFaceDirection,
                              const BVH_CONTAINER_2D* aThroughHoles = nullptr );
 
    std::mutex m_middle_layer_lock;
 
    TRIANGLE_LIST* m_layer_top_segment_ends;
    TRIANGLE_LIST* m_layer_top_triangles;
    TRIANGLE_LIST* m_layer_middle_contours_quads;
    TRIANGLE_LIST* m_layer_bot_triangles;
    TRIANGLE_LIST* m_layer_bot_segment_ends;
};
 

class OPENGL_RENDER_LIST
{
public:
    OPENGL_RENDER_LIST( const TRIANGLE_DISPLAY_LIST& aLayerTriangles,
                        GLuint aTextureIndexForSegEnds, float aZBot, float aZTop );

    ~OPENGL_RENDER_LIST();

    void DrawTopAndMiddle() const;

    void DrawBotAndMiddle() const;

    void DrawTop() const;

    void DrawBot() const;

    void DrawMiddle() const;

    void DrawAll( bool aDrawMiddle = true ) const;

    void DrawCulled( bool aDrawMiddle, const std::shared_ptr<OPENGL_RENDER_LIST> aSubtractList = nullptr,
                     const std::shared_ptr<OPENGL_RENDER_LIST> bSubtractList = nullptr,
                     const std::shared_ptr<OPENGL_RENDER_LIST> cSubtractList = nullptr,
                     const std::shared_ptr<OPENGL_RENDER_LIST> dSubtractList = nullptr ) const;
 
    void ApplyScalePosition( float aZposition, float aZscale );
    void ApplyScalePosition( std::shared_ptr<OPENGL_RENDER_LIST> aOtherList );
 
    void ClearScalePosition() { m_haveTransformation = false; }
 
    void SetItIsTransparent( bool aSetTransparent );
 
    float GetZBot() const { return m_zBot; }
    float GetZTop() const { return m_zTop; }
 
private:
    GLuint generate_top_or_bot_seg_ends( const TRIANGLE_LIST* aTriangleContainer,
                                         bool aIsNormalUp, GLuint aTextureId ) const;
 
    GLuint generate_top_or_bot_triangles( const TRIANGLE_LIST* aTriangleContainer,
                                          bool aIsNormalUp ) const;
 
    GLuint generate_middle_triangles( const TRIANGLE_LIST* aTriangleContainer ) const;
 
    void beginTransformation() const;
    void endTransformation() const;
 
    void setBlendfunction() const;
 
private:
    float   m_zBot;
    float   m_zTop;
    GLuint  m_layer_top_segment_ends;
    GLuint  m_layer_top_triangles;
    GLuint  m_layer_middle_contours_quads;
    GLuint  m_layer_bot_triangles;
    GLuint  m_layer_bot_segment_ends;
 
    bool    m_haveTransformation;
    float   m_zPositionTransformation;
    float   m_zScaleTransformation;
 
    bool    m_draw_it_transparent;
};
 

class OPENGL_RENDER_LIST_DEFERRED
{
public:
    OPENGL_RENDER_LIST_DEFERRED( std::shared_ptr<TRIANGLE_DISPLAY_LIST> aLayerTriangles, GLuint aTextureIndexForSegEnds,
                                 float aZBot, float aZTop, bool aTransparent = false ) :
            m_layerTriangles( std::move( aLayerTriangles ) ),
            m_textureIndexForSegEnds( aTextureIndexForSegEnds ),
            m_zBot( aZBot ),
            m_zTop( aZTop ),
            m_defaultTransparent( aTransparent )
    {
    }
 
    ~OPENGL_RENDER_LIST_DEFERRED() {}
 
    void MakeShared()
    {
        std::lock_guard<std::recursive_mutex> lock( m_mutex );
 
        if( !m_openglRenderList && !m_layerTriangles )
        {
            throw std::runtime_error( "Both OpenGL render list and layer triangles are null" );
        }
 
        if( !m_openglRenderList )
        {
            m_openglRenderList =
                    std::make_shared<OPENGL_RENDER_LIST>( *m_layerTriangles, m_textureIndexForSegEnds, m_zBot, m_zTop );
 
            m_openglRenderList->SetItIsTransparent( m_defaultTransparent );
        }
    }
 
    void Reset()
    {
        std::lock_guard<std::recursive_mutex> lock( m_mutex );
 
        m_openglRenderList.reset();
        m_layerTriangles.reset();
    }
 
    std::shared_ptr<OPENGL_RENDER_LIST> MakeOrGet()
    {
        std::lock_guard<std::recursive_mutex> lock( m_mutex );
 
        MakeShared();
        m_layerTriangles.reset();
 
        return m_openglRenderList;
    }
 
private:
    std::shared_ptr<OPENGL_RENDER_LIST> m_openglRenderList;
    std::recursive_mutex                m_mutex;
 
    std::shared_ptr<TRIANGLE_DISPLAY_LIST> m_layerTriangles;
    GLuint                                 m_textureIndexForSegEnds{ 0 };
    float                                  m_zBot{ 0 };
    float                                  m_zTop{ 0 };
    bool                                   m_defaultTransparent{ false };
};
 
 
#endif // TRIANGLE_DISPLAY_LIST_H