atiran/porymap
4
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Add palette preview scripting commands

Browse source
This commit is contained in:
Marcus Huderle 2020-05-03 10:31:44 -05:00
parent 8697adf186
commit 0ef3c6a898
13 changed files with 89 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
include/core/tileset.h
View file

@ -28,13 +28,14 @@ public:
QList<QImage> *tiles = nullptr;
QList<Metatile*> *metatiles = nullptr;
QList<QList<QRgb>> *palettes = nullptr;
QList<QList<QRgb>> *palettePreviews = nullptr;
Tileset* copy();
static Tileset* getBlockTileset(int, Tileset*, Tileset*);
static Metatile* getMetatile(int, Tileset*, Tileset*);
static QList<QList<QRgb>> getBlockPalettes(Tileset*, Tileset*);
static QList<QRgb> getPalette(int, Tileset*, Tileset*);
static QList<QList<QRgb>> getBlockPalettes(Tileset*, Tileset*, bool useTruePalettes = false);
static QList<QRgb> getPalette(int, Tileset*, Tileset*, bool useTruePalettes = false);
static bool metatileIsValid(uint16_t metatileId, Tileset *, Tileset *);
bool appendToHeaders(QString headerFile, QString friendlyName);

3
include/mainwindow.h
View file

@ -69,6 +69,9 @@ public:
QJSValue getTilesetPalette(Tileset *tileset, int paletteIndex);
Q_INVOKABLE QJSValue getPrimaryTilesetPalette(int paletteIndex);
Q_INVOKABLE QJSValue getSecondaryTilesetPalette(int paletteIndex);
void setTilesetPalettePreview(Tileset *tileset, int paletteIndex, QList<QList<int>> colors);
Q_INVOKABLE void setPrimaryTilesetPalettePreview(int paletteIndex, QList<QList<int>> colors);
Q_INVOKABLE void setSecondaryTilesetPalettePreview(int paletteIndex, QList<QList<int>> colors);
public slots:

4
include/ui/imageproviders.h
View file

