dyepalette.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2007-2009 The Mana World Development Team
 * Copyright (C) 2009-2010 The Mana Developers
 * Copyright (C) 2011-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * This file is part of The ManaPlus Client.
 *
 * This program 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 2 of the License, or
 * any later version.
 *
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "resources/dye/dyepalette.h"
 
#include "logger.h"
 
#ifndef DYECMD
#include "resources/db/palettedb.h"
#endif // DYECMD
 
#include "utils/stringutils.h"
 
#ifndef USE_SDL2
#include <cmath>
#endif // USE_SDL2
 
PRAGMA48(GCC diagnostic push)
PRAGMA48(GCC diagnostic ignored "-Wshadow")
#ifndef SDL_BIG_ENDIAN
#include <SDL_endian.h>
#endif // SDL_BYTEORDER
PRAGMA48(GCC diagnostic pop)
 
#ifdef SIMD_SUPPORTED
#include "utils/cpu.h"
#endif // SIMD_SUPPORTED
#include "utils/foreach.h"
 
#include "debug.h"
 
DyeFunctionPtr DyePalette::funcReplaceSColor = nullptr;
DyeFunctionPtr DyePalette::funcReplaceSColorSse2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceSColorAvx2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAColor = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAColorSse2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAColorAvx2 = nullptr;
 
#ifdef USE_OPENGL
DyeFunctionPtr DyePalette::funcReplaceSOGLColor = nullptr;
DyeFunctionPtr DyePalette::funcReplaceSOGLColorSse2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceSOGLColorAvx2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAOGLColor = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAOGLColorSse2 = nullptr;
DyeFunctionPtr DyePalette::funcReplaceAOGLColorAvx2 = nullptr;
#endif // USE_OPENGL
 
DyePalette::DyePalette(const std::string &restrict description,
 const uint8_t blockSize) :
 mColors()
{
 const size_t size = CAST_SIZE(description.length());
 if (size == 0)
 return;
 
 StringVect parts;
 splitToStringVector(parts, description.substr(1), ',');
 if (description[0] == '#')
 {
 FOR_EACH (StringVectCIter, it, parts)
 {
 DyeColor color(0, 0, 0, 0);
 hexToColor(*it, blockSize, color);
 mColors.push_back(color);
 }
 return;
 }
#ifndef DYECMD
 else if (description[0] == '@')
 {
 uint8_t alpha = 255;
 FOR_EACH (StringVectCIter, it, parts)
 {
 const std::string str = *it;
 if (str.empty())
 continue;
 if (str[0] == '+')
 {
 if (str.size() != 3)
 continue;
 alpha = CAST_U8((hexDecode(str[1]) << 4) + hexDecode(str[2]));
 continue;
 }
 const DyeColor *const color = PaletteDB::getColor(str);
 if (color != nullptr)
 {
 DyeColor color2 = *color;
 color2.value[3] = alpha;
 mColors.push_back(color2);
 }
 else
 {
 DyeColor color2(0, 0, 0, 0);
 hexToColor(str, blockSize, color2);
 mColors.push_back(color2);
 }
 }
 return;
 }
#endif // DYECMD
 
 logger->log("Error, invalid embedded palette: %s", description.c_str());
}
 
void DyePalette::hexToColor(const std::string &restrict hexStr,
 const uint8_t blockSize,
 DyeColor &color) noexcept2
{
 for (size_t i = 0, colorIdx = 0;
 i < blockSize && colorIdx < 4;
 i += 2, colorIdx ++)
 {
 color.value[colorIdx] = CAST_U8((
 hexDecode(hexStr[i]) << 4)
 + hexDecode(hexStr[i + 1]));
 }
 color.update();
}
 
unsigned int DyePalette::hexDecode(const signed char c) noexcept2
{
 if ('0' <= c && c <= '9')
 return c - '0';
 else if ('A' <= c && c <= 'F')
 return c - 'A' + 10;
 else if ('a' <= c && c <= 'f')
 return c - 'a' + 10;
 else
 return 0;
}
 
void DyePalette::getColor(const unsigned int intensity,
 unsigned int (&restrict color)[3]) const restrict2
{
 if (intensity == 0)
 {
 color[0] = 0;
 color[1] = 0;
 color[2] = 0;
 return;
 }
 
 const int last = CAST_S32(mColors.size());
 if (last == 0)
 return;
 
 const int intLast = intensity * last;
 const int i = intLast / 255;
 const int t = intLast % 255;
 
 int j = t != 0 ? i : i - 1;
 
 if (j >= last)
 j = 0;
 
 // Get the exact color if any, the next color otherwise.
 const DyeColor &colorJ = mColors[j];
 const int r2 = colorJ.value[0];
 const int g2 = colorJ.value[1];
 const int b2 = colorJ.value[2];
 
 if (t == 0)
 {
 // Exact color.
 color[0] = r2;
 color[1] = g2;
 color[2] = b2;
 return;
 }
 
 // Get the previous color. First color is implicitly black.
 if (i > 0 && i < last + 1)
 {
 const DyeColor &colorI = mColors[i - 1];
 const int t2 = 255 - t;
 // Perform a linear interpolation.
 color[0] = (t2 * colorI.value[0] + t * r2) / 255;
 color[1] = (t2 * colorI.value[1] + t * g2) / 255;
 color[2] = (t2 * colorI.value[2] + t * b2) / 255;
 }
 else
 {
 // Perform a linear interpolation.
 color[0] = (t * r2) / 255;
 color[1] = (t * g2) / 255;
 color[2] = (t * b2) / 255;
 }
}
 
