haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Code formatting 

Renamed VERTEX related constants to follow UPPER_CASE naming.
This commit is contained in:
Maciej Suminski 2017-09-09 20:40:00 +02:00
parent 19ad350c1c
commit 342bb2bf78
8 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
common/gal/opengl/cached_container.cpp
View File

@ -257,7 +257,7 @@ bool CACHED_CONTAINER::reallocate( unsigned int aSize )
(int) m_item, oldChunkOffset, newChunkOffset );
#endif
// The item was reallocated, so we have to copy all the old data to the new place
memcpy( &m_vertices[newChunkOffset], &m_vertices[m_chunkOffset], itemSize * VertexSize );
memcpy( &m_vertices[newChunkOffset], &m_vertices[m_chunkOffset], itemSize * VERTEX_SIZE );
// Free the space used by the previous chunk
addFreeChunk( m_chunkOffset, m_chunkSize );
@ -288,7 +288,7 @@ void CACHED_CONTAINER::defragment( VERTEX* aTarget )
int itemSize = item->GetSize();
// Move an item to the new container
memcpy( &aTarget[newOffset], &m_vertices[itemOffset], itemSize * VertexSize );
memcpy( &aTarget[newOffset], &m_vertices[itemOffset], itemSize * VERTEX_SIZE );
// Update new offset
item->setOffset( newOffset );
@ -301,7 +301,7 @@ void CACHED_CONTAINER::defragment( VERTEX* aTarget )
if( m_item->GetSize() > 0 )
{
memcpy( &aTarget[newOffset], &m_vertices[m_item->GetOffset()],
m_item->GetSize() * VertexSize );
m_item->GetSize() * VERTEX_SIZE );
m_item->setOffset( newOffset );
m_chunkOffset = newOffset;
}

12
common/gal/opengl/cached_container_gpu.cpp
View File

@ -45,7 +45,7 @@ CACHED_CONTAINER_GPU::CACHED_CONTAINER_GPU( unsigned int aSize ) :
glGenBuffers( 1, &m_glBufferHandle );
glBindBuffer( GL_ARRAY_BUFFER, m_glBufferHandle );
glBufferData( GL_ARRAY_BUFFER, m_currentSize * VertexSize, NULL, GL_DYNAMIC_DRAW );
glBufferData( GL_ARRAY_BUFFER, m_currentSize * VERTEX_SIZE, NULL, GL_DYNAMIC_DRAW );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
checkGlError( "allocating video memory for cached container" );
}
@ -120,7 +120,7 @@ bool CACHED_CONTAINER_GPU::defragmentResize( unsigned int aNewSize )
assert( eaBuffer == 0 );
#endif /* __WXDEBUG__ */
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, newBuffer );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, aNewSize * VertexSize, NULL, GL_DYNAMIC_DRAW );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, aNewSize * VERTEX_SIZE, NULL, GL_DYNAMIC_DRAW );
checkGlError( "creating buffer during defragmentation" );
ITEMS::iterator it, it_end;
@ -135,7 +135,7 @@ bool CACHED_CONTAINER_GPU::defragmentResize( unsigned int aNewSize )
// Move an item to the new container
glCopyBufferSubData( GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
itemOffset * VertexSize, newOffset * VertexSize, itemSize * VertexSize );
itemOffset * VERTEX_SIZE, newOffset * VERTEX_SIZE, itemSize * VERTEX_SIZE );
// Update new offset
item->setOffset( newOffset );
@ -148,8 +148,8 @@ bool CACHED_CONTAINER_GPU::defragmentResize( unsigned int aNewSize )
if( m_item->GetSize() > 0 )
{
glCopyBufferSubData( GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
m_item->GetOffset() * VertexSize, newOffset * VertexSize,
m_item->GetSize() * VertexSize );
m_item->GetOffset() * VERTEX_SIZE, newOffset * VERTEX_SIZE,
m_item->GetSize() * VERTEX_SIZE );
m_item->setOffset( newOffset );
m_chunkOffset = newOffset;
@ -217,7 +217,7 @@ bool CACHED_CONTAINER_GPU::defragmentResizeMemcpy( unsigned int aNewSize )
assert( eaBuffer == 0 );
#endif /* __WXDEBUG__ */
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, newBuffer );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, aNewSize * VertexSize, NULL, GL_DYNAMIC_DRAW );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, aNewSize * VERTEX_SIZE, NULL, GL_DYNAMIC_DRAW );
newBufferMem = static_cast<VERTEX*>( glMapBuffer( GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY ) );
checkGlError( "creating buffer during defragmentation" );

6
common/gal/opengl/cached_container_ram.cpp
View File

