vertex_manager.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2016 CERN
 * Copyright (C) 2020 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Maciej Suminski <[email protected]>
 *
 * 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 VERTEX_MANAGER_H_
#define VERTEX_MANAGER_H_
 
#define GLM_FORCE_RADIANS
#include <glm/gtc/matrix_transform.hpp>
#include <glm/glm.hpp>
#include <gal/opengl/vertex_common.h>
#include <gal/color4d.h>
#include <stack>
#include <memory>
 
namespace KIGFX
{
class SHADER;
class VERTEX_ITEM;
class VERTEX_CONTAINER;
class GPU_MANAGER;
 
class VERTEX_MANAGER
{
public:
    VERTEX_MANAGER( bool aCached );
 
    void Map();
 
    void Unmap();
 
    bool Reserve( unsigned int aSize );
 
    inline bool Vertex( const VERTEX& aVertex )
    {
        return Vertex( aVertex.x, aVertex.y, aVertex.z );
    }
 
    bool Vertex( GLfloat aX, GLfloat aY, GLfloat aZ );
 
    bool Vertex( const VECTOR2D& aXY, GLfloat aZ )
    {
        return Vertex( aXY.x, aXY.y, aZ );
    }
 
    bool Vertices( const VERTEX aVertices[], unsigned int aSize );
 
    inline void Color( const COLOR4D& aColor )
    {
        m_color[0] = aColor.r * 255.0;
        m_color[1] = aColor.g * 255.0;
        m_color[2] = aColor.b * 255.0;
        m_color[3] = aColor.a * 255.0;
    }
 
    inline void Color( GLfloat aRed, GLfloat aGreen, GLfloat aBlue, GLfloat aAlpha )
    {
        m_color[0] = aRed   * 255.0;
        m_color[1] = aGreen * 255.0;
        m_color[2] = aBlue  * 255.0;
        m_color[3] = aAlpha * 255.0;
    }
 
    inline void Shader( GLfloat aShaderType, GLfloat aParam1 = 0.0f, GLfloat aParam2 = 0.0f,
                        GLfloat aParam3 = 0.0f )
    {
        m_shader[0] = aShaderType;
        m_shader[1] = aParam1;
        m_shader[2] = aParam2;
        m_shader[3] = aParam3;
    }
 
    inline void Translate( GLfloat aX, GLfloat aY, GLfloat aZ )
    {
        m_transform = glm::translate( m_transform, glm::vec3( aX, aY, aZ ) );
    }
 
    inline void Rotate( GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ )
    {
        m_transform = glm::rotate( m_transform, aAngle, glm::vec3( aX, aY, aZ ) );
    }
 
    inline void Scale( GLfloat aX, GLfloat aY, GLfloat aZ )
    {
        m_transform = glm::scale( m_transform, glm::vec3( aX, aY, aZ ) );
    }
 
    inline void PushMatrix()
    {
        m_transformStack.push( m_transform );
 
        // Every transformation starts with PushMatrix
        m_noTransform = false;
    }
 
    void PopMatrix()
    {
        wxASSERT( !m_transformStack.empty() );
 
        m_transform = m_transformStack.top();
        m_transformStack.pop();
 
        if( m_transformStack.empty() )
        {
            // We return back to the identity matrix, thus no vertex transformation is needed
            m_noTransform = true;
        }
    }
 
    void SetItem( VERTEX_ITEM& aItem ) const;
 
    void FinishItem() const;
 
    void FreeItem( VERTEX_ITEM& aItem ) const;
 
    void ChangeItemColor( const VERTEX_ITEM& aItem, const COLOR4D& aColor ) const;
 
    void ChangeItemDepth( const VERTEX_ITEM& aItem, GLfloat aDepth ) const;
 
    VERTEX* GetVertices( const VERTEX_ITEM& aItem ) const;
 
    const glm::mat4& GetTransformation() const
    {
        return m_transform;
    }
 
    void SetShader( SHADER& aShader ) const;
 
    void Clear() const;
 
    void BeginDrawing() const;
 
    void DrawItem( const VERTEX_ITEM& aItem ) const;
 
    void EndDrawing() const;
 
    void EnableDepthTest( bool aEnabled );
 
protected:
    void putVertex( VERTEX& aTarget, GLfloat aX, GLfloat aY, GLfloat aZ ) const;
 
    std::shared_ptr<VERTEX_CONTAINER> m_container;
    std::shared_ptr<GPU_MANAGER>      m_gpu;
 
    bool                    m_noTransform;
    glm::mat4               m_transform;
    std::stack<glm::mat4>   m_transformStack;
    GLubyte                 m_color[COLOR_STRIDE];
    GLfloat                 m_shader[SHADER_STRIDE];
 
    VERTEX*                 m_reserved;
 
    unsigned int            m_reservedSpace;
};
 
} // namespace KIGFX
 
#endif /* VERTEX_MANAGER_H_ */