Mesh::Mesh()
{
BufferLayout layout;
layout.add(ET_vec3_f32, UT_position);
layout.add(ET_vec2_f32, UT_texcoord0);
init(layout, ET_u16);
}
void GLVertexBuffer::SetLayout(const BufferLayout& bufferLayout)
{
m_Layout = bufferLayout;
const std::vector<BufferElement>& layout = bufferLayout.GetLayout();
for (uint i = 0; i < layout.size(); i++)
{
const BufferElement& element = layout[i];
GLCall(glEnableVertexAttribArray(i));
GLCall(glVertexAttribPointer(i, element.count, element.type, element.normalized, bufferLayout.GetStride(), (const void*)element.offset));
}
}
DrawContext::DrawContext(Context* ctx)
{
glContext = ctx;
_textBuffer = new TextBuffer;
// load some common shaders
colorShader = Application::instance()->resourceManager->shader("resources/glsl/color");
textureShader = Application::instance()->resourceManager->shader("resources/glsl/texture");
// create buffers for efficient quad drawing. Vertex and index buffers are reused as often as possible
BufferLayout layout;
layout.add(ET_vec2_f32, UT_position);
layout.add(ET_vec2_f32, UT_texcoord0);
bgquad = Mesh::create(layout, ET_u16);
bgquad->resetSize(4, 6);
bgquad->indexBuffer->drawMode = GL_TRIANGLES;
bgquad->set(0, UT_position, Vec2(0,0));
bgquad->set(1, UT_position, Vec2(1,0));
bgquad->set(2, UT_position, Vec2(1,1));
bgquad->set(3, UT_position, Vec2(0,1));
bgquad->set(0,UT_texcoord0, Vec2(0,0));
bgquad->set(1,UT_texcoord0, Vec2(1,0));
bgquad->set(2,UT_texcoord0, Vec2(1,1));
bgquad->set(3,UT_texcoord0, Vec2(0,1));
bgquad->set(0, UT_index, (u16)0);
bgquad->set(1, UT_index, (u16)1);
bgquad->set(2, UT_index, (u16)2);
bgquad->set(3, UT_index, (u16)2);
bgquad->set(4, UT_index, (u16)3);
bgquad->set(5, UT_index, (u16)0);
bgquad->material->shader = colorShader;
bgquad->material->color = whiteColor;
bgquad->material->blendPremultiplied();
textMesh.reset(new TextMesh);
textMesh->material->shader = textureShader;
textMesh->material->color = whiteColor;
_flipX = false;
_flipY = false;
updateTexCoords();
ninePatch.reset(new NinePatch);
ninePatch->flip = true;
ninePatch->material->shader = textureShader;
ninePatch->material->blendPremultiplied();
}
HybridIndexBuffer::HybridIndexBuffer(ElementType et)
{
// an indexbuffer only ever has one attribute with usage type index in a single partition
// only the element type can vary, to optimize the buffer for hardware requirements or
// mesh sizes.
BufferLayout layout;
layout.add(et, UT_index);
switch(et)
{
case ET_u8:type = GL_UNSIGNED_BYTE;break;
case ET_u16:type = GL_UNSIGNED_SHORT;break;
case ET_u32:type = GL_UNSIGNED_INT;break;
default:
ASSERT(false,"only u8, u16, u32 are allowed");
}
drawMode = GL_TRIANGLES;
init(GL_ELEMENT_ARRAY_BUFFER, layout);
}
void NinePatch::init()
{
BufferLayout layout;
layout.add(ET_vec2_f32, UT_position);
layout.add(ET_vec2_f32, UT_texcoord0);
this->resetBuffers(layout, ET_u16);
indexBuffer->drawMode = GL_TRIANGLES;
u32 numVertices = 16; // draw it on paper and you'll see it's correct
uint32_t numQuads = 9; // it's a 3x3 matrix of quads
uint32_t numTris = numQuads*2; // each quad is drawn with two tris
u32 numIndices = numTris*3; // currently, each tri is drawn with 3 indices
this->vertexBuffer->reset(numVertices);
this->indexBuffer->reset(numIndices);
// updateTexCoords();
updateIndices();
}
HybridIndexBuffer::HybridIndexBuffer(ElementType et)
{
// an indexbuffer only ever has one attribute with usage type index in a single partition
// only the element type can vary, to optimize the buffer for hardware requirements or
// mesh sizes.
BufferLayout layout;
layout.add(et, UT_index);
switch(et)
{
case ET_u8:type = GL_UNSIGNED_BYTE;break;
case ET_u16:type = GL_UNSIGNED_SHORT;break;
case ET_u32:type = GL_UNSIGNED_INT;break;
default:
lost::common::StringStream os;
os << "only u8, u16, u32 are allowed";
LOGTHROW(std::runtime_error(os.str().c_str()));
}
drawMode = GL_TRIANGLES;
init(GL_ELEMENT_ARRAY_BUFFER, layout);
BB_INC(bb_hib_key);
}
void P3DImporter::importMeshes( Scene* scene )
{
int numMeshes = 0;
fread( &m_framesPerSecond, sizeof( int ), 1, m_fh );
fread( &numMeshes, sizeof( int ), 1, m_fh );
for( int i = 0; i < numMeshes; ++i )
{
int numAttribs = 0;
int id = -1;
int parentID = -1;
int meshType = -1;
fread( &id, sizeof( int ), 1, m_fh );
fread( &parentID, sizeof( int ), 1, m_fh );
fread( &meshType, sizeof( int ), 1, m_fh );
fread( &numAttribs, sizeof( int ), 1, m_fh );
BufferLayout* vtxLayout = new BufferLayout();
BufferLayout* idxLayout = new BufferLayout( 1, BufferLayout::INT );
for( int a = 0; a < numAttribs; ++a )
{
int type = 0;
fread( &type, sizeof( int ), 1, m_fh );
vtxLayout->pushAttribute( (BufferLayout::DataType )type );
}
int numTriBatches = 0;
fread( &numTriBatches, sizeof( int ), 1, m_fh );
Mesh* mesh = nullptr;
for( int t = 0; t < numTriBatches; ++t )
{
int matID = -1;
int numIndices = 0;
int numVertices = 0;
fread( &matID, sizeof( int ), 1, m_fh );
fread( &numIndices, sizeof( int ), 1, m_fh );
fread( &numVertices, sizeof( int ), 1, m_fh );
int vtxBufferSize = vtxLayout->stride() * numVertices;
int idxBufferSize = idxLayout->stride() * numIndices;
char* vertices = new char[ vtxBufferSize ];
char* indices = new char[ idxBufferSize ];
fread( indices, sizeof( char ), idxBufferSize, m_fh );
fread( vertices, sizeof( char ), vtxBufferSize, m_fh );
GLBuffer* vtxBuffer = new GLBuffer( vertices, numVertices, vtxLayout, GL_ARRAY_BUFFER, GL_TRIANGLES, GL_STATIC_DRAW );
GLBuffer* idxBuffer = new GLBuffer( indices, numIndices, idxLayout, GL_ELEMENT_ARRAY_BUFFER, GL_TRIANGLES, GL_STATIC_DRAW );
std::string matName;
if( matID == -1 )
if( meshType == 1 )
{
matName = "SkinningMaterial";
//Renderer::getMaterial( matName )->changeShaderProgram( "SkinningShader" );
}
else
matName = "DiffuseMaterial";
else
{
matName = m_materials[matID];
if( meshType == 1 )
{
Renderer::getMaterial( matName )->changeShaderProgram( "SkinningShader" );
}
}
if( mesh == nullptr )
{
if( meshType == 1 )
mesh = new SkeletalMesh( vtxBuffer, idxBuffer, nullptr, matName, true );
else
mesh = new Mesh( vtxBuffer, idxBuffer, nullptr, matName, true );
}
else
mesh->pushTriangleBatch( vtxBuffer, idxBuffer, nullptr, matName, true );
vtxBuffer->sendToOpenGL();
idxBuffer->sendToOpenGL();
}
// create the actor for the mesh
Actor* actor = new Actor( m_fileName + toString( i ), mesh );
int numFrames = 0;
fread( &numFrames, sizeof( int ), 1, m_fh );
actor->setFrameCount( numFrames );
for( int f = 0; f < numFrames; ++f )
{
vec3f translation;
quatf rotation;
vec3f scale;
fread( &translation, sizeof( vec3f ), 1, m_fh );
fread( &rotation, sizeof( quatf ), 1, m_fh );
fread( &scale, sizeof( vec3f ), 1, m_fh );
actor->setFrame( Node::Frame( translation, mat3f::createMatrixFromQuaternion( rotation ), scale ), f );
}
actor->setFrameRate( 1 / static_cast<float>(m_framesPerSecond) );
scene->actors.push_back( actor );
m_parentIDToActorIndex[ id ] = scene->actors.size() - 1;
if( parentID != -1 )
{
auto iter = m_parentIDToActorIndex.find( parentID );
if( iter != m_parentIDToActorIndex.end() )
{
scene->actors[ iter->second ]->addChild( actor );
}
}
// If skeletal mesh
if( meshType == 1 )
{
SkeletalMesh* skelMesh = reinterpret_cast< SkeletalMesh* >( mesh );
skelMesh->setFrameRate( 1 / static_cast<float>(m_framesPerSecond) );
int numBones = 0;
int numFrames = 0;
fread( &numBones, sizeof( int ), 1, m_fh );
fread( &numFrames, sizeof( int ), 1, m_fh );
std::vector< mat4f > bone;
for( int b = 0; b < numBones; ++b )
{
bone.clear();
for( int bf = 0; bf < numFrames; ++bf )
{
vec3f translation;
quatf rotation;
vec3f scale;
fread( &translation, sizeof( vec3f ), 1, m_fh );
fread( &rotation, sizeof( quatf ), 1, m_fh );
fread( &scale, sizeof( vec3f ), 1, m_fh );
mat4f boneFrameTM( mat4f::IDENTITY );
boneFrameTM.scale( scale );
boneFrameTM.rotate( rotation );
boneFrameTM.translate( translation );
bone.push_back( boneFrameTM );
}
skelMesh->addBone( bone );
}
skelMesh->play();
}
}
}