@ -45,7 +45,7 @@ CACHED_CONTAINER_RAM::CACHED_CONTAINER_RAM( unsigned int aSize ) :
glGenBuffers( 1, &m_verticesBuffer );
checkGlError( "generating vertices buffer" );
m_vertices = static_cast<VERTEX*>( malloc( aSize * VertexSize ) );
m_vertices = static_cast<VERTEX*>( malloc( aSize * VERTEX_SIZE ) );
}
@ -64,7 +64,7 @@ void CACHED_CONTAINER_RAM::Unmap()
// Upload vertices coordinates and shader types to GPU memory
glBindBuffer( GL_ARRAY_BUFFER, m_verticesBuffer );
checkGlError( "binding vertices buffer" );
glBufferData( GL_ARRAY_BUFFER, usedSpace() * VertexSize, m_vertices, GL_STREAM_DRAW );
glBufferData( GL_ARRAY_BUFFER, usedSpace() * VERTEX_SIZE, m_vertices, GL_STREAM_DRAW );
checkGlError( "transferring vertices" );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
checkGlError( "unbinding vertices buffer" );
@ -85,7 +85,7 @@ bool CACHED_CONTAINER_RAM::defragmentResize( unsigned int aNewSize )
PROF_COUNTER totalTime;
#endif /* __WXDEBUG__ */
VERTEX* newBufferMem = static_cast<VERTEX*>( malloc( aNewSize * VertexSize ) );
VERTEX* newBufferMem = static_cast<VERTEX*>( malloc( aNewSize * VERTEX_SIZE ) );
if( !newBufferMem )
return false;

20
common/gal/opengl/gpu_manager.cpp
View File

@ -160,15 +160,15 @@ void GPU_CACHED_MANAGER::EndDrawing()
// Bind vertices data buffers
glBindBuffer( GL_ARRAY_BUFFER, cached->GetBufferHandle() );
glVertexPointer( CoordStride, GL_FLOAT, VertexSize, 0 );
glColorPointer( ColorStride, GL_UNSIGNED_BYTE, VertexSize, (GLvoid*) ColorOffset );
glVertexPointer( COORD_STRIDE, GL_FLOAT, VERTEX_SIZE, (GLvoid*) COORD_OFFSET );
glColorPointer( COLOR_STRIDE, GL_UNSIGNED_BYTE, VERTEX_SIZE, (GLvoid*) COLOR_OFFSET );
if( m_shader != NULL ) // Use shader if applicable
{
m_shader->Use();
glEnableVertexAttribArray( m_shaderAttrib );
glVertexAttribPointer( m_shaderAttrib, ShaderStride, GL_FLOAT, GL_FALSE,
VertexSize, (GLvoid*) ShaderOffset );
glVertexAttribPointer( m_shaderAttrib, SHADER_STRIDE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE, (GLvoid*) SHADER_OFFSET );
}
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_indicesBuffer );
@ -252,23 +252,23 @@ void GPU_NONCACHED_MANAGER::EndDrawing()
VERTEX* vertices = m_container->GetAllVertices();
GLfloat* coordinates = (GLfloat*) ( vertices );
GLubyte* colors = (GLubyte*) ( vertices ) + ColorOffset;
GLubyte* colors = (GLubyte*) ( vertices ) + COLOR_OFFSET;
// Prepare buffers
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glVertexPointer( CoordStride, GL_FLOAT, VertexSize, coordinates );
glColorPointer( ColorStride, GL_UNSIGNED_BYTE, VertexSize, colors );
glVertexPointer( COORD_STRIDE, GL_FLOAT, VERTEX_SIZE, coordinates );
glColorPointer( COLOR_STRIDE, GL_UNSIGNED_BYTE, VERTEX_SIZE, colors );
if( m_shader != NULL ) // Use shader if applicable
{
GLfloat* shaders = (GLfloat*) ( vertices ) + ShaderOffset / sizeof(GLfloat);
GLfloat* shaders = (GLfloat*) ( vertices ) + SHADER_OFFSET / sizeof(GLfloat);
m_shader->Use();
glEnableVertexAttribArray( m_shaderAttrib );
glVertexAttribPointer( m_shaderAttrib, ShaderStride, GL_FLOAT, GL_FALSE,
VertexSize, shaders );
glVertexAttribPointer( m_shaderAttrib, SHADER_STRIDE, GL_FLOAT, GL_FALSE,
VERTEX_SIZE, shaders );
}
glDrawArrays( GL_TRIANGLES, 0, m_container->GetSize() );

4
common/gal/opengl/vertex_manager.cpp
View File

