Skip to content

Commit

Permalink
Add tests for palette loading
Browse files Browse the repository at this point in the history
  • Loading branch information
@kduske
kduske committed Sep 28, 2023
1 parent aa88f40 commit 90a7075
Show file tree
Hide file tree
Showing 7 changed files with 283 additions and 11 deletions.
54 changes: 44 additions & 10 deletions common/src/Assets/Palette.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@
#include "IO/File.h"
#include "IO/ImageLoader.h"
#include "IO/Reader.h"
#include "Macros.h"

#include <kdl/reflection_impl.h>
#include <kdl/result.h>
Expand All @@ -38,17 +39,23 @@
namespace TrenchBroom::Assets
{

struct PaletteData
kdl_reflect_impl(PaletteData);

std::ostream& operator<<(std::ostream& lhs, const PaletteColorFormat rhs)
{
/**
* 1024 bytes, RGBA order.
*/
std::vector<unsigned char> opaqueData;
/**
* 1024 bytes, RGBA order.
*/
std::vector<unsigned char> index255TransparentData;
};
switch (rhs)
{
case PaletteColorFormat::Rgb:
lhs << "Rgb";
break;
case PaletteColorFormat::Rgba:
lhs << "Rgba";
break;
switchDefault();
}

return lhs;
}

Palette::Palette(std::shared_ptr<PaletteData> data)
: m_data{std::move(data)}
Expand Down Expand Up @@ -107,6 +114,33 @@ bool Palette::indexedToRgba(
return hasTransparency;
}

bool operator==(const Palette& lhs, const Palette& rhs)
{
return lhs.m_data == rhs.m_data || *lhs.m_data == *rhs.m_data;
}

bool operator!=(const Palette& lhs, const Palette& rhs)
{
return !(lhs == rhs);
}

std::ostream& operator<<(std::ostream& lhs, const Palette& rhs)
{
auto str = kdl::struct_stream{lhs};
str << "Palette"
<< "m_data";
if (rhs.m_data)
{
str << *rhs.m_data;
}
else
{
str << "nullptr";
}
return lhs;
}


