398 lines
13 KiB
C++
398 lines
13 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2013-2016 CERN
|
|
* @author Maciej Suminski <maciej.suminski@cern.ch>
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
/**
|
|
* @file vertex_manager.h
|
|
* @brief Class to control vertex container and GPU with possibility of emulating old-style OpenGL
|
|
* 1.0 state machine using modern OpenGL methods.
|
|
*/
|
|
|
|
#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>
|
|
#include <wx/log.h>
|
|
|
|
namespace KIGFX
|
|
{
|
|
class SHADER;
|
|
class VERTEX_ITEM;
|
|
class VERTEX_CONTAINER;
|
|
class GPU_MANAGER;
|
|
|
|
class VERTEX_MANAGER
|
|
{
|
|
public:
|
|
/**
|
|
* @brief Constructor.
|
|
*
|
|
* @param aCached says if vertices should be cached in GPU or system memory. For data that
|
|
* does not change every frame, it is better to store vertices in GPU memory.
|
|
*/
|
|
VERTEX_MANAGER( bool aCached );
|
|
|
|
/**
|
|
* Function Map()
|
|
* maps vertex buffer.
|
|
*/
|
|
void Map();
|
|
|
|
/**
|
|
* Function Unmap()
|
|
* unmaps vertex buffer.
|
|
*/
|
|
void Unmap();
|
|
|
|
/**
|
|
* Function Reserve()
|
|
* allocates space for vertices, so it will be used with subsequent Vertex() calls.
|
|
*
|
|
* @param aSize is the number of vertices that should be available in the reserved space.
|
|
* @return True if successful, false otherwise.
|
|
*/
|
|
bool Reserve( unsigned int aSize );
|
|
|
|
/**
|
|
* Function Vertex()
|
|
* adds a vertex with the given coordinates to the currently set item. Color & shader
|
|
* parameters stored in aVertex are ignored, instead color & shader set by Color() and
|
|
* Shader() functions are used. Vertex coordinates will have the current transformation
|
|
* matrix applied.
|
|
*
|
|
* @param aVertex contains vertex coordinates.
|
|
* @return True if successful, false otherwise.
|
|
*/
|
|
inline bool Vertex( const VERTEX& aVertex )
|
|
{
|
|
return Vertex( aVertex.x, aVertex.y, aVertex.z );
|
|
}
|
|
|
|
/**
|
|
* Function Vertex()
|
|
* adds a vertex with the given coordinates to the currently set item. Vertex coordinates will
|
|
* have the current transformation matrix applied.
|
|
*
|
|
* @param aX is the X coordinate of the new vertex.
|
|
* @param aY is the Y coordinate of the new vertex.
|
|
* @param aZ is the Z coordinate of the new vertex.
|
|
* @return True if successful, false otherwise.
|
|
*/
|
|
bool Vertex( GLfloat aX, GLfloat aY, GLfloat aZ );
|
|
|
|
/**
|
|
* Function Vertex()
|
|
* adds a vertex with the given coordinates to the currently set item. Vertex coordinates will
|
|
* have the current transformation matrix applied.
|
|
*
|
|
* @param aXY are the XY coordinates of the new vertex.
|
|
* @param aZ is the Z coordinate of the new vertex.
|
|
* @return True if successful, false otherwise.
|
|
*/
|
|
bool Vertex( const VECTOR2D& aXY, GLfloat aZ )
|
|
{
|
|
return Vertex( aXY.x, aXY.y, aZ );
|
|
}
|
|
|
|
/**
|
|
* Function Vertices()
|
|
* adds one or more vertices to the currently set item. It takes advantage of allocating memory
|
|
* in advance, so should be faster than adding vertices one by one. Color & shader
|
|
* parameters stored in aVertices are ignored, instead color & shader set by Color() and
|
|
* Shader() functions are used. All the vertex coordinates will have the current
|
|
* transformation matrix applied.
|
|
*
|
|
* @param aVertices contains vertices to be added
|
|
* @param aSize is the number of vertices to be added.
|
|
* @return True if successful, false otherwise.
|
|
*/
|
|
bool Vertices( const VERTEX aVertices[], unsigned int aSize );
|
|
|
|
/**
|
|
* Function Color()
|
|
* changes currently used color that will be applied to newly added vertices.
|
|
*
|
|
* @param aColor is the new color.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Function Color()
|
|
* changes currently used color that will be applied to newly added vertices. It is the
|
|
* equivalent of glColor4f() function.
|
|
* @param aRed is the red component of the new color.
|
|
* @param aGreen is the green component of the new color.
|
|
* @param aBlue is the blue component of the new color.
|
|
* @param aAlpha is the alpha component of the new color.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Function Shader()
|
|
* changes currently used shader and its parameters that will be applied to newly added
|
|
* vertices. Parameters depend on shader, for more information have a look at shaders source
|
|
* code.
|
|
* @see SHADER_TYPE
|
|
*
|
|
* @param aShaderType is the a shader type to be applied.
|
|
* @param aParam1 is the optional parameter for a shader.
|
|
* @param aParam2 is the optional parameter for a shader.
|
|
* @param aParam3 is the optional parameter for a shader.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Function Translate()
|
|
* multiplies the current matrix by a translation matrix, so newly vertices will be
|
|
* translated by the given vector. It is the equivalent of the glTranslatef() function.
|
|
*
|
|
* @param aX is the X coordinate of a translation vector.
|
|
* @param aY is the X coordinate of a translation vector.
|
|
* @param aZ is the X coordinate of a translation vector.
|
|
*/
|
|
inline void Translate( GLfloat aX, GLfloat aY, GLfloat aZ )
|
|
{
|
|
m_transform = glm::translate( m_transform, glm::vec3( aX, aY, aZ ) );
|
|
}
|
|
|
|
/**
|
|
* Function Rotate()
|
|
* multiplies the current matrix by a rotation matrix, so the newly vertices will be
|
|
* rotated by the given angles. It is the equivalent of the glRotatef() function.
|
|
*
|
|
* @param aAngle is the angle of rotation, in radians.
|
|
* @param aX is a multiplier for the X axis
|
|
* @param aY is a multiplier for the Y axis
|
|
* @param aZ is a multiplier for the Z axis.
|
|
*/
|
|
inline void Rotate( GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ )
|
|
{
|
|
m_transform = glm::rotate( m_transform, aAngle, glm::vec3( aX, aY, aZ ) );
|
|
}
|
|
|
|
/**
|
|
* Function Scale()
|
|
* multiplies the current matrix by a scaling matrix, so the newly vertices will be
|
|
* scaled by the given factors. It is the equivalent of the glScalef() function.
|
|
*
|
|
* @param aX is the X axis scaling factor.
|
|
* @param aY is the Y axis scaling factor.
|
|
* @param aZ is the Z axis scaling factor.
|
|
*/
|
|
inline void Scale( GLfloat aX, GLfloat aY, GLfloat aZ )
|
|
{
|
|
m_transform = glm::scale( m_transform, glm::vec3( aX, aY, aZ ) );
|
|
}
|
|
|
|
/**
|
|
* Function PushMatrix()
|
|
* pushes the current transformation matrix stack. It is the equivalent of the glPushMatrix()
|
|
* function.
|
|
*/
|
|
inline void PushMatrix()
|
|
{
|
|
m_transformStack.push( m_transform );
|
|
|
|
// Every transformation starts with PushMatrix
|
|
m_noTransform = false;
|
|
}
|
|
|
|
/**
|
|
* Function PopMatrix()
|
|
* pops the current transformation matrix stack. It is the equivalent of the glPopMatrix()
|
|
* function.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Function SetItem()
|
|
* sets an item to start its modifications. After calling the function it is possible to add
|
|
* vertices using function Add().
|
|
*
|
|
* @param aItem is the item that is going to store vertices in the container.
|
|
*/
|
|
void SetItem( VERTEX_ITEM& aItem ) const;
|
|
|
|
/**
|
|
* Function FinishItem()
|
|
* does the cleaning after adding an item.
|
|
*/
|
|
void FinishItem() const;
|
|
|
|
/**
|
|
* Function FreeItem()
|
|
* frees the memory occupied by the item, so it is no longer stored in the container.
|
|
*
|
|
* @param aItem is the item to be freed
|
|
*/
|
|
void FreeItem( VERTEX_ITEM& aItem ) const;
|
|
|
|
/**
|
|
* Function ChangeItemColor()
|
|
* changes the color of all vertices owned by an item.
|
|
*
|
|
* @param aItem is the item to change.
|
|
* @param aColor is the new color to be applied.
|
|
*/
|
|
void ChangeItemColor( const VERTEX_ITEM& aItem, const COLOR4D& aColor ) const;
|
|
|
|
/**
|
|
* Function ChangeItemDepth()
|
|
* changes the depth of all vertices owned by an item.
|
|
*
|
|
* @param aItem is the item to change.
|
|
* @param aDepth is the new color to be applied.
|
|
*/
|
|
void ChangeItemDepth( const VERTEX_ITEM& aItem, GLfloat aDepth ) const;
|
|
|
|
/**
|
|
* Function GetVertices()
|
|
* returns a pointer to the vertices owned by an item.
|
|
*
|
|
* @param aItem is the owner of vertices that are going to be returned.
|
|
* @return Pointer to the vertices or NULL if the item is not stored at the container.
|
|
*/
|
|
VERTEX* GetVertices( const VERTEX_ITEM& aItem ) const;
|
|
|
|
const glm::mat4& GetTransformation() const
|
|
{
|
|
return m_transform;
|
|
}
|
|
|
|
/**
|
|
* Function SetShader()
|
|
* sets a shader program that is going to be used during rendering.
|
|
* @param aShader is the object containing compiled and linked shader program.
|
|
*/
|
|
void SetShader( SHADER& aShader ) const;
|
|
|
|
/**
|
|
* Function Clear()
|
|
* removes all the stored vertices from the container.
|
|
*/
|
|
void Clear() const;
|
|
|
|
/**
|
|
* Function BeginDrawing()
|
|
* prepares buffers and items to start drawing.
|
|
*/
|
|
void BeginDrawing() const;
|
|
|
|
/**
|
|
* Function DrawItem()
|
|
* draws an item to the buffer.
|
|
*
|
|
* @param aItem is the item to be drawn.
|
|
*/
|
|
void DrawItem( const VERTEX_ITEM& aItem ) const;
|
|
|
|
/**
|
|
* Function EndDrawing()
|
|
* finishes drawing operations.
|
|
*/
|
|
void EndDrawing() const;
|
|
|
|
/**
|
|
* Function EnableDepthTest()
|
|
* Enables/disables Z buffer depth test.
|
|
*/
|
|
void EnableDepthTest( bool aEnabled );
|
|
|
|
protected:
|
|
/**
|
|
* Function putVertex()
|
|
* applies all transformation to the given coordinates and store them at the specified target.
|
|
*
|
|
* @param aTarget is the place where the new vertex is going to be stored (it has to be
|
|
* allocated first).
|
|
* @param aX is the X coordinate of the new vertex.
|
|
* @param aY is the Y coordinate of the new vertex.
|
|
* @param aZ is the Z coordinate of the new vertex.
|
|
*/
|
|
void putVertex( VERTEX& aTarget, GLfloat aX, GLfloat aY, GLfloat aZ ) const;
|
|
|
|
/// Container for vertices, may be cached or noncached
|
|
std::shared_ptr<VERTEX_CONTAINER> m_container;
|
|
/// GPU manager for data transfers and drawing operations
|
|
std::shared_ptr<GPU_MANAGER> m_gpu;
|
|
|
|
/// State machine variables
|
|
/// True in case there is no need to transform vertices
|
|
bool m_noTransform;
|
|
/// Currently used transform matrix
|
|
glm::mat4 m_transform;
|
|
/// Stack of transformation matrices, used for Push/PopMatrix
|
|
std::stack<glm::mat4> m_transformStack;
|
|
/// Currently used color
|
|
GLubyte m_color[COLOR_STRIDE];
|
|
/// Currently used shader and its parameters
|
|
GLfloat m_shader[SHADER_STRIDE];
|
|
|
|
/// Currently reserved chunk to store vertices
|
|
VERTEX* m_reserved;
|
|
|
|
/// Currently available reserved space
|
|
unsigned int m_reservedSpace;
|
|
};
|
|
|
|
} // namespace KIGFX
|
|
|
|
#endif /* VERTEX_MANAGER_H_ */
|