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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef TRIANGLE_DISPLAY_LIST_H
#define TRIANGLE_DISPLAY_LIST_H
 
#include "../../common_ogl/openGL_includes.h"
#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>
 
 
typedef std::vector< SFVEC3F > SFVEC3F_VECTOR;
 

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:
    SFVEC3F_VECTOR m_vertexs;  
    SFVEC3F_VECTOR 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 OPENGL_RENDER_LIST* aSubtractList = nullptr,
                        const OPENGL_RENDER_LIST* bSubtractList = nullptr,
                        const OPENGL_RENDER_LIST* cSubtractList = nullptr,
                        const OPENGL_RENDER_LIST* dSubtractList = nullptr ) const;
 
    void ApplyScalePosition( float aZposition, float aZscale );
    void ApplyScalePosition( 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;
};
 
#endif // TRIANGLE_DISPLAY_LIST_H