Serializer Class Reference

#include <Serializer.h>

Collaboration diagram for Serializer:

Static Public Member Functions
static void	serializeInt (std::vector< unsigned char > &buffer, int value)
static void	serializeFloat (std::vector< unsigned char > &buffer, float value)
static void	serializeBool (std::vector< unsigned char > &buffer, bool value)
static void	serializeString (std::vector< unsigned char > &buffer, const std::string &str)
static void	serializeVec2 (std::vector< unsigned char > &buffer, const glm::vec2 &vec)
static void	serializeUInt64 (std::vector< unsigned char > &buffer, uint64_t value)
static void	serializeUInt32 (std::vector< unsigned char > &buffer, uint32_t value)
static void	serializeUInt8 (std::vector< unsigned char > &buffer, uint8_t value)
static int	deserializeInt (const std::vector< unsigned char > &buffer, size_t &offset)
static float	deserializeFloat (const std::vector< unsigned char > &buffer, size_t &offset)
static bool	deserializeBool (const std::vector< unsigned char > &buffer, size_t &offset)
static std::string	deserializeString (const std::vector< unsigned char > &buffer, size_t &offset)
static glm::vec2	deserializeVec2 (const std::vector< unsigned char > &buffer, size_t &offset)
static uint64_t	deserializeUInt64 (const std::vector< unsigned char > &buffer, size_t &offset)
static uint32_t	deserializeUInt32 (const std::vector< unsigned char > &buffer, size_t &offset)
static uint8_t	deserializeUInt8 (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializePosition (std::vector< unsigned char > &buffer, const Position *position)
static Position	deserializePosition (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeSize (std::vector< unsigned char > &buffer, const Size *size)
static Size	deserializeSize (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeVisibility (std::vector< unsigned char > &buffer, const Visibility *visibility)
static Visibility	deserializeVisibility (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeMoving (std::vector< unsigned char > &buffer, const Moving *moving)
static Moving	deserializeMoving (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeTextureComponent (std::vector< unsigned char > &buffer, const TextureComponent *texture)
static TextureComponent	deserializeTextureComponent (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializePanning (std::vector< unsigned char > &buffer, const Panning *panning)
static Panning	deserializePanning (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeGrid (std::vector< unsigned char > &buffer, const Grid *grid)
static Grid	deserializeGrid (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeMarkerComponent (std::vector< unsigned char > &buffer, const MarkerComponent *marker_component)
static MarkerComponent	deserializeMarkerComponent (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeBoard (std::vector< unsigned char > &buffer, const Board *board)
static Board	deserializeBoard (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeGameTable (std::vector< unsigned char > &buffer, const GameTable *gameTable)
static GameTable	deserializeGameTable (const std::vector< unsigned char > &buffer, size_t &offset)
static void	serializeMarkerEntity (std::vector< unsigned char > &buffer, const flecs::entity entity, flecs::world &ecs)
static flecs::entity	deserializeMarkerEntity (const std::vector< unsigned char > &buffer, size_t &offset, flecs::world &ecs)
static void	serializeFogEntity (std::vector< unsigned char > &buffer, const flecs::entity entity, flecs::world &ecs)
static flecs::entity	deserializeFogEntity (const std::vector< unsigned char > &buffer, size_t &offset, flecs::world &ecs)
static void	serializeGameTableEntity (std::vector< unsigned char > &buffer, const flecs::entity entity, flecs::world &ecs)
static flecs::entity	deserializeGameTableEntity (const std::vector< unsigned char > &buffer, size_t &offset, flecs::world &ecs)
static void	serializeBoardEntity (std::vector< unsigned char > &buffer, const flecs::entity entity, flecs::world &ecs)
static flecs::entity	deserializeBoardEntity (const std::vector< unsigned char > &buffer, size_t &offset, flecs::world &ecs)

Detailed Description

Definition at line 10 of file Serializer.h.

Member Function Documentation

deserializeBoard()

Board Serializer::deserializeBoard ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 510 of file Serializer.h.

{
    std::string board_name = deserializeString(buffer, offset);
    return Board{board_name};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeBoardEntity()

flecs::entity Serializer::deserializeBoardEntity ( const std::vector< unsigned char > & buffer, size_t & offset, flecs::world & ecs )

inlinestatic

Definition at line 244 of file Serializer.h.

{
 
    uint64_t board_id = Serializer::deserializeUInt64(buffer, offset);
    auto boardData = Serializer::deserializeBoard(buffer, offset);
    auto panning = Serializer::deserializePanning(buffer, offset);
    auto grid = Serializer::deserializeGrid(buffer, offset);
    auto texture = Serializer::deserializeTextureComponent(buffer, offset);
    auto size = Serializer::deserializeSize(buffer, offset);
 
    auto newBoard = ecs.entity()
                        .set<Identifier>({board_id})
                        .set<Board>(boardData)
                        .set<Panning>(panning)
                        .set<Grid>(grid)
                        .set<TextureComponent>({0, texture.image_path, texture.size})
                        .set<Size>(size);
 
    // Deserialize markers
    int markerCount = Serializer::deserializeInt(buffer, offset);
    for (int i = 0; i < markerCount; ++i)
    {
        auto marker = deserializeMarkerEntity(buffer, offset, ecs);
        marker.add<MarkerComponent>();
        marker.add(flecs::ChildOf, newBoard);
    }
 
    // Deserialize fog entities
    int fogCount = Serializer::deserializeInt(buffer, offset);
    for (int i = 0; i < fogCount; ++i)
    {
        auto fog = deserializeFogEntity(buffer, offset, ecs);
        fog.add<FogOfWar>();
        fog.add(flecs::ChildOf, newBoard);
    }
 
    return newBoard;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeBool()

bool Serializer::deserializeBool ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 381 of file Serializer.h.

{
    bool value = buffer[offset] != 0;
    offset += sizeof(unsigned char);
    return value;
}

Here is the caller graph for this function:

deserializeFloat()

float Serializer::deserializeFloat ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 374 of file Serializer.h.

{
    float value = *reinterpret_cast<const float*>(&buffer[offset]);
    offset += sizeof(float);
    return value;
}

Here is the caller graph for this function:

deserializeFogEntity()

flecs::entity Serializer::deserializeFogEntity ( const std::vector< unsigned char > & buffer, size_t & offset, flecs::world & ecs )

inlinestatic

Definition at line 133 of file Serializer.h.

{
 
    uint64_t fog_id = Serializer::deserializeUInt64(buffer, offset);
    auto position = deserializePosition(buffer, offset);
    auto size = deserializeSize(buffer, offset);
    auto visibility = deserializeVisibility(buffer, offset);
 
    auto fog = ecs.entity()
                   .set<Identifier>({fog_id})
                   .set<Position>(position)
                   .set<Size>(size)
                   .set<Visibility>(visibility);
 
    return fog;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeGameTable()

GameTable Serializer::deserializeGameTable ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 522 of file Serializer.h.

{
    std::string gameTableName = deserializeString(buffer, offset);
    return GameTable{gameTableName};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeGameTableEntity()

flecs::entity Serializer::deserializeGameTableEntity ( const std::vector< unsigned char > & buffer, size_t & offset, flecs::world & ecs )

inlinestatic

Definition at line 174 of file Serializer.h.

{
    //auto game_table_id = deserializeInt(buffer, offset);
    auto identifier = deserializeUInt64(buffer, offset);
    auto game_table = deserializeGameTable(buffer, offset);
    auto game_table_entity = ecs.entity().set(GameTable{game_table});
    game_table_entity.set(Identifier{identifier});
 
    int board_count = Serializer::deserializeInt(buffer, offset);
    for (int i = 1; i <= board_count; i++)
    {
        auto board_entity = deserializeBoardEntity(buffer, offset, ecs);
        board_entity.add(flecs::ChildOf, game_table_entity);
    }
 
    return game_table_entity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeGrid()

Grid Serializer::deserializeGrid ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 492 of file Serializer.h.

{
    glm::vec2 offset_val = deserializeVec2(buffer, offset);
    float cell_size = deserializeFloat(buffer, offset);
    bool is_hex = deserializeBool(buffer, offset);
    bool snap_to_grid = deserializeBool(buffer, offset);
    bool visible = deserializeBool(buffer, offset);
    float opacity = deserializeFloat(buffer, offset);
 
    return Grid{offset_val, cell_size, is_hex, snap_to_grid, visible, opacity};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeInt()

int Serializer::deserializeInt ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 367 of file Serializer.h.

{
    int value = *reinterpret_cast<const int*>(&buffer[offset]);
    offset += sizeof(int);
    return value;
}

Here is the caller graph for this function:

deserializeMarkerComponent()

MarkerComponent Serializer::deserializeMarkerComponent ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 292 of file Serializer.h.

{
    MarkerComponent marker_component{};
    marker_component.ownerPeerUsername = deserializeString(b, off);
    marker_component.ownerUniqueId = deserializeString(b, off);
    marker_component.allowAllPlayersMove = deserializeBool(b, off);
    marker_component.locked = deserializeBool(b, off);
    return marker_component;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeMarkerEntity()

flecs::entity Serializer::deserializeMarkerEntity ( const std::vector< unsigned char > & buffer, size_t & offset, flecs::world & ecs )

inlinestatic

Definition at line 97 of file Serializer.h.

{
 
    uint64_t marker_id = Serializer::deserializeUInt64(buffer, offset);
    auto position = deserializePosition(buffer, offset);
    auto size = deserializeSize(buffer, offset);
    auto moving = deserializeMoving(buffer, offset);
    auto visibility = deserializeVisibility(buffer, offset);
    auto texture = deserializeTextureComponent(buffer, offset);
    auto marker_component = deserializeMarkerComponent(buffer, offset);
    auto marker = ecs.entity()
                      .set<Identifier>({marker_id})
                      .set<Position>(position)
                      .set<Size>(size)
                      .set<Moving>(moving)
                      .set<Visibility>(visibility)
                      .set<MarkerComponent>(marker_component)
                      .set<TextureComponent>({0, texture.image_path, texture.size});
 
    return marker;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeMoving()

Moving Serializer::deserializeMoving ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 447 of file Serializer.h.

{
    bool isDragging = deserializeBool(buffer, offset);
    return Moving{isDragging};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializePanning()

Panning Serializer::deserializePanning ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 475 of file Serializer.h.

{
    bool isPanning = deserializeBool(buffer, offset);
    return Panning{isPanning};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializePosition()

Position Serializer::deserializePosition ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 409 of file Serializer.h.

{
    float x = deserializeFloat(buffer, offset);
    float y = deserializeFloat(buffer, offset);
    return Position{x, y};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeSize()

Size Serializer::deserializeSize ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 422 of file Serializer.h.

{
    float width = deserializeFloat(buffer, offset);
    float height = deserializeFloat(buffer, offset);
    return Size{width, height};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeString()

std::string Serializer::deserializeString ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 388 of file Serializer.h.

{
    int length = deserializeInt(buffer, offset);
    std::string str(buffer.begin() + offset, buffer.begin() + offset + length);
    offset += length;
    return str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeTextureComponent()

TextureComponent Serializer::deserializeTextureComponent ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 461 of file Serializer.h.

{
    GLuint textureID = static_cast<GLuint>(deserializeInt(buffer, offset));
    std::string image_path = deserializeString(buffer, offset);
    glm::vec2 size = deserializeVec2(buffer, offset);
    return TextureComponent{0, image_path, size};
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeUInt32()

uint32_t Serializer::deserializeUInt32 ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 353 of file Serializer.h.

{
    uint32_t value = *reinterpret_cast<const uint32_t*>(&buffer[offset]);
    offset += sizeof(uint32_t);
    return value;
}

Here is the caller graph for this function:

deserializeUInt64()

uint64_t Serializer::deserializeUInt64 ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 360 of file Serializer.h.

{
    uint64_t value = *reinterpret_cast<const uint64_t*>(&buffer[offset]);
    offset += sizeof(uint64_t);
    return value;
}

Here is the caller graph for this function:

deserializeUInt8()

uint8_t Serializer::deserializeUInt8 ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 346 of file Serializer.h.

{
    uint8_t v = static_cast<uint8_t>(buffer[offset]);
    offset += sizeof(uint8_t);
    return v;
}

Here is the caller graph for this function:

deserializeVec2()

glm::vec2 Serializer::deserializeVec2 ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 396 of file Serializer.h.

{
    float x = deserializeFloat(buffer, offset);
    float y = deserializeFloat(buffer, offset);
    return glm::vec2(x, y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

deserializeVisibility()

Visibility Serializer::deserializeVisibility ( const std::vector< unsigned char > & buffer, size_t & offset )

inlinestatic

Definition at line 435 of file Serializer.h.

{
    bool isVisible = deserializeBool(buffer, offset);
    return Visibility{isVisible};
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeBoard()

void Serializer::serializeBoard ( std::vector< unsigned char > & buffer, const Board * board )

inlinestatic

Definition at line 505 of file Serializer.h.

{
    serializeString(buffer, board->board_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeBoardEntity()

void Serializer::serializeBoardEntity ( std::vector< unsigned char > & buffer, const flecs::entity entity, flecs::world & ecs )

inlinestatic

Definition at line 192 of file Serializer.h.

{
    auto identifier = entity.get<Identifier>();
    auto boardData = entity.get<Board>();
    auto panning = entity.get<Panning>();
    auto grid = entity.get<Grid>();
    auto texture = entity.get<TextureComponent>();
    auto size = entity.get<Size>();
 
    Serializer::serializeUInt64(buffer, identifier->id);
    Serializer::serializeBoard(buffer, boardData);
    Serializer::serializePanning(buffer, panning);
    Serializer::serializeGrid(buffer, grid);
    Serializer::serializeTextureComponent(buffer, texture);
    Serializer::serializeSize(buffer, size);
 
    // Serialize markers
    int markerCount = 0;
    ecs.defer_begin();
    entity.children([&](flecs::entity child)
                    {
        if (child.has<MarkerComponent>()) {
            markerCount++;
        } });
    Serializer::serializeInt(buffer, markerCount);
    // Serialize each marker's data
    entity.children([&](flecs::entity child)
                    {
        if (child.has<MarkerComponent>()) {
            serializeMarkerEntity(buffer, child, ecs);
        } });
    ecs.defer_end();
    // Serialize fog entities
    int fogCount = 0;
    ecs.defer_begin();
    entity.children([&](flecs::entity child)
                    {
        if (child.has<FogOfWar>()) {
            fogCount++;
        } });
    ecs.defer_end();
    Serializer::serializeInt(buffer, fogCount);
    // Serialize each fog's data
    ecs.defer_begin();
    entity.children([&](flecs::entity child)
                    {
        if (child.has<FogOfWar>()) {
            serializeFogEntity(buffer, child, ecs);
        } });
    ecs.defer_end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeBool()

void Serializer::serializeBool ( std::vector< unsigned char > & buffer, bool value )

inlinestatic

Definition at line 312 of file Serializer.h.

{
    unsigned char byteValue = value ? 1 : 0;
    buffer.push_back(byteValue);
}

Here is the caller graph for this function:

serializeFloat()

void Serializer::serializeFloat ( std::vector< unsigned char > & buffer, float value )

inlinestatic

Definition at line 307 of file Serializer.h.

{
    buffer.insert(buffer.end(), reinterpret_cast<unsigned char*>(&value), reinterpret_cast<unsigned char*>(&value) + sizeof(float));
}

Here is the caller graph for this function:

serializeFogEntity()

void Serializer::serializeFogEntity ( std::vector< unsigned char > & buffer, const flecs::entity entity, flecs::world & ecs )

inlinestatic

Definition at line 120 of file Serializer.h.

{
    auto identifier = entity.get<Identifier>();
    auto position = entity.get<Position>();
    auto size = entity.get<Size>();
    auto visibility = entity.get<Visibility>();
 
    serializeUInt64(buffer, identifier->id);
    serializePosition(buffer, position);
    serializeSize(buffer, size);
    serializeVisibility(buffer, visibility);
}

Here is the call graph for this function:

serializeGameTable()

void Serializer::serializeGameTable ( std::vector< unsigned char > & buffer, const GameTable * gameTable )

inlinestatic

Definition at line 517 of file Serializer.h.

{
    serializeString(buffer, gameTable->gameTableName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeGameTableEntity()

void Serializer::serializeGameTableEntity ( std::vector< unsigned char > & buffer, const flecs::entity entity, flecs::world & ecs )

inlinestatic

Definition at line 150 of file Serializer.h.

{
    auto identifier = entity.get<Identifier>();
    auto game_table = entity.get<GameTable>();
    //auto game_table_id = entity.id();
 
    serializeUInt64(buffer, identifier->id);
    serializeGameTable(buffer, game_table);
 
    int boardCount = 0;
    ecs.defer_begin();
    entity.children([&](flecs::entity child)
                    {
        if (child.has<Board>()) {
            boardCount++;
        } });
    ecs.defer_end();
    Serializer::serializeInt(buffer, boardCount);
    ecs.defer_begin();
    entity.children([&](flecs::entity child)
                    { serializeBoardEntity(buffer, child, ecs); });
    ecs.defer_end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeGrid()

void Serializer::serializeGrid ( std::vector< unsigned char > & buffer, const Grid * grid )

inlinestatic

Definition at line 482 of file Serializer.h.

{
    serializeVec2(buffer, grid->offset);
    serializeFloat(buffer, grid->cell_size);
    serializeBool(buffer, grid->is_hex);
    serializeBool(buffer, grid->snap_to_grid);
    serializeBool(buffer, grid->visible);
    serializeFloat(buffer, grid->opacity);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeInt()

void Serializer::serializeInt ( std::vector< unsigned char > & buffer, int value )

inlinestatic

Definition at line 302 of file Serializer.h.

{
    buffer.insert(buffer.end(), reinterpret_cast<unsigned char*>(&value), reinterpret_cast<unsigned char*>(&value) + sizeof(int));
}

Here is the caller graph for this function:

serializeMarkerComponent()

void Serializer::serializeMarkerComponent ( std::vector< unsigned char > & buffer, const MarkerComponent * marker_component )

inlinestatic

Definition at line 284 of file Serializer.h.

{
    serializeString(b, marker_component->ownerPeerUsername);
    serializeString(b, marker_component->ownerUniqueId);
    serializeBool(b, marker_component->allowAllPlayersMove);
    serializeBool(b, marker_component->locked);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeMarkerEntity()

void Serializer::serializeMarkerEntity ( std::vector< unsigned char > & buffer, const flecs::entity entity, flecs::world & ecs )

inlinestatic

Definition at line 78 of file Serializer.h.

{
    auto identifier = entity.get<Identifier>();
    auto position = entity.get<Position>();
    auto size = entity.get<Size>();
    auto texture = entity.get<TextureComponent>();
    auto visibility = entity.get<Visibility>();
    auto moving = entity.get<Moving>();
    auto marker_component = entity.get<MarkerComponent>();
 
    serializeUInt64(buffer, identifier->id);
    serializePosition(buffer, position);
    serializeSize(buffer, size);
    serializeMoving(buffer, moving);
    serializeVisibility(buffer, visibility);
    serializeTextureComponent(buffer, texture);
    serializeMarkerComponent(buffer, marker_component);
}

Here is the call graph for this function:

serializeMoving()

void Serializer::serializeMoving ( std::vector< unsigned char > & buffer, const Moving * moving )

inlinestatic

Definition at line 442 of file Serializer.h.

{
    serializeBool(buffer, moving->isDragging);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializePanning()

void Serializer::serializePanning ( std::vector< unsigned char > & buffer, const Panning * panning )

inlinestatic

Definition at line 470 of file Serializer.h.

{
    serializeBool(buffer, panning->isPanning);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializePosition()

void Serializer::serializePosition ( std::vector< unsigned char > & buffer, const Position * position )

inlinestatic

Definition at line 403 of file Serializer.h.

{
    serializeFloat(buffer, position->x);
    serializeFloat(buffer, position->y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeSize()

void Serializer::serializeSize ( std::vector< unsigned char > & buffer, const Size * size )

inlinestatic

Definition at line 416 of file Serializer.h.

{
    serializeFloat(buffer, size->width);
    serializeFloat(buffer, size->height);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeString()

void Serializer::serializeString ( std::vector< unsigned char > & buffer, const std::string & str )

inlinestatic

Definition at line 318 of file Serializer.h.

{
    int length = static_cast<int>(str.size());
    serializeInt(buffer, length);
    buffer.insert(buffer.end(), str.begin(), str.end());
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeTextureComponent()

void Serializer::serializeTextureComponent ( std::vector< unsigned char > & buffer, const TextureComponent * texture )

inlinestatic

Definition at line 454 of file Serializer.h.

{
    serializeInt(buffer, static_cast<int>(texture->textureID));
    serializeString(buffer, texture->image_path);
    serializeVec2(buffer, texture->size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeUInt32()

void Serializer::serializeUInt32 ( std::vector< unsigned char > & buffer, uint32_t value )

inlinestatic

Definition at line 336 of file Serializer.h.

{
    buffer.insert(buffer.end(), reinterpret_cast<unsigned char*>(&value), reinterpret_cast<unsigned char*>(&value) + sizeof(uint32_t));
}

Here is the caller graph for this function:

serializeUInt64()

void Serializer::serializeUInt64 ( std::vector< unsigned char > & buffer, uint64_t value )

inlinestatic

Definition at line 331 of file Serializer.h.

{
    buffer.insert(buffer.end(), reinterpret_cast<unsigned char*>(&value), reinterpret_cast<unsigned char*>(&value) + sizeof(uint64_t));
}

Here is the caller graph for this function:

serializeUInt8()

void Serializer::serializeUInt8 ( std::vector< unsigned char > & buffer, uint8_t value )

inlinestatic

Definition at line 341 of file Serializer.h.

{
    buffer.push_back(static_cast<unsigned char>(value));
}

Here is the caller graph for this function:

serializeVec2()

void Serializer::serializeVec2 ( std::vector< unsigned char > & buffer, const glm::vec2 & vec )

inlinestatic

Definition at line 325 of file Serializer.h.

{
    serializeFloat(buffer, vec.x);
    serializeFloat(buffer, vec.y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVisibility()

void Serializer::serializeVisibility ( std::vector< unsigned char > & buffer, const Visibility * visibility )

inlinestatic

Definition at line 430 of file Serializer.h.

{
    serializeBool(buffer, visibility->isVisible);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• include/network/Serializer.h