Add palette preview scripting commands

include/core/tileset.h

@@ -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<QList<QRgb>> getBlockPalettes(Tileset*, Tileset*, bool useTruePalettes = false);
-    static QList<QRgb> getPalette(int, Tileset*, Tileset*);
+    static QList<QRgb> getPalette(int, Tileset*, Tileset*, bool useTruePalettes = false);
     static bool metatileIsValid(uint16_t metatileId, Tileset *, Tileset *);
 
     bool appendToHeaders(QString headerFile, QString friendlyName);

include/mainwindow.h

@@ -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:

include/ui/imageproviders.h

@@ -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({

src/core/tileset.cpp

@@ -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++) {
+    auto palettes = useTruePalettes ? tileset->palettes : tileset->palettePreviews;
-        paletteTable.append(tileset->palettes->at(paletteId).at(i));
+    for (int i = 0; i < palettes->at(paletteId).length(); i++) {
+        paletteTable.append(palettes->at(paletteId).at(i));
     }
     return paletteTable;
 }

src/mainwindow.cpp

@@ -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;
+        (*tileset->palettes)[paletteIndex][i] = qRgb(colors[i][0], colors[i][1], colors[i][2]);
-        (*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);
+}

src/project.cpp

@@ -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) {

src/ui/imageproviders.cpp

@@ -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) {
+QImage getPalettedTileImage(uint16_t tile, Tileset *primaryTileset, Tileset *secondaryTileset, int paletteId, bool useTruePalettes) {
-    QList<QRgb> palette = Tileset::getPalette(paletteId, primaryTileset, secondaryTileset);
+    QList<QRgb> palette = Tileset::getPalette(paletteId, primaryTileset, secondaryTileset, useTruePalettes);
     return getColoredTileImage(tile, primaryTileset, secondaryTileset, palette);
 }
 

src/ui/metatilelayersitem.cpp

@@ -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);

src/ui/paletteeditor.cpp

@@ -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);
         }
     }
 

src/ui/tileseteditor.cpp

@@ -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++;

src/ui/tileseteditormetatileselector.cpp

@@ -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);

src/ui/tileseteditortileselector.cpp

@@ -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;
 }

test_script.js

@@ -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)
+            applyTint(primaryPalette, morningTint)
-            map.setPrimaryTilesetPalette(i, primaryPalette)
+            map.setPrimaryTilesetPalettePreview(i, primaryPalette)
             const secondaryPalette = map.getSecondaryTilesetPalette(i)
-            applyTint(secondaryPalette, nightTint)
+            applyTint(secondaryPalette, morningTint)
-            map.setSecondaryTilesetPalette(i, secondaryPalette)
+            map.setSecondaryTilesetPalettePreview(i, secondaryPalette)
         }
     } catch (err) {
         console.log(err)