int main(int argc,char *argv[])
{
gtk_init(&argc,&argv);
initialize();
signals();
packing();
gtk_widget_show_all(window);
gtk_main();
}
int Msg_util::err_packing(const char* err_info, char* msg)
{
Msg_field fields((char*) "ERR", (char*) "", (char*) "", err_info);
return packing(&fields, msg);
}
void Map::update_tile(int x_pos, int y_pos, const std::string layer_name, const std::string tile_name) {
int tile_id = -1;
std::shared_ptr<TileSet> tileset;
for (std::shared_ptr<TileSet> tileset_i : tilesets) {
try {
tile_id = tileset_i->get_atlas()->get_name_index(tile_name);
tileset = tileset_i;
break;
} catch (std::exception) {
continue;
}
}
if (tile_id == -1) {
// Tile not found.
throw std::runtime_error("Tile not found: " + tile_name);
}
// Build the data for the update
GLfloat *data;
size_t data_size(sizeof(GLfloat) * num_tile_dimensions * num_tile_vertices);
// Get a buffer for the data
try {
data = new GLfloat[data_size];
}
catch(std::bad_alloc& ba) {
LOG(ERROR) << "Couldn't allocate memory in Map::update_tile";
return;
}
// Get the texture coordinates for this tile
// GLfloat *tileset_ptr = &tileset_tex_coords[(tile_id)*8]; //*8 as 8 coordinates per tile
std::tuple<float,float,float,float> coords(tileset->get_atlas()->index_to_coords(tile_id));
//bottom left
data[0] = std::get<0>(coords);
data[1] = std::get<2>(coords);
//top left
data[2] = std::get<0>(coords);
data[3] = std::get<3>(coords);
//bottom right
data[4] = std::get<1>(coords);
data[5] = std::get<2>(coords);
//top left
data[6] = std::get<0>(coords);
data[7] = std::get<3>(coords);
//top right
data[8] = std::get<1>(coords);
data[9] = std::get<3>(coords);
//bottom right
data[10] = std::get<1>(coords);
data[11] = std::get<2>(coords);
// Find the layer from the layer name name.
std::shared_ptr<Layer> layer;
int layer_num;
for (unsigned int i = 0; i < layer_ids.size(); i++) {
std::shared_ptr<Layer> layer_test(ObjectManager::get_instance().get_object<Layer>(layer_ids[i]));
if (layer_test->get_name() == layer_name) {
layer = layer_test;
layer_num = i;
break;
}
}
if (!layer) {
throw std::runtime_error("Layer not found: " + layer_name);
}
// Put it into the buffers
Layer::Packing packing(layer->get_packing());
// Add this tile to the layer data structure
layer->update_tile(x_pos, y_pos, tile_id, tileset);
int tile_offset;
// Perform O(1) update. no need to do mapping changes
if (packing == Layer::Packing::DENSE) {
tile_offset = y_pos * map_width + x_pos;
// Update the buffer
// Just update that tile directly
RenderableComponent *renderable_component(layer->get_renderable_component());
renderable_component->update_texture_buffer(
sizeof(GLfloat) * tile_offset * num_tile_vertices * num_tile_dimensions,
data_size,
data
);
}
else {
// TODO: create a small buffer to hold these updates rather than rebuilding the entire buffer
// Generate the new tile's data
GLfloat* vertex_data = nullptr;
// Get a buffer for the data
try {
vertex_data = new GLfloat[data_size];
}
catch(std::bad_alloc& ba) {
LOG(ERROR) << "Couldn't allocate memory in Map::update_tile";
data = nullptr;
return;
}
// Set the needed data
// bottom left
vertex_data[0] = float(x_pos);
vertex_data[1] = float(y_pos);
// top left
vertex_data[2] = float(x_pos);
vertex_data[3] = float(y_pos + 1);
// bottom right
vertex_data[4] = float(x_pos + 1);
vertex_data[5] = float(y_pos);
// top left
vertex_data[6] = float(x_pos);
vertex_data[7] = float(y_pos + 1);
// top right
vertex_data[8] = float(x_pos + 1);
vertex_data[9] = float(y_pos + 1);
// bottom right
vertex_data[10] = float(x_pos + 1);
vertex_data[11] = float(y_pos);
// Fetch the offset from the data buffer
// Tile offset in floats
int offset((*layer_mappings[layer_num])[y_pos*map_width + x_pos]);
// Recalculate the layer mappings
bool overwrite(recalculate_layer_mappings(x_pos, y_pos, layer_num));
// TODO: small buffer
// Get the data
RenderableComponent* layer_renderable_component(layer->get_renderable_component());
GLfloat* layer_texture_data(layer_renderable_component->get_texture_coords_data());
GLfloat* layer_vertex_data (layer_renderable_component->get_vertex_data());
size_t texture_data_size(layer_renderable_component->get_texture_coords_data_size());
size_t vertex_data_size (layer_renderable_component->get_vertex_data_size());
if (overwrite) {
// We just need to overwrite the tile
// Update the buffer
// Just update that tile directly
layer_renderable_component->update_texture_buffer(offset*sizeof(GLfloat), data_size, data);
}
else {
// We need to insert the tile: expand the buffers
//Generate the new buffers
GLfloat *new_texture_data;
GLfloat *new_vertex_data;
int new_texture_data_size(int(texture_data_size + data_size));
int new_vertex_data_size (int( vertex_data_size + data_size));
try {
new_texture_data = new GLfloat[new_texture_data_size];
new_vertex_data = new GLfloat[new_vertex_data_size];
}
catch(std::bad_alloc& ba) {
LOG(ERROR) << "Couldn't allocate memory for new texture and vertex buffers in Map::update_tile";
return;
}
//Copy the first part of the original data
int data_length(num_tile_vertices * num_tile_dimensions);
std::copy(layer_vertex_data, &layer_vertex_data[offset], new_vertex_data);
std::copy(layer_texture_data, &layer_texture_data[offset], new_texture_data);
//Insert the new data into the correct position
std::copy(vertex_data, &vertex_data[data_length], &new_vertex_data[offset]);
std::copy(data, &data[data_length], &new_texture_data[offset]);
//Copy the rest of the original data
std::copy(&layer_vertex_data[offset], &layer_vertex_data[vertex_data_size], &new_vertex_data[offset + data_length]);
std::copy(&layer_texture_data[offset], &layer_texture_data[texture_data_size], &new_texture_data[offset + data_length]);
//Set the new data
layer_renderable_component->set_vertex_data(new_vertex_data, new_vertex_data_size, false);
layer_renderable_component->set_num_vertices_render(new_texture_data_size / (int(sizeof(GLfloat)) * num_tile_dimensions));
layer_renderable_component->set_texture_coords_data(new_texture_data, new_texture_data_size, false);
}
delete[] vertex_data;
}
delete[] data;
}