void DyePalette::getColor(double intensity,
 int (&restrict color)[3]) const restrict2
{
 // Nothing to do here
 if (mColors.empty())
 return;
 
 // Force range
 if (intensity > 1.0)
 intensity = 1.0;
 else if (intensity < 0.0)
 intensity = 0.0;
 
 // Scale up
 intensity *= static_cast<double>(mColors.size() - 1);
 
 // Color indices
 const int i = CAST_S32(floor(intensity));
 const int j = CAST_S32(ceil(intensity));
 const DyeColor &colorI = mColors[i];
 
 if (i == j)
 {
 // Exact color.
 color[0] = colorI.value[0];
 color[1] = colorI.value[1];
 color[2] = colorI.value[2];
 return;
 }
 
 intensity -= i;
 const double rest = 1 - intensity;
 const DyeColor &colorJ = mColors[j];
 
 // Perform the interpolation.
 color[0] = CAST_S32(rest * colorI.value[0] +
 intensity * colorJ.value[0]);
 color[1] = CAST_S32(rest * colorI.value[1] +
 intensity * colorJ.value[1]);
 color[2] = CAST_S32(rest * colorI.value[2] +
 intensity * colorJ.value[2]);
}
 
void DyePalette::initFunctions()
{
#ifdef SIMD_SUPPORTED
 const uint32_t flags = Cpu::getFlags();
 if ((flags & Cpu::FEATURE_AVX2) != 0U)
 {
 funcReplaceSColor = &DyePalette::replaceSColorAvx2;
 funcReplaceSColorAvx2 = &DyePalette::replaceSColorAvx2;
 funcReplaceSColorSse2 = &DyePalette::replaceSColorSse2;
 funcReplaceAColor = &DyePalette::replaceAColorAvx2;
 funcReplaceAColorAvx2 = &DyePalette::replaceAColorAvx2;
 funcReplaceAColorSse2 = &DyePalette::replaceAColorSse2;
 
#ifdef USE_OPENGL
 funcReplaceSOGLColor = &DyePalette::replaceSOGLColorAvx2;
 funcReplaceSOGLColorAvx2 = &DyePalette::replaceSOGLColorAvx2;
 funcReplaceSOGLColorSse2 = &DyePalette::replaceSOGLColorSse2;
 funcReplaceAOGLColor = &DyePalette::replaceAOGLColorAvx2;
 funcReplaceAOGLColorAvx2 = &DyePalette::replaceAOGLColorAvx2;
 funcReplaceAOGLColorSse2 = &DyePalette::replaceAOGLColorSse2;
#endif // USE_OPENGL
 }
 else if ((flags & Cpu::FEATURE_SSE2) != 0U)
 {
 funcReplaceSColor = &DyePalette::replaceSColorSse2;
 funcReplaceSColorAvx2 = &DyePalette::replaceSColorSse2;
 funcReplaceSColorSse2 = &DyePalette::replaceSColorSse2;
 funcReplaceAColor = &DyePalette::replaceAColorSse2;
 funcReplaceAColorAvx2 = &DyePalette::replaceAColorSse2;
 funcReplaceAColorSse2 = &DyePalette::replaceAColorSse2;
 
#ifdef USE_OPENGL
 funcReplaceSOGLColor = &DyePalette::replaceSOGLColorSse2;
 funcReplaceSOGLColorAvx2 = &DyePalette::replaceSOGLColorSse2;
 funcReplaceSOGLColorSse2 = &DyePalette::replaceSOGLColorSse2;
 funcReplaceAOGLColor = &DyePalette::replaceAOGLColorSse2;
 funcReplaceAOGLColorAvx2 = &DyePalette::replaceAOGLColorSse2;
 funcReplaceAOGLColorSse2 = &DyePalette::replaceAOGLColorSse2;
#endif // USE_OPENGL
 }
 else
#endif // SIMD_SUPPORTED
 {
 funcReplaceSColor = &DyePalette::replaceSColorDefault;
 funcReplaceSColorAvx2 = &DyePalette::replaceSColorDefault;
 funcReplaceSColorSse2 = &DyePalette::replaceSColorDefault;
 funcReplaceAColor = &DyePalette::replaceAColorDefault;
 funcReplaceAColorAvx2 = &DyePalette::replaceAColorDefault;
 funcReplaceAColorSse2 = &DyePalette::replaceAColorDefault;
 
#ifdef USE_OPENGL
 funcReplaceSOGLColor = &DyePalette::replaceSOGLColorDefault;
 funcReplaceSOGLColorAvx2 = &DyePalette::replaceSOGLColorDefault;
 funcReplaceSOGLColorSse2 = &DyePalette::replaceSOGLColorDefault;
 funcReplaceAOGLColor = &DyePalette::replaceAOGLColorDefault;
 funcReplaceAOGLColorAvx2 = &DyePalette::replaceAOGLColorDefault;
 funcReplaceAOGLColorSse2 = &DyePalette::replaceAOGLColorDefault;
#endif // USE_OPENGL
 }
}