@ -44,7 +44,7 @@ VERTEX_MANAGER::VERTEX_MANAGER( bool aCached ) :
m_gpu.reset( GPU_MANAGER::MakeManager( m_container.get() ) );
// There is no shader used by default
for( unsigned int i = 0; i < ShaderStride; ++i )
for( unsigned int i = 0; i < SHADER_STRIDE; ++i )
m_shader[i] = 0.0f;
}
@ -279,7 +279,7 @@ void VERTEX_MANAGER::putVertex( VERTEX& aTarget, GLfloat aX, GLfloat aY, GLfloat
aTarget.a = m_color[3];
// Apply currently used shader
for( unsigned int j = 0; j < ShaderStride; ++j )
for( unsigned int j = 0; j < SHADER_STRIDE; ++j )
{
aTarget.shader[j] = m_shader[j];
}

10
include/gal/opengl/cached_container.h
View File

@ -91,17 +91,17 @@ protected:
typedef std::set<VERTEX_ITEM*> ITEMS;
///> Stores size & offset of free chunks.
FREE_CHUNK_MAP m_freeChunks;
FREE_CHUNK_MAP m_freeChunks;
///> Stored VERTEX_ITEMs
ITEMS m_items;
ITEMS m_items;
///> Currently modified item
VERTEX_ITEM* m_item;
VERTEX_ITEM* m_item;
///> Properties of currently modified chunk & item
unsigned int m_chunkSize;
unsigned int m_chunkOffset;
unsigned int m_chunkSize;
unsigned int m_chunkOffset;
/**
* Resizes the chunk that stores the current item to the given size. The current item has

34
include/gal/opengl/vertex_common.h
View File

@ -36,7 +36,7 @@
namespace KIGFX
{
// Possible types of shaders
///> Possible types of shaders
enum SHADER_MODE
{
SHADER_NONE = 0,
@ -46,32 +46,32 @@ enum SHADER_MODE
SHADER_FONT
};
typedef struct
///> Data structure for vertices {X,Y,Z,R,G,B,A,shader&param}
struct VERTEX
{
GLfloat x, y, z; // Coordinates
GLubyte r, g, b, a; // Color
GLfloat shader[4]; // Shader type & params
} VERTEX;
};
///< Data structure for vertices {X,Y,Z,R,G,B,A,shader&param} (@see VERTEX).
const size_t VertexSize = sizeof(VERTEX);
const size_t VertexStride = VertexSize / sizeof(GLfloat);
static constexpr size_t VERTEX_SIZE = sizeof(VERTEX);
static constexpr size_t VERTEX_STRIDE = VERTEX_SIZE / sizeof(GLfloat);
const size_t CoordSize = sizeof(VERTEX().x) + sizeof(VERTEX().y) + sizeof(VERTEX().z);
const size_t CoordStride = CoordSize / sizeof(GLfloat);
static constexpr size_t COORD_OFFSET = offsetof(VERTEX, x);
static constexpr size_t COORD_SIZE = sizeof(VERTEX::x) + sizeof(VERTEX::y) + sizeof(VERTEX::z);
static constexpr size_t COORD_STRIDE = COORD_SIZE / sizeof(GLfloat);
// Offset of color data from the beginning of each vertex data
const size_t ColorOffset = offsetof(VERTEX, r);
const size_t ColorSize = sizeof(VERTEX().r) + sizeof(VERTEX().g) +
sizeof(VERTEX().b) + sizeof(VERTEX().a);
const size_t ColorStride = ColorSize / sizeof(GLubyte);
static constexpr size_t COLOR_OFFSET = offsetof(VERTEX, r);
static constexpr size_t COLOR_SIZE = sizeof(VERTEX::r) + sizeof(VERTEX::g) + sizeof(VERTEX::b) + sizeof(VERTEX::a);
static constexpr size_t COLOR_STRIDE = COLOR_SIZE / sizeof(GLubyte);
// Shader attributes
const size_t ShaderOffset = offsetof(VERTEX, shader);
const size_t ShaderSize = sizeof(VERTEX().shader);
const size_t ShaderStride = ShaderSize / sizeof(GLfloat);
static constexpr size_t SHADER_OFFSET = offsetof(VERTEX, shader);
static constexpr size_t SHADER_SIZE = sizeof(VERTEX::shader);
static constexpr size_t SHADER_STRIDE = SHADER_SIZE / sizeof(GLfloat);
static constexpr size_t INDEX_SIZE = sizeof(GLuint);
const size_t IndexSize = sizeof(GLuint);
} // namespace KIGFX
#endif /* VERTEX_COMMON_H_ */

4
include/gal/opengl/vertex_manager.h
View File

@ -361,9 +361,9 @@ protected:
/// Stack of transformation matrices, used for Push/PopMatrix
std::stack<glm::mat4> m_transformStack;
/// Currently used color
GLubyte m_color[ColorStride];
GLubyte m_color[COLOR_STRIDE];
/// Currently used shader and its parameters
GLfloat m_shader[ShaderStride];
GLfloat m_shader[SHADER_STRIDE];
/// Currently reserved chunk to store vertices
VERTEX* m_reserved;