Meshes

#include <filament/VertexBuffer.h>

struct Vertex {
    float3 position;
    float2 uv;
};

Vertex vertices[4] = {
    {{-1, -1, 0}, {0, 0}},
    {{ 1, -1, 0}, {1, 0}},
    {{ 1,  1, 0}, {1, 1}},
    {{-1,  1, 0}, {0, 1}}
};

VertexBuffer* vb = VertexBuffer::Builder()
    .vertexCount(4)
    .bufferCount(1)
    .attribute(VertexAttribute::POSITION, 0, 
        VertexBuffer::AttributeType::FLOAT3, 0, sizeof(Vertex))
    .attribute(VertexAttribute::UV0, 0,
        VertexBuffer::AttributeType::FLOAT2, 
        offsetof(Vertex, uv), sizeof(Vertex))
    .build(*engine);

vb->setBufferAt(*engine, 0,
    VertexBuffer::BufferDescriptor(vertices, sizeof(vertices)));

struct Vertex {
    float3 position;
    short4 tangents;  // Packed quaternion
    float2 uv;
};

VertexBuffer* vb = VertexBuffer::Builder()
    .vertexCount(vertexCount)
    .bufferCount(1)
    .attribute(VertexAttribute::POSITION, 0,
        VertexBuffer::AttributeType::FLOAT3, 0, sizeof(Vertex))
    .attribute(VertexAttribute::TANGENTS, 0,
        VertexBuffer::AttributeType::SHORT4, 
        offsetof(Vertex, tangents), sizeof(Vertex))
    .normalized(VertexAttribute::TANGENTS)
    .attribute(VertexAttribute::UV0, 0,
        VertexBuffer::AttributeType::FLOAT2,
        offsetof(Vertex, uv), sizeof(Vertex))
    .build(*engine);

// Static geometry in buffer 0
float3 positions[count];

// Dynamic data in buffer 1  
float2 uvs[count];

VertexBuffer* vb = VertexBuffer::Builder()
    .vertexCount(count)
    .bufferCount(2)
    .attribute(VertexAttribute::POSITION, 0,
        VertexBuffer::AttributeType::FLOAT3)
    .attribute(VertexAttribute::UV0, 1,
        VertexBuffer::AttributeType::FLOAT2)
    .build(*engine);

vb->setBufferAt(*engine, 0,
    VertexBuffer::BufferDescriptor(positions, sizeof(positions)));
vb->setBufferAt(*engine, 1,
    VertexBuffer::BufferDescriptor(uvs, sizeof(uvs)));

// Pack tangent frame into quaternion
mat3f tangentFrame = mat3f{
    float3{1, 0, 0},  // tangent
    float3{0, 0, 1},  // bitangent
    float3{0, 1, 0}   // normal
};

short4 packedTangents = packSnorm16(
    mat3f::packTangentFrame(tangentFrame).xyzw);

// Use in vertex buffer
VertexBuffer* vb = VertexBuffer::Builder()
    .attribute(VertexAttribute::TANGENTS, 1,
        VertexBuffer::AttributeType::SHORT4)
    .normalized(VertexAttribute::TANGENTS)
    .build(*engine);

// Store UVs as 16-bit integers
ushort2 uvs[count];
// ... fill with values 0-65535 ...

VertexBuffer* vb = VertexBuffer::Builder()
    .attribute(VertexAttribute::UV0, 0,
        VertexBuffer::AttributeType::USHORT2)
    .normalized(VertexAttribute::UV0)  // Map to [0, 1]
    .build(*engine);

#include <filament/IndexBuffer.h>

uint16_t indices[] = {0, 1, 2, 2, 3, 0};

IndexBuffer* ib = IndexBuffer::Builder()
    .indexCount(6)
    .bufferType(IndexBuffer::IndexType::USHORT)
    .build(*engine);

ib->setBuffer(*engine,
    IndexBuffer::BufferDescriptor(indices, sizeof(indices)));

uint32_t indices[largeCount];

IndexBuffer* ib = IndexBuffer::Builder()
    .indexCount(largeCount)
    .bufferType(IndexBuffer::IndexType::UINT)
    .build(*engine);

ib->setBuffer(*engine,
    IndexBuffer::BufferDescriptor(indices, sizeof(indices)));

#include <filament/RenderableManager.h>

Entity entity = entityManager.create();

RenderableManager::Builder(1)
    .boundingBox({{
        {-1, -1, -1}, {1, 1, 1}
    }})
    .material(0, materialInstance)
    .geometry(0, RenderableManager::PrimitiveType::TRIANGLES,
        vertexBuffer, indexBuffer, 0, indexCount)
    .culling(true)
    .receiveShadows(true)
    .castShadows(true)
    .build(*engine, entity);

scene->addEntity(entity);

static const uint32_t indices[] = {
    0, 1, 2, 2, 3, 0
};

static const float3 vertices[] = {
    {-10.0f, 0, -10.0f},
    {-10.0f, 0,  10.0f},
    { 10.0f, 0,  10.0f},
    { 10.0f, 0, -10.0f}
};

// Create tangent frame for ground plane
short4 tbn = packSnorm16(
    mat3f::packTangentFrame(
        mat3f{
            float3{1.0f, 0.0f, 0.0f},  // tangent
            float3{0.0f, 0.0f, 1.0f},  // bitangent  
            float3{0.0f, 1.0f, 0.0f}   // normal
        }
    ).xyzw);

static const short4 normals[] = {tbn, tbn, tbn, tbn};

VertexBuffer* vertexBuffer = VertexBuffer::Builder()
    .vertexCount(4)
    .bufferCount(2)
    .attribute(VertexAttribute::POSITION, 0,
        VertexBuffer::AttributeType::FLOAT3)
    .attribute(VertexAttribute::TANGENTS, 1,
        VertexBuffer::AttributeType::SHORT4)
    .normalized(VertexAttribute::TANGENTS)
    .build(*engine);

vertexBuffer->setBufferAt(*engine, 0,
    VertexBuffer::BufferDescriptor(vertices, sizeof(vertices)));
vertexBuffer->setBufferAt(*engine, 1,
    VertexBuffer::BufferDescriptor(normals, sizeof(normals)));

IndexBuffer* indexBuffer = IndexBuffer::Builder()
    .indexCount(6)
    .build(*engine);

indexBuffer->setBuffer(*engine,
    IndexBuffer::BufferDescriptor(indices, sizeof(indices)));

// Create shared buffer object
BufferObject* bufferObject = BufferObject::Builder()
    .size(bufferSize)
    .build(*engine);

bufferObject->setBuffer(*engine,
    BufferObject::BufferDescriptor(data, bufferSize));

// Enable buffer objects mode
VertexBuffer* vb = VertexBuffer::Builder()
    .vertexCount(count)
    .bufferCount(1)
    .enableBufferObjects(true)
    .attribute(VertexAttribute::POSITION, 0,
        VertexBuffer::AttributeType::FLOAT3)
    .build(*engine);

// Use buffer object instead of direct data
vb->setBufferObjectAt(*engine, 0, bufferObject);

auto callback = [](VertexBuffer* vb, void* user) {
    std::cout << "Buffer updated!" << std::endl;
};

vb->setBufferAtAsync(*engine, 0, 
    VertexBuffer::BufferDescriptor(newData, size),
    0, nullptr, callback, nullptr);