Result<Palette> makePalette(
const std::vector<unsigned char>& data, const PaletteColorFormat colorFormat)
{
Expand Down
21 changes: 20 additions & 1 deletion common/src/Assets/Palette.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,9 +38,22 @@ class Reader;

namespace TrenchBroom::Assets
{
struct PaletteData;
class TextureBuffer;

struct PaletteData
{
/**
* 1024 bytes, RGBA order.
*/
std::vector<unsigned char> opaqueData;
/**
* 1024 bytes, RGBA order.
*/
std::vector<unsigned char> index255TransparentData;

kdl_reflect_decl(PaletteData, opaqueData, index255TransparentData);
};

enum class PaletteTransparency
{
Opaque,
Expand All @@ -53,6 +66,8 @@ enum class PaletteColorFormat
Rgba,
};

std::ostream& operator<<(std::ostream& lhs, PaletteColorFormat rhs);

class Palette
{
private:
Expand Down Expand Up @@ -85,6 +100,10 @@ class Palette
TextureBuffer& rgbaImage,
PaletteTransparency transparency,
Color& averageColor) const;

friend bool operator==(const Palette& lhs, const Palette& rhs);
friend bool operator!=(const Palette& lhs, const Palette& rhs);
friend std::ostream& operator<<(std::ostream& lhs, const Palette& rhs);
};

Result<Palette> makePalette(
Expand Down
1 change: 1 addition & 0 deletions common/test/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ set(COMMON_TEST_SOURCE
"${COMMON_TEST_SOURCE_DIR}/Assets/tst_DecalDefinition.cpp"
"${COMMON_TEST_SOURCE_DIR}/Assets/tst_EntityModel.cpp"
"${COMMON_TEST_SOURCE_DIR}/Assets/tst_ModelDefinition.cpp"
"${COMMON_TEST_SOURCE_DIR}/Assets/tst_Palette.cpp"
"${COMMON_TEST_SOURCE_DIR}/EL/tst_EL.cpp"
"${COMMON_TEST_SOURCE_DIR}/EL/tst_Expression.cpp"
"${COMMON_TEST_SOURCE_DIR}/EL/tst_Interpolator.cpp"
Expand Down
Binary file added common/test/fixture/Assets/Palette/colormap.bmp
View file
Binary file not shown.
Binary file added common/test/fixture/Assets/Palette/colormap.pcx
View file
Binary file not shown.
Binary file added common/test/fixture/Assets/Palette/palette.lmp
View file
Binary file not shown.
218 changes: 218 additions & 0 deletions common/test/src/Assets/tst_Palette.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,218 @@
/*
Copyright (C) 2023 Kristian Duske
This file is part of TrenchBroom.
TrenchBroom is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
TrenchBroom is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with TrenchBroom. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Assets/Palette.h"
#include "Error.h"
#include "IO/DiskIO.h"
#include "IO/File.h"
#include "Result.h"

#include <kdl/result.h>

#include "Catch2.h"

namespace TrenchBroom::Assets
{
TEST_CASE("makePalette")
{
using T =
std::tuple<std::vector<unsigned char>, PaletteColorFormat, Result<PaletteData>>;

const auto [data, colorFormat, expectedResult] = GENERATE(values<T>({
{{}, PaletteColorFormat::Rgb, Result<PaletteData>{PaletteData{{}, {}}}},
{{0xF0}, PaletteColorFormat::Rgb, Result<PaletteData>{PaletteData{{}, {}}}},
{{0xF0, 0xF1}, PaletteColorFormat::Rgb, Result<PaletteData>{PaletteData{{}, {}}}},
{{0xF0, 0xF1, 0xF2},
PaletteColorFormat::Rgb,
Result<PaletteData>{
PaletteData{{0xF0, 0xF1, 0xF2, 0xFF}, {0xF0, 0xF1, 0xF2, 0x00}}}},
{{0xF0, 0xF1, 0xF2, 0xF3},
PaletteColorFormat::Rgb,
Result<PaletteData>{
PaletteData{{0xF0, 0xF1, 0xF2, 0xFF}, {0xF0, 0xF1, 0xF2, 0x00}}}},
{{0xF0, 0xF1, 0xF2, 0xF3, 0xF4},
PaletteColorFormat::Rgb,
Result<PaletteData>{
PaletteData{{0xF0, 0xF1, 0xF2, 0xFF}, {0xF0, 0xF1, 0xF2, 0x00}}}},
{{0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5},
PaletteColorFormat::Rgb,
Result<PaletteData>{PaletteData{
{0xF0, 0xF1, 0xF2, 0xFF, 0xF3, 0xF4, 0xF5, 0xFF},
{0xF0, 0xF1, 0xF2, 0xFF, 0xF3, 0xF4, 0xF5, 0x00}}}},

{{}, PaletteColorFormat::Rgba, Result<PaletteData>{PaletteData{{}, {}}}},
{{0xF0}, PaletteColorFormat::Rgba, Result<PaletteData>{PaletteData{{0xF0}, {0xF0}}}},
{{0xF0, 0xF1, 0xF2, 0xFE},
PaletteColorFormat::Rgba,
Result<PaletteData>{
PaletteData{{0xF0, 0xF1, 0xF2, 0xFE}, {0xF0, 0xF1, 0xF2, 0xFE}}}},
{{0xF0, 0xF1, 0xF2, 0xFE, 0xF3, 0xF4, 0xF5, 0xFE},
PaletteColorFormat::Rgba,
Result<PaletteData>{PaletteData{
{0xF0, 0xF1, 0xF2, 0xFE, 0xF3, 0xF4, 0xF5, 0xFE},
{0xF0, 0xF1, 0xF2, 0xFE, 0xF3, 0xF4, 0xF5, 0xFE}}}},
}));

CAPTURE(data, colorFormat);

const auto expectedPalette =
expectedResult
.and_then([](auto paletteData) {
return Result<Palette>{
Palette{std::make_shared<PaletteData>(std::move(paletteData))}};
})
.or_else([](auto e) { return Result<Palette>{std::move(e)}; });

CHECK(makePalette(data, colorFormat) == expectedPalette);
}

TEST_CASE("loadPalette")
{
using T = std::tuple<std::string, std::vector<unsigned char>>;

const auto [filename, expectedPaletteData] = GENERATE(values<T>({
{"colormap.pcx",
{
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x2F, 0x2F, 0x2F, 0x3F, 0x3F,
0x3F, 0x4B, 0x4B, 0x4B, 0x5B, 0x5B, 0x5B, 0x6B, 0x6B, 0x6B, 0x7B, 0x7B, 0x7B, 0x8B,
0x8B, 0x8B, 0x9B, 0x9B, 0x9B, 0xAB, 0xAB, 0xAB, 0xBB, 0xBB, 0xBB, 0xCB, 0xCB, 0xCB,
0xDB, 0xDB, 0xDB, 0xEB, 0xEB, 0xEB, 0x63, 0x4B, 0x23, 0x5B, 0x43, 0x1F, 0x53, 0x3F,
0x1F, 0x4F, 0x3B, 0x1B, 0x47, 0x37, 0x1B, 0x3F, 0x2F, 0x17, 0x3B, 0x2B, 0x17, 0x33,
0x27, 0x13, 0x2F, 0x23, 0x13, 0x2B, 0x1F, 0x13, 0x27, 0x1B, 0x0F, 0x23, 0x17, 0x0F,
0x1B, 0x13, 0x0B, 0x17, 0x0F, 0x0B, 0x13, 0x0F, 0x07, 0x0F, 0x0B, 0x07, 0x5F, 0x5F,
0x6F, 0x5B, 0x5B, 0x67, 0x5B, 0x53, 0x5F, 0x57, 0x4F, 0x5B, 0x53, 0x4B, 0x53, 0x4F,
0x47, 0x4B, 0x47, 0x3F, 0x43, 0x3F, 0x3B, 0x3B, 0x3B, 0x37, 0x37, 0x33, 0x2F, 0x2F,
0x2F, 0x2B, 0x2B, 0x27, 0x27, 0x27, 0x23, 0x23, 0x23, 0x1B, 0x1B, 0x1B, 0x17, 0x17,
0x17, 0x13, 0x13, 0x13, 0x8F, 0x77, 0x53, 0x7B, 0x63, 0x43, 0x73, 0x5B, 0x3B, 0x67,
0x4F, 0x2F, 0xCF, 0x97, 0x4B, 0xA7, 0x7B, 0x3B, 0x8B, 0x67, 0x2F, 0x6F, 0x53, 0x27,
0xEB, 0x9F, 0x27, 0xCB, 0x8B, 0x23, 0xAF, 0x77, 0x1F, 0x93, 0x63, 0x1B, 0x77, 0x4F,
0x17, 0x5B, 0x3B, 0x0F, 0x3F, 0x27, 0x0B, 0x23, 0x17, 0x07, 0xA7, 0x3B, 0x2B, 0x9F,
0x2F, 0x23, 0x97, 0x2B, 0x1B, 0x8B, 0x27, 0x13, 0x7F, 0x1F, 0x0F, 0x73, 0x17, 0x0B,
0x67, 0x17, 0x07, 0x57, 0x13, 0x00, 0x4B, 0x0F, 0x00, 0x43, 0x0F, 0x00, 0x3B, 0x0F,
0x00, 0x33, 0x0B, 0x00, 0x2B, 0x0B, 0x00, 0x23, 0x0B, 0x00, 0x1B, 0x07, 0x00, 0x13,
0x07, 0x00, 0x7B, 0x5F, 0x4B, 0x73, 0x57, 0x43, 0x6B, 0x53, 0x3F, 0x67, 0x4F, 0x3B,
0x5F, 0x47, 0x37, 0x57, 0x43, 0x33, 0x53, 0x3F, 0x2F, 0x4B, 0x37, 0x2B, 0x43, 0x33,
0x27, 0x3F, 0x2F, 0x23, 0x37, 0x27, 0x1B, 0x2F, 0x23, 0x17, 0x27, 0x1B, 0x13, 0x1F,
0x17, 0x0F, 0x17, 0x0F, 0x0B, 0x0F, 0x0B, 0x07, 0x6F, 0x3B, 0x17, 0x5F, 0x37, 0x17,
0x53, 0x2F, 0x17, 0x43, 0x2B, 0x17, 0x37, 0x23, 0x13, 0x27, 0x1B, 0x0F, 0x1B, 0x13,
0x0B, 0x0F, 0x0B, 0x07, 0xB3, 0x5B, 0x4F, 0xBF, 0x7B, 0x6F, 0xCB, 0x9B, 0x93, 0xD7,
0xBB, 0xB7, 0xCB, 0xD7, 0xDF, 0xB3, 0xC7, 0xD3, 0x9F, 0xB7, 0xC3, 0x87, 0xA7, 0xB7,
0x73, 0x97, 0xA7, 0x5B, 0x87, 0x9B, 0x47, 0x77, 0x8B, 0x2F, 0x67, 0x7F, 0x17, 0x53,
0x6F, 0x13, 0x4B, 0x67, 0x0F, 0x43, 0x5B, 0x0B, 0x3F, 0x53, 0x07, 0x37, 0x4B, 0x07,
0x2F, 0x3F, 0x07, 0x27, 0x33, 0x00, 0x1F, 0x2B, 0x00, 0x17, 0x1F, 0x00, 0x0F, 0x13,
0x00, 0x07, 0x0B, 0x00, 0x00, 0x00, 0x8B, 0x57, 0x57, 0x83, 0x4F, 0x4F, 0x7B, 0x47,
0x47, 0x73, 0x43, 0x43, 0x6B, 0x3B, 0x3B, 0x63, 0x33, 0x33, 0x5B, 0x2F, 0x2F, 0x57,
0x2B, 0x2B, 0x4B, 0x23, 0x23, 0x3F, 0x1F, 0x1F, 0x33, 0x1B, 0x1B, 0x2B, 0x13, 0x13,
0x1F, 0x0F, 0x0F, 0x13, 0x0B, 0x0B, 0x0B, 0x07, 0x07, 0x00, 0x00, 0x00, 0x97, 0x9F,
0x7B, 0x8F, 0x97, 0x73, 0x87, 0x8B, 0x6B, 0x7F, 0x83, 0x63, 0x77, 0x7B, 0x5F, 0x73,
0x73, 0x57, 0x6B, 0x6B, 0x4F, 0x63, 0x63, 0x47, 0x5B, 0x5B, 0x43, 0x4F, 0x4F, 0x3B,
0x43, 0x43, 0x33, 0x37, 0x37, 0x2B, 0x2F, 0x2F, 0x23, 0x23, 0x23, 0x1B, 0x17, 0x17,
0x13, 0x0F, 0x0F, 0x0B, 0x9F, 0x4B, 0x3F, 0x93, 0x43, 0x37, 0x8B, 0x3B, 0x2F, 0x7F,
0x37, 0x27, 0x77, 0x2F, 0x23, 0x6B, 0x2B, 0x1B, 0x63, 0x23, 0x17, 0x57, 0x1F, 0x13,
0x4F, 0x1B, 0x0F, 0x43, 0x17, 0x0B, 0x37, 0x13, 0x0B, 0x2B, 0x0F, 0x07, 0x1F, 0x0B,
0x07, 0x17, 0x07, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0x7B, 0xCF, 0x6F,
0x73, 0xC3, 0x67, 0x6B, 0xB7, 0x63, 0x63, 0xA7, 0x5B, 0x5B, 0x9B, 0x53, 0x57, 0x8F,
0x4B, 0x4F, 0x7F, 0x47, 0x47, 0x73, 0x3F, 0x3F, 0x67, 0x37, 0x37, 0x57, 0x2F, 0x2F,
0x4B, 0x27, 0x27, 0x3F, 0x23, 0x1F, 0x2F, 0x1B, 0x17, 0x23, 0x13, 0x0F, 0x17, 0x0B,
0x07, 0x07, 0x9B, 0xAB, 0x7B, 0x8F, 0x9F, 0x6F, 0x87, 0x97, 0x63, 0x7B, 0x8B, 0x57,
0x73, 0x83, 0x4B, 0x67, 0x77, 0x43, 0x5F, 0x6F, 0x3B, 0x57, 0x67, 0x33, 0x4B, 0x5B,
0x27, 0x3F, 0x4F, 0x1B, 0x37, 0x43, 0x13, 0x2F, 0x3B, 0x0B, 0x23, 0x2F, 0x07, 0x1B,
0x23, 0x00, 0x13, 0x17, 0x00, 0x0B, 0x0F, 0x00, 0x00, 0xFF, 0x00, 0x23, 0xE7, 0x0F,
0x3F, 0xD3, 0x1B, 0x53, 0xBB, 0x27, 0x5F, 0xA7, 0x2F, 0x5F, 0x8F, 0x33, 0x5F, 0x7B,
0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xD3, 0xFF, 0xFF, 0xA7, 0xFF, 0xFF, 0x7F, 0xFF,
0xFF, 0x53, 0xFF, 0xFF, 0x27, 0xFF, 0xEB, 0x1F, 0xFF, 0xD7, 0x17, 0xFF, 0xBF, 0x0F,
0xFF, 0xAB, 0x07, 0xFF, 0x93, 0x00, 0xEF, 0x7F, 0x00, 0xE3, 0x6B, 0x00, 0xD3, 0x57,
0x00, 0xC7, 0x47, 0x00, 0xB7, 0x3B, 0x00, 0xAB, 0x2B, 0x00, 0x9B, 0x1F, 0x00, 0x8F,
0x17, 0x00, 0x7F, 0x0F, 0x00, 0x73, 0x07, 0x00, 0x5F, 0x00, 0x00, 0x47, 0x00, 0x00,
0x2F, 0x00, 0x00, 0x1B, 0x00, 0x00, 0xEF, 0x00, 0x00, 0x37, 0x37, 0xFF, 0xFF, 0x00,
0x00, 0x00, 0x00, 0xFF, 0x2B, 0x2B, 0x23, 0x1B, 0x1B, 0x17, 0x13, 0x13, 0x0F, 0xEB,
0x97, 0x7F, 0xC3, 0x73, 0x53, 0x9F, 0x57, 0x33, 0x7B, 0x3F, 0x1B, 0xEB, 0xD3, 0xC7,
0xC7, 0xAB, 0x9B, 0xA7, 0x8B, 0x77, 0x87, 0x6B, 0x57, 0x9F, 0x5B, 0x53,
}},
{"palette.lmp",
{
0x00, 0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x2F, 0x2F, 0x2F, 0x3F, 0x3F,
0x3F, 0x4B, 0x4B, 0x4B, 0x5B, 0x5B, 0x5B, 0x6B, 0x6B, 0x6B, 0x7B, 0x7B, 0x7B, 0x8B,
0x8B, 0x8B, 0x9B, 0x9B, 0x9B, 0xAB, 0xAB, 0xAB, 0xBB, 0xBB, 0xBB, 0xCB, 0xCB, 0xCB,
0xDB, 0xDB, 0xDB, 0xEB, 0xEB, 0xEB, 0x0F, 0x0B, 0x07, 0x17, 0x0F, 0x0B, 0x1F, 0x17,
0x0B, 0x27, 0x1B, 0x0F, 0x2F, 0x23, 0x13, 0x37, 0x2B, 0x17, 0x3F, 0x2F, 0x17, 0x4B,
0x37, 0x1B, 0x53, 0x3B, 0x1B, 0x5B, 0x43, 0x1F, 0x63, 0x4B, 0x1F, 0x6B, 0x53, 0x1F,
0x73, 0x57, 0x1F, 0x7B, 0x5F, 0x23, 0x83, 0x67, 0x23, 0x8F, 0x6F, 0x23, 0x0B, 0x0B,
0x0F, 0x13, 0x13, 0x1B, 0x1B, 0x1B, 0x27, 0x27, 0x27, 0x33, 0x2F, 0x2F, 0x3F, 0x37,
0x37, 0x4B, 0x3F, 0x3F, 0x57, 0x47, 0x47, 0x67, 0x4F, 0x4F, 0x73, 0x5B, 0x5B, 0x7F,
0x63, 0x63, 0x8B, 0x6B, 0x6B, 0x97, 0x73, 0x73, 0xA3, 0x7B, 0x7B, 0xAF, 0x83, 0x83,
0xBB, 0x8B, 0x8B, 0xCB, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x0B, 0x0B, 0x00, 0x13,
0x13, 0x00, 0x1B, 0x1B, 0x00, 0x23, 0x23, 0x00, 0x2B, 0x2B, 0x07, 0x2F, 0x2F, 0x07,
0x37, 0x37, 0x07, 0x3F, 0x3F, 0x07, 0x47, 0x47, 0x07, 0x4B, 0x4B, 0x0B, 0x53, 0x53,
0x0B, 0x5B, 0x5B, 0x0B, 0x63, 0x63, 0x0B, 0x6B, 0x6B, 0x0F, 0x07, 0x00, 0x00, 0x0F,
0x00, 0x00, 0x17, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x27, 0x00, 0x00, 0x2F, 0x00, 0x00,
0x37, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x47, 0x00, 0x00, 0x4F, 0x00, 0x00, 0x57, 0x00,
0x00, 0x5F, 0x00, 0x00, 0x67, 0x00, 0x00, 0x6F, 0x00, 0x00, 0x77, 0x00, 0x00, 0x7F,
0x00, 0x00, 0x13, 0x13, 0x00, 0x1B, 0x1B, 0x00, 0x23, 0x23, 0x00, 0x2F, 0x2B, 0x00,
0x37, 0x2F, 0x00, 0x43, 0x37, 0x00, 0x4B, 0x3B, 0x07, 0x57, 0x43, 0x07, 0x5F, 0x47,
0x07, 0x6B, 0x4B, 0x0B, 0x77, 0x53, 0x0F, 0x83, 0x57, 0x13, 0x8B, 0x5B, 0x13, 0x97,
0x5F, 0x1B, 0xA3, 0x63, 0x1F, 0xAF, 0x67, 0x23, 0x23, 0x13, 0x07, 0x2F, 0x17, 0x0B,
0x3B, 0x1F, 0x0F, 0x4B, 0x23, 0x13, 0x57, 0x2B, 0x17, 0x63, 0x2F, 0x1F, 0x73, 0x37,
0x23, 0x7F, 0x3B, 0x2B, 0x8F, 0x43, 0x33, 0x9F, 0x4F, 0x33, 0xAF, 0x63, 0x2F, 0xBF,
0x77, 0x2F, 0xCF, 0x8F, 0x2B, 0xDF, 0xAB, 0x27, 0xEF, 0xCB, 0x1F, 0xFF, 0xF3, 0x1B,
0x0B, 0x07, 0x00, 0x1B, 0x13, 0x00, 0x2B, 0x23, 0x0F, 0x37, 0x2B, 0x13, 0x47, 0x33,
0x1B, 0x53, 0x37, 0x23, 0x63, 0x3F, 0x2B, 0x6F, 0x47, 0x33, 0x7F, 0x53, 0x3F, 0x8B,
0x5F, 0x47, 0x9B, 0x6B, 0x53, 0xA7, 0x7B, 0x5F, 0xB7, 0x87, 0x6B, 0xC3, 0x93, 0x7B,
0xD3, 0xA3, 0x8B, 0xE3, 0xB3, 0x97, 0xAB, 0x8B, 0xA3, 0x9F, 0x7F, 0x97, 0x93, 0x73,
0x87, 0x8B, 0x67, 0x7B, 0x7F, 0x5B, 0x6F, 0x77, 0x53, 0x63, 0x6B, 0x4B, 0x57, 0x5F,
0x3F, 0x4B, 0x57, 0x37, 0x43, 0x4B, 0x2F, 0x37, 0x43, 0x27, 0x2F, 0x37, 0x1F, 0x23,
0x2B, 0x17, 0x1B, 0x23, 0x13, 0x13, 0x17, 0x0B, 0x0B, 0x0F, 0x07, 0x07, 0xBB, 0x73,
0x9F, 0xAF, 0x6B, 0x8F, 0xA3, 0x5F, 0x83, 0x97, 0x57, 0x77, 0x8B, 0x4F, 0x6B, 0x7F,
0x4B, 0x5F, 0x73, 0x43, 0x53, 0x6B, 0x3B, 0x4B, 0x5F, 0x33, 0x3F, 0x53, 0x2B, 0x37,
0x47, 0x23, 0x2B, 0x3B, 0x1F, 0x23, 0x2F, 0x17, 0x1B, 0x23, 0x13, 0x13, 0x17, 0x0B,
0x0B, 0x0F, 0x07, 0x07, 0xDB, 0xC3, 0xBB, 0xCB, 0xB3, 0xA7, 0xBF, 0xA3, 0x9B, 0xAF,
0x97, 0x8B, 0xA3, 0x87, 0x7B, 0x97, 0x7B, 0x6F, 0x87, 0x6F, 0x5F, 0x7B, 0x63, 0x53,
0x6B, 0x57, 0x47, 0x5F, 0x4B, 0x3B, 0x53, 0x3F, 0x33, 0x43, 0x33, 0x27, 0x37, 0x2B,
0x1F, 0x27, 0x1F, 0x17, 0x1B, 0x13, 0x0F, 0x0F, 0x0B, 0x07, 0x6F, 0x83, 0x7B, 0x67,
0x7B, 0x6F, 0x5F, 0x73, 0x67, 0x57, 0x6B, 0x5F, 0x4F, 0x63, 0x57, 0x47, 0x5B, 0x4F,
0x3F, 0x53, 0x47, 0x37, 0x4B, 0x3F, 0x2F, 0x43, 0x37, 0x2B, 0x3B, 0x2F, 0x23, 0x33,
0x27, 0x1F, 0x2B, 0x1F, 0x17, 0x23, 0x17, 0x0F, 0x1B, 0x13, 0x0B, 0x13, 0x0B, 0x07,
0x0B, 0x07, 0xFF, 0xF3, 0x1B, 0xEF, 0xDF, 0x17, 0xDB, 0xCB, 0x13, 0xCB, 0xB7, 0x0F,
0xBB, 0xA7, 0x0F, 0xAB, 0x97, 0x0B, 0x9B, 0x83, 0x07, 0x8B, 0x73, 0x07, 0x7B, 0x63,
0x07, 0x6B, 0x53, 0x00, 0x5B, 0x47, 0x00, 0x4B, 0x37, 0x00, 0x3B, 0x2B, 0x00, 0x2B,
0x1F, 0x00, 0x1B, 0x0F, 0x00, 0x0B, 0x07, 0x00, 0x00, 0x00, 0xFF, 0x0B, 0x0B, 0xEF,
0x13, 0x13, 0xDF, 0x1B, 0x1B, 0xCF, 0x23, 0x23, 0xBF, 0x2B, 0x2B, 0xAF, 0x2F, 0x2F,
0x9F, 0x2F, 0x2F, 0x8F, 0x2F, 0x2F, 0x7F, 0x2F, 0x2F, 0x6F, 0x2F, 0x2F, 0x5F, 0x2B,
0x2B, 0x4F, 0x23, 0x23, 0x3F, 0x1B, 0x1B, 0x2F, 0x13, 0x13, 0x1F, 0x0B, 0x0B, 0x0F,
0x2B, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x4B, 0x07, 0x00, 0x5F, 0x07, 0x00, 0x6F, 0x0F,
0x00, 0x7F, 0x17, 0x07, 0x93, 0x1F, 0x07, 0xA3, 0x27, 0x0B, 0xB7, 0x33, 0x0F, 0xC3,
0x4B, 0x1B, 0xCF, 0x63, 0x2B, 0xDB, 0x7F, 0x3B, 0xE3, 0x97, 0x4F, 0xE7, 0xAB, 0x5F,
0xEF, 0xBF, 0x77, 0xF7, 0xD3, 0x8B, 0xA7, 0x7B, 0x3B, 0xB7, 0x9B, 0x37, 0xC7, 0xC3,
0x37, 0xE7, 0xE3, 0x57, 0x7F, 0xBF, 0xFF, 0xAB, 0xE7, 0xFF, 0xD7, 0xFF, 0xFF, 0x67,
0x00, 0x00, 0x8B, 0x00, 0x00, 0xB3, 0x00, 0x00, 0xD7, 0x00, 0x00, 0xFF, 0x00, 0x00,
0xFF, 0xF3, 0x93, 0xFF, 0xF7, 0xC7, 0xFF, 0xFF, 0xFF, 0x9F, 0x5B, 0x53,
}},
}));

CAPTURE(filename);

const auto basePath = std::filesystem::current_path() / "fixture/test/Assets/Palette/";
const auto filePath = basePath / filename;
const auto file = IO::Disk::openFile(filePath).value();

const auto expectedPalette = makePalette(expectedPaletteData, PaletteColorFormat::Rgb);

CHECK(loadPalette(*file, filePath) == expectedPalette);
}
} // namespace TrenchBroom::Assets

0 comments on commit 90a7075

Please sign in to comment.