Port ScreenEditor to use Tilemap, remove Tilesheet class
This commit is contained in:
scawful
@@ -9,5 +9,4 @@ set(
|
||||
app/gfx/snes_tile.cc
|
||||
app/gfx/snes_color.cc
|
||||
app/gfx/tilemap.cc
|
||||
app/gfx/tilesheet.cc
|
||||
)
|
||||
@@ -1,176 +0,0 @@
|
||||
#include "app/gfx/tilesheet.h"
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "app/gfx/bitmap.h"
|
||||
#include "app/gfx/snes_tile.h"
|
||||
|
||||
namespace yaze {
|
||||
namespace gfx {
|
||||
|
||||
void Tilesheet::Init(int width, int height, TileType tile_type) {
|
||||
internal_data_.resize(0x20000);
|
||||
bitmap_ = std::make_shared<Bitmap>(width, height, 8, internal_data_);
|
||||
tile_type_ = tile_type;
|
||||
if (tile_type_ == TileType::Tile8) {
|
||||
tile_width_ = 8;
|
||||
tile_height_ = 8;
|
||||
} else {
|
||||
tile_width_ = 16;
|
||||
tile_height_ = 16;
|
||||
}
|
||||
}
|
||||
|
||||
void Tilesheet::ComposeTile16(const std::vector<uint8_t>& graphics_buffer,
|
||||
const TileInfo& top_left,
|
||||
const TileInfo& top_right,
|
||||
const TileInfo& bottom_left,
|
||||
const TileInfo& bottom_right, int sheet_offset) {
|
||||
sheet_offset_ = sheet_offset;
|
||||
// Calculate the base position for this Tile16 in the full-size bitmap
|
||||
int tiles_per_row = bitmap_->width() / tile_width_;
|
||||
int tile16_row = num_tiles_ / tiles_per_row;
|
||||
int tile16_column = num_tiles_ % tiles_per_row;
|
||||
int base_x = tile16_column * tile_width_;
|
||||
int base_y = tile16_row * tile_height_;
|
||||
|
||||
// Compose and place each part of the Tile16
|
||||
ComposeAndPlaceTilePart(graphics_buffer, top_left, base_x, base_y);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, top_right, base_x + 8, base_y);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, bottom_left, base_x, base_y + 8);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, bottom_right, base_x + 8,
|
||||
base_y + 8);
|
||||
|
||||
tile_info_.push_back({top_left, top_right, bottom_left, bottom_right});
|
||||
|
||||
num_tiles_++;
|
||||
}
|
||||
|
||||
void Tilesheet::ModifyTile16(const std::vector<uint8_t>& graphics_buffer,
|
||||
const TileInfo& top_left,
|
||||
const TileInfo& top_right,
|
||||
const TileInfo& bottom_left,
|
||||
const TileInfo& bottom_right, int tile_id,
|
||||
int sheet_offset) {
|
||||
sheet_offset_ = sheet_offset;
|
||||
// Calculate the base position for this Tile16 in the full-size bitmap
|
||||
int tiles_per_row = bitmap_->width() / tile_width_;
|
||||
int tile16_row = tile_id / tiles_per_row;
|
||||
int tile16_column = tile_id % tiles_per_row;
|
||||
int base_x = tile16_column * tile_width_;
|
||||
int base_y = tile16_row * tile_height_;
|
||||
|
||||
// Compose and place each part of the Tile16
|
||||
ComposeAndPlaceTilePart(graphics_buffer, top_left, base_x, base_y);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, top_right, base_x + 8, base_y);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, bottom_left, base_x, base_y + 8);
|
||||
ComposeAndPlaceTilePart(graphics_buffer, bottom_right, base_x + 8,
|
||||
base_y + 8);
|
||||
|
||||
tile_info_[tile_id] = {top_left, top_right, bottom_left, bottom_right};
|
||||
}
|
||||
|
||||
void Tilesheet::ComposeAndPlaceTilePart(
|
||||
const std::vector<uint8_t>& graphics_buffer, const TileInfo& tile_info,
|
||||
int base_x, int base_y) {
|
||||
std::vector<uint8_t> tile_data =
|
||||
FetchTileDataFromGraphicsBuffer(graphics_buffer, tile_info.id_);
|
||||
|
||||
if (tile_info.vertical_mirror_) {
|
||||
MirrorTileDataVertically(tile_data);
|
||||
}
|
||||
if (tile_info.horizontal_mirror_) {
|
||||
MirrorTileDataHorizontally(tile_data);
|
||||
}
|
||||
|
||||
// Place the tile data into the full-size bitmap at the calculated position
|
||||
for (int y = 0; y < 8; ++y) {
|
||||
for (int x = 0; x < 8; ++x) {
|
||||
int src_index = y * 8 + x;
|
||||
int dest_x = base_x + x;
|
||||
int dest_y = base_y + y;
|
||||
int dest_index = (dest_y * bitmap_->width()) + dest_x;
|
||||
internal_data_[dest_index] = tile_data[src_index];
|
||||
}
|
||||
}
|
||||
|
||||
bitmap_->set_data(internal_data_);
|
||||
}
|
||||
|
||||
std::vector<uint8_t> Tilesheet::FetchTileDataFromGraphicsBuffer(
|
||||
const std::vector<uint8_t>& graphics_buffer, int tile_id) {
|
||||
const int tile_width = 8;
|
||||
const int tile_height = 8;
|
||||
const int buffer_width = 128;
|
||||
const int sheet_height = 32;
|
||||
|
||||
const int tiles_per_row = buffer_width / tile_width;
|
||||
const int rows_per_sheet = sheet_height / tile_height;
|
||||
const int tiles_per_sheet = tiles_per_row * rows_per_sheet;
|
||||
|
||||
// Calculate the position in the graphics_buffer_ based on tile_id
|
||||
std::vector<uint8_t> tile_data(0x40, 0x00);
|
||||
int sheet = (tile_id / tiles_per_sheet) % 4 + sheet_offset_;
|
||||
int position_in_sheet = tile_id % tiles_per_sheet;
|
||||
int row_in_sheet = position_in_sheet / tiles_per_row;
|
||||
int column_in_sheet = position_in_sheet % tiles_per_row;
|
||||
|
||||
// Ensure that the sheet ID is between 212 and 215 if using full gfx buffer
|
||||
assert(sheet >= sheet_offset_ && sheet <= sheet_offset_ + 3);
|
||||
|
||||
// Copy the tile data from the graphics_buffer_ to tile_data
|
||||
for (int y = 0; y < 8; ++y) {
|
||||
for (int x = 0; x < 8; ++x) {
|
||||
// Calculate the position in the graphics_buffer_ based on tile_id
|
||||
int src_x = column_in_sheet * tile_width + x;
|
||||
int src_y = (sheet * sheet_height) + (row_in_sheet * tile_height) + y;
|
||||
|
||||
int src_index = (src_y * buffer_width) + src_x;
|
||||
int dest_index = y * tile_width + x;
|
||||
|
||||
tile_data[dest_index] = graphics_buffer[src_index];
|
||||
}
|
||||
}
|
||||
|
||||
return tile_data;
|
||||
}
|
||||
|
||||
void Tilesheet::MirrorTileDataVertically(std::vector<uint8_t>& tile_data) {
|
||||
std::vector<uint8_t> tile_data_copy = tile_data;
|
||||
for (int i = 0; i < 8; ++i) { // For each row
|
||||
for (int j = 0; j < 8; ++j) { // For each column
|
||||
int src_index = i * 8 + j;
|
||||
int dest_index = (7 - i) * 8 + j; // Calculate the mirrored row
|
||||
tile_data_copy[dest_index] = tile_data[src_index];
|
||||
}
|
||||
}
|
||||
tile_data = tile_data_copy;
|
||||
}
|
||||
|
||||
void Tilesheet::MirrorTileDataHorizontally(std::vector<uint8_t>& tile_data) {
|
||||
std::vector<uint8_t> tile_data_copy = tile_data;
|
||||
for (int i = 0; i < 8; ++i) { // For each row
|
||||
for (int j = 0; j < 8; ++j) { // For each column
|
||||
int src_index = i * 8 + j;
|
||||
int dest_index = i * 8 + (7 - j); // Calculate the mirrored column
|
||||
tile_data_copy[dest_index] = tile_data[src_index];
|
||||
}
|
||||
}
|
||||
tile_data = tile_data_copy;
|
||||
}
|
||||
|
||||
void Tilesheet::MirrorTileData(std::vector<uint8_t>& tile_data, bool mirrorX,
|
||||
bool mirrorY) {
|
||||
std::vector tile_data_copy = tile_data;
|
||||
if (mirrorX) {
|
||||
MirrorTileDataHorizontally(tile_data_copy);
|
||||
}
|
||||
if (mirrorY) {
|
||||
MirrorTileDataVertically(tile_data_copy);
|
||||
}
|
||||
tile_data = tile_data_copy;
|
||||
}
|
||||
|
||||
} // namespace gfx
|
||||
} // namespace yaze
|
||||
@@ -1,133 +0,0 @@
|
||||
#ifndef YAZE_APP_GFX_TILESHEET_H
|
||||
#define YAZE_APP_GFX_TILESHEET_H
|
||||
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "app/gfx/bitmap.h"
|
||||
#include "app/gfx/snes_palette.h"
|
||||
#include "app/gfx/snes_tile.h"
|
||||
|
||||
namespace yaze {
|
||||
namespace gfx {
|
||||
|
||||
enum class TileType { Tile8, Tile16 };
|
||||
|
||||
struct InternalTile16 {
|
||||
std::array<TileInfo, 4> tiles;
|
||||
};
|
||||
|
||||
/**
|
||||
* @class Tilesheet
|
||||
* @brief Represents a tilesheet, which is a collection of tiles stored in a
|
||||
* bitmap.
|
||||
*
|
||||
* The Tilesheet class provides methods to manipulate and extract tiles from the
|
||||
* tilesheet. It also supports copying and mirroring tiles within the tilesheet.
|
||||
*/
|
||||
class Tilesheet {
|
||||
public:
|
||||
Tilesheet() = default;
|
||||
Tilesheet(std::shared_ptr<Bitmap> bitmap, int tileWidth, int tileHeight,
|
||||
TileType tile_type)
|
||||
: bitmap_(std::move(bitmap)),
|
||||
tile_width_(tileWidth),
|
||||
tile_height_(tileHeight),
|
||||
tile_type_(tile_type) {}
|
||||
|
||||
void Init(int width, int height, TileType tile_type);
|
||||
|
||||
void ComposeTile16(const std::vector<uint8_t>& graphics_buffer,
|
||||
const TileInfo& top_left, const TileInfo& top_right,
|
||||
const TileInfo& bottom_left, const TileInfo& bottom_right,
|
||||
int sheet_offset = 0);
|
||||
void ModifyTile16(const std::vector<uint8_t>& graphics_buffer,
|
||||
const TileInfo& top_left, const TileInfo& top_right,
|
||||
const TileInfo& bottom_left, const TileInfo& bottom_right,
|
||||
int tile_id, int sheet_offset = 0);
|
||||
|
||||
void ComposeAndPlaceTilePart(const std::vector<uint8_t>& graphics_buffer,
|
||||
const TileInfo& tile_info, int baseX, int baseY);
|
||||
|
||||
// Extracts a tile from the tilesheet
|
||||
Bitmap GetTile(int tileX, int tileY, int bmp_width, int bmp_height) {
|
||||
std::vector<uint8_t> tileData(tile_width_ * tile_height_);
|
||||
int tile_data_offset = 0;
|
||||
bitmap_->Get8x8Tile(CalculateTileIndex(tileX, tileY), tileX, tileY,
|
||||
tileData, tile_data_offset);
|
||||
return Bitmap(bmp_width, bmp_height, bitmap_->depth(), tileData);
|
||||
}
|
||||
|
||||
Bitmap GetTile16(int tile_id) {
|
||||
int tiles_per_row = bitmap_->width() / tile_width_;
|
||||
int tile_x = (tile_id % tiles_per_row) * tile_width_;
|
||||
int tile_y = (tile_id / tiles_per_row) * tile_height_;
|
||||
std::vector<uint8_t> tile_data(tile_width_ * tile_height_, 0x00);
|
||||
int tile_data_offset = 0;
|
||||
bitmap_->Get16x16Tile(tile_x, tile_y, tile_data, tile_data_offset);
|
||||
return Bitmap(16, 16, bitmap_->depth(), tile_data);
|
||||
}
|
||||
|
||||
// Copy a tile within the tilesheet
|
||||
void CopyTile(int srcX, int srcY, int destX, int destY, bool mirror_x = false,
|
||||
bool mirror_y = false) {
|
||||
auto src_tile = GetTile(srcX, srcY, tile_width_, tile_height_);
|
||||
auto dest_tile_data = src_tile.vector();
|
||||
MirrorTileData(dest_tile_data, mirror_x, mirror_y);
|
||||
WriteTile(destX, destY, dest_tile_data);
|
||||
}
|
||||
|
||||
auto bitmap() const { return bitmap_; }
|
||||
auto mutable_bitmap() { return bitmap_; }
|
||||
auto num_tiles() const { return num_tiles_; }
|
||||
auto tile_width() const { return tile_width_; }
|
||||
auto tile_height() const { return tile_height_; }
|
||||
auto set_palette(gfx::SnesPalette& palette) { palette_ = palette; }
|
||||
auto palette() const { return palette_; }
|
||||
auto tile_type() const { return tile_type_; }
|
||||
auto tile_info() const { return tile_info_; }
|
||||
auto mutable_tile_info() { return tile_info_; }
|
||||
void clear() {
|
||||
palette_.clear();
|
||||
internal_data_.clear();
|
||||
tile_info_.clear();
|
||||
bitmap_.reset();
|
||||
num_tiles_ = 0;
|
||||
}
|
||||
|
||||
private:
|
||||
int CalculateTileIndex(int x, int y) {
|
||||
return y * (bitmap_->width() / tile_width_) + x;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> FetchTileDataFromGraphicsBuffer(
|
||||
const std::vector<uint8_t>& graphics_buffer, int tile_id);
|
||||
|
||||
void MirrorTileDataVertically(std::vector<uint8_t>& tileData);
|
||||
void MirrorTileDataHorizontally(std::vector<uint8_t>& tileData);
|
||||
void MirrorTileData(std::vector<uint8_t>& tileData, bool mirror_x,
|
||||
bool mirror_y);
|
||||
|
||||
void WriteTile(int x, int y, const std::vector<uint8_t>& tileData) {
|
||||
int tileDataOffset = 0;
|
||||
bitmap_->Get8x8Tile(CalculateTileIndex(x, y), x, y,
|
||||
const_cast<std::vector<uint8_t>&>(tileData),
|
||||
tileDataOffset);
|
||||
}
|
||||
|
||||
int num_tiles_ = 0;
|
||||
int tile_width_ = 0;
|
||||
int tile_height_ = 0;
|
||||
int sheet_offset_ = 0;
|
||||
|
||||
TileType tile_type_;
|
||||
SnesPalette palette_;
|
||||
std::vector<uint8_t> internal_data_;
|
||||
std::vector<InternalTile16> tile_info_;
|
||||
std::shared_ptr<Bitmap> bitmap_;
|
||||
};
|
||||
|
||||
} // namespace gfx
|
||||
} // namespace yaze
|
||||
|
||||
#endif // YAZE_APP_GFX_TILESHEET_H
|
||||
Reference in New Issue
Block a user