2023-08-12 10:13:27 +00:00
|
|
|
#include "editor.h"
|
|
|
|
|
2023-08-28 15:55:29 +00:00
|
|
|
#include <game/editor/mapitems/image.h>
|
|
|
|
|
2023-08-12 10:13:27 +00:00
|
|
|
#include <array>
|
|
|
|
|
|
|
|
bool operator<(const ColorRGBA &Left, const ColorRGBA &Right)
|
|
|
|
{
|
|
|
|
if(Left.r != Right.r)
|
|
|
|
return Left.r < Right.r;
|
|
|
|
else if(Left.g != Right.g)
|
|
|
|
return Left.g < Right.g;
|
|
|
|
else if(Left.b != Right.b)
|
|
|
|
return Left.b < Right.b;
|
|
|
|
else
|
|
|
|
return Left.a < Right.a;
|
|
|
|
}
|
|
|
|
|
2023-04-27 15:15:48 +00:00
|
|
|
static ColorRGBA GetPixelColor(const CImageInfo &Image, size_t x, size_t y)
|
2023-08-12 10:13:27 +00:00
|
|
|
{
|
|
|
|
uint8_t *pData = static_cast<uint8_t *>(Image.m_pData);
|
2023-04-27 15:15:48 +00:00
|
|
|
const size_t PixelSize = Image.PixelSize();
|
|
|
|
const size_t PixelStartIndex = x * PixelSize + (Image.m_Width * PixelSize * y);
|
2023-08-12 10:13:27 +00:00
|
|
|
|
|
|
|
ColorRGBA Color = {255, 255, 255, 255};
|
2023-04-27 15:15:48 +00:00
|
|
|
if(PixelSize == 1)
|
2023-08-12 10:13:27 +00:00
|
|
|
{
|
|
|
|
Color.a = pData[PixelStartIndex];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Color.r = pData[PixelStartIndex + 0];
|
|
|
|
Color.g = pData[PixelStartIndex + 1];
|
|
|
|
Color.b = pData[PixelStartIndex + 2];
|
|
|
|
|
2023-04-27 15:15:48 +00:00
|
|
|
if(PixelSize == 4)
|
2023-08-12 10:13:27 +00:00
|
|
|
Color.a = pData[PixelStartIndex + 3];
|
|
|
|
}
|
|
|
|
|
|
|
|
return Color;
|
|
|
|
}
|
|
|
|
|
2023-04-27 15:15:48 +00:00
|
|
|
static void SetPixelColor(CImageInfo *pImage, size_t x, size_t y, ColorRGBA Color)
|
2023-08-12 10:13:27 +00:00
|
|
|
{
|
|
|
|
uint8_t *pData = static_cast<uint8_t *>(pImage->m_pData);
|
2023-04-27 15:15:48 +00:00
|
|
|
const size_t PixelSize = pImage->PixelSize();
|
|
|
|
const size_t PixelStartIndex = x * PixelSize + (pImage->m_Width * PixelSize * y);
|
2023-08-12 10:13:27 +00:00
|
|
|
|
2023-04-27 15:15:48 +00:00
|
|
|
if(PixelSize == 1)
|
2023-08-12 10:13:27 +00:00
|
|
|
{
|
|
|
|
pData[PixelStartIndex] = Color.a;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pData[PixelStartIndex + 0] = Color.r;
|
|
|
|
pData[PixelStartIndex + 1] = Color.g;
|
|
|
|
pData[PixelStartIndex + 2] = Color.b;
|
|
|
|
|
2023-04-27 15:15:48 +00:00
|
|
|
if(PixelSize == 4)
|
2023-08-12 10:13:27 +00:00
|
|
|
pData[PixelStartIndex + 3] = Color.a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::vector<ColorRGBA> GetUniqueColors(const CImageInfo &Image)
|
|
|
|
{
|
|
|
|
std::set<ColorRGBA> ColorSet;
|
|
|
|
std::vector<ColorRGBA> vUniqueColors;
|
|
|
|
for(int x = 0; x < Image.m_Width; x++)
|
|
|
|
{
|
|
|
|
for(int y = 0; y < Image.m_Height; y++)
|
|
|
|
{
|
|
|
|
ColorRGBA Color = GetPixelColor(Image, x, y);
|
|
|
|
if(Color.a > 0 && ColorSet.insert(Color).second)
|
|
|
|
vUniqueColors.push_back(Color);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::sort(vUniqueColors.begin(), vUniqueColors.end());
|
|
|
|
|
|
|
|
return vUniqueColors;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr int NumTilesRow = 16;
|
|
|
|
constexpr int NumTilesColumn = 16;
|
|
|
|
constexpr int NumTiles = NumTilesRow * NumTilesColumn;
|
|
|
|
constexpr int TileSize = 64;
|
|
|
|
|
|
|
|
static int GetColorIndex(const std::array<ColorRGBA, NumTiles> &ColorGroup, ColorRGBA Color)
|
|
|
|
{
|
|
|
|
std::array<ColorRGBA, NumTiles>::const_iterator Iterator = std::find(ColorGroup.begin(), ColorGroup.end(), Color);
|
|
|
|
if(Iterator == ColorGroup.end())
|
|
|
|
return 0;
|
|
|
|
return Iterator - ColorGroup.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::vector<std::array<ColorRGBA, NumTiles>> GroupColors(const std::vector<ColorRGBA> &vColors)
|
|
|
|
{
|
|
|
|
std::vector<std::array<ColorRGBA, NumTiles>> vaColorGroups;
|
|
|
|
|
|
|
|
for(size_t i = 0; i < vColors.size(); i += NumTiles - 1)
|
|
|
|
{
|
|
|
|
auto &Group = vaColorGroups.emplace_back();
|
|
|
|
std::copy_n(vColors.begin() + i, std::min<size_t>(NumTiles - 1, vColors.size() - i), Group.begin() + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return vaColorGroups;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void SetColorTile(CImageInfo *pImage, int x, int y, ColorRGBA Color)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < TileSize; i++)
|
|
|
|
{
|
|
|
|
for(int j = 0; j < TileSize; j++)
|
|
|
|
SetPixelColor(pImage, x * TileSize + i, y * TileSize + j, Color);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static CImageInfo ColorGroupToImage(const std::array<ColorRGBA, NumTiles> &aColorGroup)
|
|
|
|
{
|
|
|
|
CImageInfo Image;
|
|
|
|
Image.m_Width = NumTilesRow * TileSize;
|
|
|
|
Image.m_Height = NumTilesColumn * TileSize;
|
|
|
|
Image.m_Format = CImageInfo::FORMAT_RGBA;
|
|
|
|
|
|
|
|
uint8_t *pData = static_cast<uint8_t *>(malloc(static_cast<size_t>(Image.m_Width) * Image.m_Height * 4 * sizeof(uint8_t)));
|
|
|
|
Image.m_pData = pData;
|
|
|
|
|
|
|
|
for(int y = 0; y < NumTilesColumn; y++)
|
|
|
|
{
|
|
|
|
for(int x = 0; x < NumTilesRow; x++)
|
|
|
|
{
|
|
|
|
int ColorIndex = x + NumTilesRow * y;
|
|
|
|
SetColorTile(&Image, x, y, aColorGroup[ColorIndex]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Image;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::vector<CImageInfo> ColorGroupsToImages(const std::vector<std::array<ColorRGBA, NumTiles>> &vaColorGroups)
|
|
|
|
{
|
|
|
|
std::vector<CImageInfo> vImages;
|
|
|
|
vImages.reserve(vaColorGroups.size());
|
|
|
|
for(const auto &ColorGroup : vaColorGroups)
|
|
|
|
vImages.push_back(ColorGroupToImage(ColorGroup));
|
|
|
|
|
|
|
|
return vImages;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::shared_ptr<CEditorImage> ImageInfoToEditorImage(CEditor *pEditor, const CImageInfo &Image, const char *pName)
|
|
|
|
{
|
|
|
|
std::shared_ptr<CEditorImage> pEditorImage = std::make_shared<CEditorImage>(pEditor);
|
|
|
|
pEditorImage->m_Width = Image.m_Width;
|
|
|
|
pEditorImage->m_Height = Image.m_Height;
|
|
|
|
pEditorImage->m_Format = Image.m_Format;
|
|
|
|
pEditorImage->m_pData = Image.m_pData;
|
|
|
|
|
|
|
|
int TextureLoadFlag = pEditor->Graphics()->HasTextureArrays() ? IGraphics::TEXLOAD_TO_2D_ARRAY_TEXTURE : IGraphics::TEXLOAD_TO_3D_TEXTURE;
|
2023-04-27 15:15:48 +00:00
|
|
|
pEditorImage->m_Texture = pEditor->Graphics()->LoadTextureRaw(Image.m_Width, Image.m_Height, Image.m_Format, Image.m_pData, TextureLoadFlag, pName);
|
2023-08-12 10:13:27 +00:00
|
|
|
pEditorImage->m_External = 0;
|
|
|
|
str_copy(pEditorImage->m_aName, pName);
|
|
|
|
|
|
|
|
return pEditorImage;
|
|
|
|
}
|
|
|
|
|
|
|
|
static std::shared_ptr<CLayerTiles> AddLayerWithImage(CEditor *pEditor, const std::shared_ptr<CLayerGroup> &pGroup, int Width, int Height, const CImageInfo &Image, const char *pName)
|
|
|
|
{
|
|
|
|
std::shared_ptr<CEditorImage> pEditorImage = ImageInfoToEditorImage(pEditor, Image, pName);
|
|
|
|
pEditor->m_Map.m_vpImages.push_back(pEditorImage);
|
|
|
|
|
2023-09-05 13:16:41 +00:00
|
|
|
std::shared_ptr<CLayerTiles> pLayer = std::make_shared<CLayerTiles>(pEditor, Width, Height);
|
2023-08-12 10:13:27 +00:00
|
|
|
str_copy(pLayer->m_aName, pName);
|
|
|
|
pLayer->m_Image = pEditor->m_Map.m_vpImages.size() - 1;
|
|
|
|
pGroup->AddLayer(pLayer);
|
|
|
|
|
|
|
|
return pLayer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void SetTilelayerIndices(const std::shared_ptr<CLayerTiles> &pLayer, const std::array<ColorRGBA, NumTiles> &aColorGroup, const CImageInfo &Image)
|
|
|
|
{
|
|
|
|
for(int x = 0; x < pLayer->m_Width; x++)
|
|
|
|
{
|
|
|
|
for(int y = 0; y < pLayer->m_Height; y++)
|
|
|
|
pLayer->m_pTiles[x + y * pLayer->m_Width].m_Index = GetColorIndex(aColorGroup, GetPixelColor(Image, x, y));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CEditor::AddTileart()
|
|
|
|
{
|
|
|
|
std::shared_ptr<CLayerGroup> pGroup = m_Map.NewGroup();
|
|
|
|
str_copy(pGroup->m_aName, m_aTileartFilename);
|
|
|
|
|
|
|
|
auto vUniqueColors = GetUniqueColors(m_TileartImageInfo);
|
|
|
|
auto vaColorGroups = GroupColors(vUniqueColors);
|
|
|
|
auto vColorImages = ColorGroupsToImages(vaColorGroups);
|
|
|
|
char aImageName[IO_MAX_PATH_LENGTH];
|
|
|
|
for(size_t i = 0; i < vColorImages.size(); i++)
|
|
|
|
{
|
|
|
|
str_format(aImageName, sizeof(aImageName), "%s %" PRIzu, m_aTileartFilename, i + 1);
|
|
|
|
std::shared_ptr<CLayerTiles> pLayer = AddLayerWithImage(this, pGroup, m_TileartImageInfo.m_Width, m_TileartImageInfo.m_Height, vColorImages[i], aImageName);
|
|
|
|
SetTilelayerIndices(pLayer, vaColorGroups[i], m_TileartImageInfo);
|
|
|
|
}
|
|
|
|
SortImages();
|
|
|
|
|
|
|
|
free(m_TileartImageInfo.m_pData);
|
|
|
|
m_TileartImageInfo.m_pData = nullptr;
|
|
|
|
m_Map.OnModify();
|
|
|
|
m_Dialog = DIALOG_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CEditor::TileartCheckColors()
|
|
|
|
{
|
|
|
|
auto vUniqueColors = GetUniqueColors(m_TileartImageInfo);
|
|
|
|
int NumColorGroups = std::ceil(vUniqueColors.size() / 255.0f);
|
|
|
|
if(m_Map.m_vpImages.size() + NumColorGroups >= 64)
|
|
|
|
{
|
|
|
|
m_PopupEventType = CEditor::POPEVENT_PIXELART_TOO_MANY_COLORS;
|
|
|
|
m_PopupEventActivated = true;
|
|
|
|
free(m_TileartImageInfo.m_pData);
|
|
|
|
m_TileartImageInfo.m_pData = nullptr;
|
|
|
|
}
|
|
|
|
else if(NumColorGroups > 1)
|
|
|
|
{
|
|
|
|
m_PopupEventType = CEditor::POPEVENT_PIXELART_MANY_COLORS;
|
|
|
|
m_PopupEventActivated = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
AddTileart();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CEditor::CallbackAddTileart(const char *pFilepath, int StorageType, void *pUser)
|
|
|
|
{
|
|
|
|
CEditor *pEditor = (CEditor *)pUser;
|
|
|
|
|
|
|
|
if(!pEditor->Graphics()->LoadPNG(&pEditor->m_TileartImageInfo, pFilepath, StorageType))
|
|
|
|
{
|
|
|
|
pEditor->ShowFileDialogError("Failed to load image from file '%s'.", pFilepath);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
IStorage::StripPathAndExtension(pFilepath, pEditor->m_aTileartFilename, sizeof(pEditor->m_aTileartFilename));
|
|
|
|
if(pEditor->m_TileartImageInfo.m_Width * pEditor->m_TileartImageInfo.m_Height > 10'000)
|
|
|
|
{
|
|
|
|
pEditor->m_PopupEventType = CEditor::POPEVENT_PIXELART_BIG_IMAGE;
|
|
|
|
pEditor->m_PopupEventActivated = true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pEditor->TileartCheckColors();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|