@ -8,9 +8,9 @@
QImage getCollisionMetatileImage(Block);
QImage getCollisionMetatileImage(int, int);
QImage getMetatileImage(uint16_t, Tileset*, Tileset*);
QImage getMetatileImage(uint16_t, Tileset*, Tileset*, bool useTruePalettes = false);
QImage getTileImage(uint16_t, Tileset*, Tileset*);
QImage getPalettedTileImage(uint16_t, Tileset*, Tileset*, int);
QImage getPalettedTileImage(uint16_t, Tileset*, Tileset*, int, bool useTruePalettes = false);
QImage getGreyscaleTileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset);
static QList<QRgb> greyscalePalette({

23
src/core/tileset.cpp
View file

@ -46,6 +46,14 @@ Tileset* Tileset::copy() {
}
copy->palettes->append(copyPalette);
}
copy->palettePreviews = new QList<QList<QRgb>>;
for (QList<QRgb> palette : *this->palettePreviews) {
QList<QRgb> copyPalette;
for (QRgb color : palette) {
copyPalette.append(color);
}
copy->palettePreviews->append(copyPalette);
}
return copy;
}
@ -80,24 +88,27 @@ bool Tileset::metatileIsValid(uint16_t metatileId, Tileset *primaryTileset, Tile
return true;
}
QList<QList<QRgb>> Tileset::getBlockPalettes(Tileset *primaryTileset, Tileset *secondaryTileset) {
QList<QList<QRgb>> Tileset::getBlockPalettes(Tileset *primaryTileset, Tileset *secondaryTileset, bool useTruePalettes) {
QList<QList<QRgb>> palettes;
auto primaryPalettes = useTruePalettes ? primaryTileset->palettes : primaryTileset->palettePreviews;
for (int i = 0; i < Project::getNumPalettesPrimary(); i++) {
palettes.append(primaryTileset->palettes->at(i));
palettes.append(primaryPalettes->at(i));
}
auto secondaryPalettes = useTruePalettes ? secondaryTileset->palettes : secondaryTileset->palettePreviews;
for (int i = Project::getNumPalettesPrimary(); i < Project::getNumPalettesTotal(); i++) {
palettes.append(secondaryTileset->palettes->at(i));
palettes.append(secondaryPalettes->at(i));
}
return palettes;
}
QList<QRgb> Tileset::getPalette(int paletteId, Tileset *primaryTileset, Tileset *secondaryTileset) {
QList<QRgb> Tileset::getPalette(int paletteId, Tileset *primaryTileset, Tileset *secondaryTileset, bool useTruePalettes) {
QList<QRgb> paletteTable;
Tileset *tileset = paletteId < Project::getNumPalettesPrimary()
? primaryTileset
: secondaryTileset;
for (int i = 0; i < tileset->palettes->at(paletteId).length(); i++) {
paletteTable.append(tileset->palettes->at(paletteId).at(i));
auto palettes = useTruePalettes ? tileset->palettes : tileset->palettePreviews;
for (int i = 0; i < palettes->at(paletteId).length(); i++) {
paletteTable.append(palettes->at(paletteId).at(i));
}
return paletteTable;
}

41
src/mainwindow.cpp
View file

@ -1056,6 +1056,7 @@ void MainWindow::on_actionNew_Tileset_triggered() {
newSet->metatiles->append(mt);
}
newSet->palettes = new QList<QList<QRgb>>();
newSet->palettePreviews = new QList<QList<QRgb>>();
newSet->palettePaths = *new QList<QString>();
for(int i = 0; i < 16; ++i) {
QList<QRgb> *currentPal = new QList<QRgb>();
@ -1063,11 +1064,13 @@ void MainWindow::on_actionNew_Tileset_triggered() {
currentPal->append(qRgb(0,0,0));
}
newSet->palettes->append(*currentPal);
newSet->palettePreviews->append(*currentPal);
QString fileName;
fileName.sprintf("%02d.pal", i);
newSet->palettePaths.append(fullDirectoryPath+"/palettes/" + fileName);
}
(*newSet->palettes)[0][1] = qRgb(255,0,255);
(*newSet->palettePreviews)[0][1] = qRgb(255,0,255);
newSet->is_compressed = "TRUE";
newSet->padding = "0";
editor->project->saveTilesetTilesImage(newSet);
@ -2758,8 +2761,8 @@ void MainWindow::setTilesetPalette(Tileset *tileset, int paletteIndex, QList<QLi
for (int i = 0; i < 16; i++) {
if (colors[i].size() != 3)
continue;
auto palettes = tileset->palettes;
(*palettes)[paletteIndex][i] = qRgb(colors[i][0], colors[i][1], colors[i][2]);
(*tileset->palettes)[paletteIndex][i] = qRgb(colors[i][0], colors[i][1], colors[i][2]);
(*tileset->palettePreviews)[paletteIndex][i] = qRgb(colors[i][0], colors[i][1], colors[i][2]);
}
if (this->tilesetEditor) {
@ -2807,3 +2810,37 @@ QJSValue MainWindow::getSecondaryTilesetPalette(int paletteIndex) {
return QJSValue();
return this->getTilesetPalette(this->editor->map->layout->tileset_secondary, paletteIndex);
}
void MainWindow::setTilesetPalettePreview(Tileset *tileset, int paletteIndex, QList<QList<int>> colors) {
if (!this->editor || !this->editor->map || !this->editor->map->layout)
return;
if (paletteIndex >= tileset->palettePreviews->size())
return;
if (colors.size() != 16)
return;
for (int i = 0; i < 16; i++) {
if (colors[i].size() != 3)
continue;
auto palettes = tileset->palettePreviews;
(*palettes)[paletteIndex][i] = qRgb(colors[i][0], colors[i][1], colors[i][2]);
}
this->editor->metatile_selector_item->draw();
this->editor->selected_border_metatiles_item->draw();
this->editor->map_item->draw(true);
this->editor->updateMapBorder();
this->editor->updateMapConnections();
}
void MainWindow::setPrimaryTilesetPalettePreview(int paletteIndex, QList<QList<int>> colors) {
if (!this->editor || !this->editor->map || !this->editor->map->layout || !this->editor->map->layout->tileset_primary)
return;
this->setTilesetPalettePreview(this->editor->map->layout->tileset_primary, paletteIndex, colors);
}
void MainWindow::setSecondaryTilesetPalettePreview(int paletteIndex, QList<QList<int>> colors) {
if (!this->editor || !this->editor->map || !this->editor->map->layout || !this->editor->map->layout->tileset_secondary)
return;
this->setTilesetPalettePreview(this->editor->map->layout->tileset_secondary, paletteIndex, colors);
}

3
src/project.cpp
View file

@ -1585,6 +1585,7 @@ void Project::loadTilesetAssets(Tileset* tileset) {
// palettes
QList<QList<QRgb>> *palettes = new QList<QList<QRgb>>;
QList<QList<QRgb>> *palettePreviews = new QList<QList<QRgb>>;
for (int i = 0; i < tileset->palettePaths.length(); i++) {
QList<QRgb> palette;
QString path = tileset->palettePaths.value(i);
@ -1619,8 +1620,10 @@ void Project::loadTilesetAssets(Tileset* tileset) {
}
palettes->append(palette);
palettePreviews->append(palette);
}
tileset->palettes = palettes;
tileset->palettePreviews = palettePreviews;
}
void Project::loadTilesetTiles(Tileset *tileset, QImage image) {

8
src/ui/imageproviders.cpp
View file

@ -13,7 +13,7 @@ QImage getCollisionMetatileImage(int collision, int elevation) {
return collisionImage.toImage();
}
QImage getMetatileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset) {
QImage getMetatileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset, bool useTruePalettes) {
QImage metatile_image(16, 16, QImage::Format_RGBA8888);
Metatile* metatile = Tileset::getMetatile(tile, primaryTileset, secondaryTileset);
@ -27,7 +27,7 @@ QImage getMetatileImage(uint16_t tile, Tileset *primaryTileset, Tileset *seconda
metatile_image.fill(Qt::magenta);
return metatile_image;
}
QList<QList<QRgb>> palettes = Tileset::getBlockPalettes(primaryTileset, secondaryTileset);
QList<QList<QRgb>> palettes = Tileset::getBlockPalettes(primaryTileset, secondaryTileset, useTruePalettes);
QPainter metatile_painter(&metatile_image);
for (int layer = 0; layer < 2; layer++)
@ -95,8 +95,8 @@ QImage getColoredTileImage(uint16_t tile, Tileset *primaryTileset, Tileset *seco
return tileImage;
}
QImage getPalettedTileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset, int paletteId) {
QList<QRgb> palette = Tileset::getPalette(paletteId, primaryTileset, secondaryTileset);
QImage getPalettedTileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset, int paletteId, bool useTruePalettes) {
QList<QRgb> palette = Tileset::getPalette(paletteId, primaryTileset, secondaryTileset, useTruePalettes);
return getColoredTileImage(tile, primaryTileset, secondaryTileset, palette);
}

2
src/ui/metatilelayersitem.cpp
View file

@ -18,7 +18,7 @@ void MetatileLayersItem::draw() {
QPainter painter(&pixmap);
for (int i = 0; i < 8; i++) {
Tile tile = this->metatile->tiles->at(i);
QImage tileImage = getPalettedTileImage(tile.tile, this->primaryTileset, this->secondaryTileset, tile.palette)
QImage tileImage = getPalettedTileImage(tile.tile, this->primaryTileset, this->secondaryTileset, tile.palette, true)
.mirrored(tile.xflip, tile.yflip)
.scaled(16, 16);
painter.drawImage(tileCoords.at(i), tileImage);

5
src/ui/paletteeditor.cpp
View file

@ -203,6 +203,7 @@ void PaletteEditor::setColor(int colorIndex) {
? this->primaryTileset
: this->secondaryTileset;
(*tileset->palettes)[paletteNum][colorIndex] = qRgb(red, green, blue);
(*tileset->palettePreviews)[paletteNum][colorIndex] = qRgb(red, green, blue);
this->refreshColor(colorIndex);
this->commitEditHistory(paletteNum);
emit this->changedPaletteColor();
@ -246,8 +247,10 @@ void PaletteEditor::setColorsFromHistory(PaletteHistoryItem *history, int palett
for (int i = 0; i < 16; i++) {
if (paletteId < Project::getNumPalettesPrimary()) {
(*this->primaryTileset->palettes)[paletteId][i] = history->colors.at(i);
(*this->primaryTileset->palettePreviews)[paletteId][i] = history->colors.at(i);
} else {
(*this->secondaryTileset->palettes)[paletteId][i] = history->colors.at(i);
(*this->secondaryTileset->palettePreviews)[paletteId][i] = history->colors.at(i);
}
}
@ -296,8 +299,10 @@ void PaletteEditor::on_actionImport_Palette_triggered()
for (int i = 0; i < 16; i++) {
if (paletteId < Project::getNumPalettesPrimary()) {
(*this->primaryTileset->palettes)[paletteId][i] = palette.at(i);
(*this->primaryTileset->palettePreviews)[paletteId][i] = palette.at(i);
} else {
(*this->secondaryTileset->palettes)[paletteId][i] = palette.at(i);
(*this->secondaryTileset->palettePreviews)[paletteId][i] = palette.at(i);
}
}

2
src/ui/tileseteditor.cpp
View file

@ -177,7 +177,7 @@ void TilesetEditor::drawSelectedTiles() {
int tileIndex = 0;
for (int j = 0; j < dimensions.y(); j++) {
for (int i = 0; i < dimensions.x(); i++) {
QImage tileImage = getPalettedTileImage(tiles.at(tileIndex).tile, this->primaryTileset, this->secondaryTileset, tiles.at(tileIndex).palette)
QImage tileImage = getPalettedTileImage(tiles.at(tileIndex).tile, this->primaryTileset, this->secondaryTileset, tiles.at(tileIndex).palette, true)
.mirrored(tiles.at(tileIndex).xflip, tiles.at(tileIndex).yflip)
.scaled(16, 16);
tileIndex++;

2
src/ui/tileseteditormetatileselector.cpp
View file

@ -22,7 +22,7 @@ void TilesetEditorMetatileSelector::draw() {
if (i >= primaryLength) {
tile += Project::getNumMetatilesPrimary() - primaryLength;
}
QImage metatile_image = getMetatileImage(tile, this->primaryTileset, this->secondaryTileset).scaled(32, 32);
QImage metatile_image = getMetatileImage(tile, this->primaryTileset, this->secondaryTileset, true).scaled(32, 32);
int map_y = i / this->numMetatilesWide;
int map_x = i % this->numMetatilesWide;
QPoint metatile_origin = QPoint(map_x * 32, map_y * 32);

10
src/ui/tileseteditortileselector.cpp
View file

@ -22,19 +22,19 @@ void TilesetEditorTileSelector::draw() {
int primaryLength = this->primaryTileset->tiles->length();
int secondaryLength = this->secondaryTileset->tiles->length();
int height = totalTiles / this->numTilesWide;
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset);
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset, true);
QImage image(this->numTilesWide * 16, height * 16, QImage::Format_RGBA8888);
QPainter painter(&image);
for (uint16_t tile = 0; tile < totalTiles; tile++) {
QImage tileImage;
if (tile < primaryLength) {
tileImage = getPalettedTileImage(tile, this->primaryTileset, this->secondaryTileset, this->paletteId).scaled(16, 16);
tileImage = getPalettedTileImage(tile, this->primaryTileset, this->secondaryTileset, this->paletteId, true).scaled(16, 16);
} else if (tile < Project::getNumTilesPrimary()) {
tileImage = QImage(16, 16, QImage::Format_RGBA8888);
tileImage.fill(palette.at(0));
} else if (tile < Project::getNumTilesPrimary() + secondaryLength) {
tileImage = getPalettedTileImage(tile, this->primaryTileset, this->secondaryTileset, this->paletteId).scaled(16, 16);
tileImage = getPalettedTileImage(tile, this->primaryTileset, this->secondaryTileset, this->paletteId, true).scaled(16, 16);
} else {
tileImage = QImage(16, 16, QImage::Format_RGBA8888);
QPainter painter(&tileImage);
@ -224,7 +224,7 @@ QImage TilesetEditorTileSelector::buildPrimaryTilesIndexedImage() {
// Image is first converted using greyscale so that palettes with duplicate colors
// are properly represented in the final image.
QImage indexedImage = image.convertToFormat(QImage::Format::Format_Indexed8, greyscalePalette.toVector());
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset);
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset, true);
indexedImage.setColorTable(palette.toVector());
return indexedImage;
}
@ -261,7 +261,7 @@ QImage TilesetEditorTileSelector::buildSecondaryTilesIndexedImage() {
// Image is first converted using greyscale so that palettes with duplicate colors
// are properly represented in the final image.
QImage indexedImage = image.convertToFormat(QImage::Format::Format_Indexed8, greyscalePalette.toVector());
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset);
QList<QRgb> palette = Tileset::getPalette(this->paletteId, this->primaryTileset, this->secondaryTileset, true);
indexedImage.setColorTable(palette.toVector());
return indexedImage;
}

9
test_script.js
View file

@ -1,3 +1,4 @@
const morningTint = [0.8, 0.7, 0.9];
const nightTint = [0.6, 0.55, 1.0];
function applyTint(palette, tint) {
@ -14,11 +15,11 @@ export function on_map_opened(mapName) {
try {
for (let i = 0; i < 13; i++) {
const primaryPalette = map.getPrimaryTilesetPalette(i)
applyTint(primaryPalette, nightTint)
map.setPrimaryTilesetPalette(i, primaryPalette)
applyTint(primaryPalette, morningTint)
map.setPrimaryTilesetPalettePreview(i, primaryPalette)
const secondaryPalette = map.getSecondaryTilesetPalette(i)
applyTint(secondaryPalette, nightTint)
map.setSecondaryTilesetPalette(i, secondaryPalette)
applyTint(secondaryPalette, morningTint)
map.setSecondaryTilesetPalettePreview(i, secondaryPalette)
}
} catch (err) {
console.log(err)