if (smoothNormals==true)
        {
            SmoothNormals();
        }

        // vertex count
        unsigned int vertexCount = tVertex.size();

        // Set Attributes
        if (HasVertex()==true || tVertex.size()>0)
        {
            hasVertex = true;
            AddAttribute("Vertex", "aPosition", BufferElementUsage::Pos, BufferElementType::Vec3);
        }
        if (HasNormal()==true || tNormal.size()>0)
        {
            hasNormal = true;
            AddAttribute("Vertex", "aNormal", BufferElementUsage::Normal, BufferElementType::Vec3);
        }
        if (HasTexcoord()==true || tTexcoord.size()>0)
        {
            hasTexcoord = true;
            AddAttribute("Vertex", "aTexcoord", BufferElementUsage::TexCoord, BufferElementType::Vec2);
        }
        if (HasTangentBitangent()==true || (tBitangent.size()>0 && tTangent.size()>0))
        {
            hasTangentBitangent = true;
            AddAttribute("Vertex", "aTangent", BufferElementUsage::Tangent, BufferElementType::Vec3);
            AddAttribute("Vertex", "aBitangent", BufferElementUsage::Bitangent, BufferElementType::Vec3);
        }
        if (HasVertexColor()==true || tVertexColor.size()>0)
        {
            hasVertexColor = true;
            AddAttribute("Vertex", "aColor", BufferElementUsage::Color, BufferElementType::Vec4);
        }

        // Set offsets
        unsigned int offset = 0;
        for (std::map <StringID, AttributeBuffer>::iterator i=Attributes.begin();i!=Attributes.end();i++)
        {
            for (std::map<StringID, SuperSmartPointer <VertexAttribute> >::iterator k = (*i).second.Attributes.begin();k!=(*i).second.Attributes.end();k++)
            {
                (*k).second->Offset = offset;
                switch((*k).second->Type)
                {
                    case BufferElementType::Float:
                            offset += sizeof(float);
                            (*k).second->byteSize=sizeof(float);
                            break;
                    case BufferElementType::Int:
                            offset += sizeof(int);
                            (*k).second->byteSize=sizeof(int);
                            break;
                    case BufferElementType::Matrix:
                            offset += sizeof(Matrix);
                            (*k).second->byteSize=sizeof(Matrix);
                            break;
                    case BufferElementType::Vec2:
                            offset += sizeof(vec2);
                            (*k).second->byteSize=sizeof(vec2);
                            break;
                    case BufferElementType::Vec3:
                            offset += sizeof(vec3);
                            (*k).second->byteSize=sizeof(vec3);
                            break;
                    case BufferElementType::Vec4:
                            offset += sizeof(vec4);
                            (*k).second->byteSize=sizeof(vec4);
                            break;
                };
            }
        }
        vertexTotalOffset = offset;

        // resize vertexdata
        vertexData.resize(vertexTotalOffset*vertexCount);

        // copy data
        for (unsigned int v=0; v<vertexCount; v++)
        {
            offset = vertexTotalOffset*v;
            for (std::map<StringID, AttributeBuffer >::iterator i=Attributes.begin(); i!=Attributes.end();i++)
            {
                for (std::map<StringID, SuperSmartPointer<VertexAttribute> >::iterator k=(*i).second.Attributes.begin();k!=(*i).second.Attributes.end();k++)
                {
                    switch ((*k).second->Usage)
                    {
                        case BufferElementUsage::Pos:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tVertex[v], (*k).second->byteSize);
                            break;
                        case BufferElementUsage::Normal:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tNormal[v], (*k).second->byteSize);
                            break;
                        case BufferElementUsage::TexCoord:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tTexcoord[v], (*k).second->byteSize);
                            break;
                        case BufferElementUsage::Color:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tVertexColor[v], (*k).second->byteSize);
                            break;
                        case BufferElementUsage::Tangent:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tTangent[v], (*k).second->byteSize);
                            break;
                        case BufferElementUsage::Bitangent:
                            memcpy(&vertexData[offset + (*k).second->Offset], &tBitangent[v], (*k).second->byteSize);
                            break;
                    }
                }
            }
        }

        // send index buffer
        indexBuffer->Init( &indexData[0], sizeof(unsigned int)*indexData.size(), BufferType::Index, BufferDraw::Static );
        // send vertex buffers
        for (std::map <StringID, AttributeBuffer>::iterator i=Attributes.begin();i!=Attributes.end();i++)
        {
            (*i).second.Buffer = SuperSmartPointer<GeometryBuffer> (new GeometryBuffer());
            (*i).second.Buffer->Init(&vertexData[0], vertexData.size(), BufferType::Attribute, BufferDraw::Static);
        }