aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-17 21:11:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/nel/tools/3d/panoply_maker/panoply_maker.cpp

992 lines
26 KiB
C++
Raw Blame History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "color_modifier.h"
#include "color_mask.h"
#include "hls_bank_texture_info.h"
#define HAS_INFO_GENERATION 0
#if HAS_INFO_GENERATION
#include "info_color_generation.h"
#include "info_mask_generation.h"
#endif
#include <nel/misc/types_nl.h>
#include <nel/misc/config_file.h>
#include <nel/misc/path.h>
#include <nel/misc/file.h>
#include <nel/misc/bitmap.h>
#include <nel/misc/debug.h>
#include <time.h>
using namespace NLMISC;
using namespace std;
string DivideBy2Dir= "/d4/";
//string HlsInfoDir= "hlsInfo/";
// ========================================================================================================
// This tool is for creating various colored texture from a base texture.
// Parts of a base texture can have hue, contrast, luminosity shifting etc.
// Each part is defined by a mask. The red component of it is considered as an alpha value (not the alpha, because it is faster to create a grey texture with photoshop..)
// The result is serialized in png or tga files.
// ========================================================================================================
// why this tool ? : it is useful to create various colored cloth and skin textures
// Not all hardware allow it to manage that at runtime (lack for palettized textures or pixel shaders...)
//=========================================================================================================
/// describes the building infos
struct CBuildInfo
{
std::string InputPath;
std::string OutputPath;
std::string HlsInfoPath;
std::string CachePath;
std::vector<std::string> BitmapExtensions; // the supported extension for bitmaps
std::string OutputFormat; // png or tga
std::string DefaultSeparator;
TColorMaskVect ColorMasks;
// how to shift right the size of the src Bitmap for the .hlsinfo
uint LowDefShift;
uint OptimizeTextures; // 0 = don't optimize, 1 = check, 2 = optimize
};
/// Temporary
static void validateCgiInfo();
static void validateGtmInfo();
/// Temporary
/** Build the infos we need from a config file
* It build a list of masks infos
*/
static void BuildMasksFromConfigFile(NLMISC::CConfigFile &cf,
TColorMaskVect &colorMasks);
/// Build the colored versions
static void BuildColoredVersions(const CBuildInfo &bi);
///
static void BuildColoredVersionForOneBitmap(const CBuildInfo &bi, const std::string &fileNameWithExtension, bool mustDivideBy2);
/** Check if building if reneeded by looking in the cache directory.
* If the texture is found in the cache it is just copied
*/
static bool CheckIfNeedRebuildColoredVersionForOneBitmap(const CBuildInfo &bi, const std::string &fileNameWithExtension, bool mustDivideBy2);
/// replace slashes by the matching os value in a file name
static std::string replaceSlashes(const std::string &src)
{
std::string result = src;
for(uint k = 0; k < result.size(); ++k)
#ifdef NL_OS_WINDOWS
if (result[k] == '/') result[k] = '\\';
#else
if (result[k] == '\\') result[k] = '/';
#endif
return result;
}
///=====================================================
int main(int argc, char* argv[])
{
// Filter addSearchPath
NLMISC::createDebug();
//"panoply.cfg" "gtm" "fyros"
#if HAS_INFO_GENERATION
if(!strcmp(argv[2], "gtm") || !strcmp(argv[2], "cgi"))
{
NLMISC::CConfigFile cf;
std::string _Path_Input_TexBases;
std::string _Path_Input_Masks;
std::string _Path_Output_MasksOptimized;
std::string _Path_Output_Gtm;
std::string _Path_Output_Cgi;
try
{
/// load the config file
cf.load(argv[1]);
/// look paths
try
{
NLMISC::CConfigFile::CVar &additionnal_paths = cf.getVar ("additionnal_paths");
for (uint k = 0; k < (uint) additionnal_paths.size(); ++k)
{
NLMISC::CPath::addSearchPath(NLMISC::CPath::standardizePath(additionnal_paths.asString(k)),true, false);
}
}
catch (const NLMISC::EUnknownVar &)
{
}
/// repertory of textures bases (no-colorized)
try
{
_Path_Input_TexBases = NLMISC::CPath::standardizePath(cf.getVar ("input_path_texbase").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// repertory of masks (original)
try
{
_Path_Input_Masks = NLMISC::CPath::standardizePath(cf.getVar ("input_path_mask").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// optimized masks output directory created
try
{
_Path_Output_MasksOptimized = NLMISC::CPath::standardizePath(cf.getVar ("output_path_mask_optimized").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// file of infos about colorization average for the client
try
{
_Path_Output_Cgi = NLMISC::CPath::standardizePath(cf.getVar ("output_path_cgi").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// file of infos about multiplexing texture for the client
try
{
_Path_Output_Gtm = NLMISC::CPath::standardizePath(cf.getVar ("output_path_gtm").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
}
catch (const std::exception &e)
{
nlerror("Panoply building failed: %s", e.what());
return -1;
}
/// oriented program
if( !strcmp(argv[2], "gtm")) /// masks optimized
{
CInfoMaskGeneration infoMaskGen(_Path_Input_TexBases,
_Path_Input_Masks,
_Path_Output_MasksOptimized,
_Path_Output_Gtm,
argv[3],
1);
infoMaskGen.init();
infoMaskGen.process();
}
else if( !strcmp(argv[2], "cgi")) /// colorized information
{
CInfoColorGeneration infoColor(_Path_Input_TexBases,
_Path_Input_Masks,
_Path_Output_Cgi,
argv[3],
1);
infoColor.init();
infoColor.process();
}
}
else
{
#endif
NLMISC::InfoLog->addNegativeFilter ("adding the path");
if (argc != 2)
{
nlinfo("Usage : %s [config_file name]", argv[0]);
return -1;
}
CBuildInfo bi;
/////////////////////////////////////////
// reads infos from the config files //
/////////////////////////////////////////
NLMISC::CConfigFile cf;
try
{
/// load the config file
cf.load(argv[1]);
/// colors masks
BuildMasksFromConfigFile(cf, bi.ColorMasks);
/// look paths
try
{
NLMISC::CConfigFile::CVar &additionnal_paths = cf.getVar ("additionnal_paths");
for (uint k = 0; k < (uint) additionnal_paths.size(); ++k)
{
NLMISC::CPath::addSearchPath(NLMISC::CPath::standardizePath(additionnal_paths.asString(k)));
}
}
catch (const NLMISC::EUnknownVar &)
{
}
/// input
try
{
bi.InputPath = NLMISC::CPath::standardizePath(cf.getVar ("input_path").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// output
try
{
bi.OutputPath = NLMISC::CPath::standardizePath(cf.getVar ("output_path").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// hls info path
try
{
bi.HlsInfoPath = NLMISC::CPath::standardizePath(cf.getVar("hls_info_path").asString());
}
catch (const NLMISC::EUnknownVar &)
{
bi.HlsInfoPath = "hlsInfo/";
}
/// output
try
{
bi.CachePath = NLMISC::CPath::standardizePath(cf.getVar ("cache_path").asString());
}
catch (const NLMISC::EUnknownVar &)
{
}
/// output format
try
{
bi.OutputFormat = "." + cf.getVar ("output_format").asString();
}
catch (const NLMISC::EUnknownVar &)
{
bi.OutputFormat = ".tga";
}
/// default ascii character for unused masks
try
{
bi.DefaultSeparator = cf.getVar ("default_separator").asString();
}
catch (const NLMISC::EUnknownVar &)
{
bi.DefaultSeparator = '_';
}
/// extension for bitmaps
try
{
NLMISC::CConfigFile::CVar &bitmap_extensions = cf.getVar ("bitmap_extensions");
for (uint k = 0; k < (uint) bitmap_extensions.size(); ++k)
{
std::string ext = "." + bitmap_extensions.asString(k);
ext = NLMISC::strupr(ext);
if (std::find(bi.BitmapExtensions.begin(), bi.BitmapExtensions.end(), ext) == bi.BitmapExtensions.end())
{
bi.BitmapExtensions.push_back(ext);
}
}
}
catch (const NLMISC::EUnknownVar &)
{
bi.BitmapExtensions[0].resize(1);
bi.BitmapExtensions[0] = bi.OutputFormat;
}
try
{
bi.LowDefShift = cf.getVar ("low_def_shift").asInt();
}
catch (const NLMISC::EUnknownVar &)
{
// tranform 512*512 to 64*64 by default
bi.LowDefShift= 3;
}
try
{
bi.OptimizeTextures = cf.getVar ("optimize_textures").asInt();
}
catch (const NLMISC::EUnknownVar &)
{
// don't optimize files by default
bi.OptimizeTextures = 0;
}
}
catch (const std::exception &e)
{
nlerror("Panoply building failed: %s", e.what());
return -1;
}
////////////////////////////////
// Build the colored versions //
////////////////////////////////
try
{
BuildColoredVersions(bi);
}
catch (const std::exception &e)
{
nlerror("Something went wrong while building bitmap: %s", e.what());
return -1;
}
return 0;
#if HAS_INFO_GENERATION
}
#endif
}
///======================================================
#if HAS_INFO_GENERATION
static void validateCgiInfo()
{
NLMISC::CIFile f;
vector<StrInfoTexColor> temp;
uint version;
try
{
f.open(CPath::lookup("info_color_texbase_fyros.cgi"));
f.serialCont(temp);
}
catch(const std::exception &e)
{
nlerror("Panoply building failed: %s", e.what());
}
uint16 a = temp.size();
f.close();
}
///======================================================
static void validateGtmInfo()
{
}
#endif
///======================================================
static void BuildMasksFromConfigFile(NLMISC::CConfigFile &cf,
TColorMaskVect &colorMasks)
{
/// get a list of the alpha mask extensions
NLMISC::CConfigFile::CVar &mask_extensions = cf.getVar ("mask_extensions");
colorMasks.resize(mask_extensions.size());
/// For each kind of mask, build a list of the color modifiers
for (uint k = 0; k < (uint) mask_extensions.size(); ++k)
{
colorMasks[k].MaskExt = mask_extensions.asString(k);
NLMISC::CConfigFile::CVar &luminosities = cf.getVar (colorMasks[k].MaskExt + "_luminosities");
NLMISC::CConfigFile::CVar &contrasts = cf.getVar (colorMasks[k].MaskExt + "_constrasts");
NLMISC::CConfigFile::CVar &hues = cf.getVar (colorMasks[k].MaskExt + "_hues");
NLMISC::CConfigFile::CVar &lightness = cf.getVar (colorMasks[k].MaskExt + "_lightness");
NLMISC::CConfigFile::CVar &saturation = cf.getVar (colorMasks[k].MaskExt + "_saturations");
NLMISC::CConfigFile::CVar &colorIDs = cf.getVar (colorMasks[k].MaskExt + "_color_id");
if (luminosities.size() != contrasts.size()
|| luminosities.size() != hues.size()
|| luminosities.size() != lightness.size()
|| luminosities.size() != saturation.size()
|| luminosities.size() != colorIDs.size()
)
{
throw NLMISC::Exception("All color descriptors must have the same number of arguments");
}
colorMasks[k].CMs.resize(luminosities.size());
for (uint l = 0; l < (uint) luminosities.size(); ++l)
{
CColorModifier &cm = colorMasks[k].CMs[l];
cm.Contrast = contrasts.asFloat(l);
cm.Luminosity = luminosities.asFloat(l);
cm.Hue = hues.asFloat(l);
cm.Lightness = lightness.asFloat(l);
cm.Saturation = saturation.asFloat(l);
cm.ColID = colorIDs.asString(l);
}
}
}
///======================================================
static void BuildColoredVersions(const CBuildInfo &bi)
{
if (!NLMISC::CFile::isExists(bi.InputPath))
{
nlerror("Path not found: %s", bi.InputPath.c_str());
return;
}
for(uint sizeVersion= 0; sizeVersion<2; sizeVersion++)
{
std::vector<std::string> files;
if(sizeVersion==0)
// get the original (not to dvide) dir
NLMISC::CPath::getPathContent (bi.InputPath, false, false, true, files);
else
// get the dir content with texture that must be divided by 2.
NLMISC::CPath::getPathContent (bi.InputPath+DivideBy2Dir, false, false, true, files);
// For all files found
for (uint k = 0; k < files.size(); ++k)
{
for (uint l = 0; l < bi.BitmapExtensions.size(); ++l)
{
std::string fileExt = "." + NLMISC::strupr(NLMISC::CFile::getExtension(files[k]));
if (fileExt == bi.BitmapExtensions[l])
{
//nlwarning("Processing : %s ", files[k].c_str());
try
{
if (CheckIfNeedRebuildColoredVersionForOneBitmap(bi, NLMISC::CFile::getFilename(files[k]),
sizeVersion==1) )
{
BuildColoredVersionForOneBitmap(bi,
NLMISC::CFile::getFilename(files[k]),
sizeVersion==1);
}
else
{
//nlwarning(("No need to rebuild " + NLMISC::CFile::getFilename(files[k])).c_str());
}
}
catch (const std::exception &e)
{
nlerror("Processing of %s failed: %s", files[k].c_str(), e.what());
}
}
}
}
}
}
/// used to loop throiugh the process, avoiding unused masks
struct CLoopInfo
{
NLMISC::CBitmap Mask;
uint Counter;
uint MaskID;
};
///======================================================
static bool CheckIfNeedRebuildColoredVersionForOneBitmap(const CBuildInfo &bi, const std::string &fileNameWithExtension,
bool mustDivideBy2)
{
if (bi.CachePath.empty()) return true;
uint32 srcDate = (uint32) NLMISC::CFile::getFileModificationDate(replaceSlashes(bi.InputPath + fileNameWithExtension));
static std::vector<CLoopInfo> masks;
/// check the needed masks
masks.clear();
std::string fileName = NLMISC::CFile::getFilenameWithoutExtension(fileNameWithExtension);
std::string fileExt = NLMISC::strupr(NLMISC::CFile::getExtension(fileNameWithExtension));
for (uint k = 0; k < bi.ColorMasks.size(); ++k)
{
std::string maskName = fileName + "_" + bi.ColorMasks[k].MaskExt + "." + fileExt;
std::string maskFileName = NLMISC::CPath::lookup(maskName,
false, false);
if (!maskFileName.empty()) // found the mask ?
{
CLoopInfo li;
li.Counter = 0;
li.MaskID = k;
if (NLMISC::CFile::fileExists(maskFileName))
{
srcDate = std::max(srcDate, (uint32) NLMISC::CFile::getFileModificationDate(replaceSlashes(maskFileName)));
masks.push_back(li);
}
}
}
// get hls info version that is in the cache. if not possible, must rebuild
std::string outputHLSInfo = bi.HlsInfoPath + fileName + ".hlsinfo";
std::string cacheHLSInfo = bi.CachePath + fileName + ".hlsinfo";
if (!NLMISC::CFile::fileExists(cacheHLSInfo.c_str()) )
return true;
else
{
// Must now if was moved beetween normal dir and d4/ dir.
CHLSBankTextureInfo hlsInfo;
// read .hlsInfo cache
CIFile f;
if(!f.open(cacheHLSInfo))
return true;
f.serial(hlsInfo);
f.close();
// check if same DividedBy2 Flag.
if(hlsInfo.DividedBy2!=mustDivideBy2)
return true;
// ok, can move the cache
if (!NLMISC::CFile::moveFile(outputHLSInfo, cacheHLSInfo))
{
nlerror("Couldn't move %s to %s", cacheHLSInfo.c_str(), outputHLSInfo.c_str());
return true;
}
}
/// check is each generated texture has the same date or is more recent
for(;;)
{
uint l;
std::string outputFileName = fileName;
/// build current tex name
for (l = 0; l < masks.size(); ++l)
{
uint maskID = masks[l].MaskID;
uint colorID = masks[l].Counter;
/// complete the file name
outputFileName += bi.DefaultSeparator + bi.ColorMasks[maskID].CMs[colorID].ColID;
}
// compare date
std::string searchName = replaceSlashes(bi.CachePath + outputFileName + bi.OutputFormat);
if ((uint32) NLMISC::CFile::getFileModificationDate(searchName) < srcDate)
{
return true; // not found or more old => need rebuild
}
// get version that is in the cache
std::string cacheDest = bi.OutputPath + outputFileName + bi.OutputFormat;
if (!NLMISC::CFile::moveFile(cacheDest, searchName))
{
nlerror("Couldn't move %s to %s", searchName.c_str(), cacheDest.c_str());
return true;
}
/// increment counters
for (l = 0; l < (uint) masks.size(); ++l)
{
++ (masks[l].Counter);
/// check if we have done all colors for this mask
if (masks[l].Counter == bi.ColorMasks[masks[l].MaskID].CMs.size())
{
masks[l].Counter = 0;
}
else
{
break;
}
}
if (l == masks.size()) break; // all cases dones
}
return false; // nothing to rebuild
}
///======================================================
static void BuildColoredVersionForOneBitmap(const CBuildInfo &bi, const std::string &fileNameWithExtension,
bool mustDivideBy2)
{
uint32 depth;
NLMISC::CBitmap srcBitmap;
NLMISC::CBitmap resultBitmap;
/// **** load the src bitmap
{
// where to load it.
string actualInputPath;
if(mustDivideBy2)
actualInputPath= bi.InputPath + DivideBy2Dir;
else
actualInputPath= bi.InputPath;
// load
std::string fullInputBitmapPath = actualInputPath + fileNameWithExtension;
NLMISC::CIFile is;
try
{
if (is.open(fullInputBitmapPath))
{
depth = srcBitmap.load(is);
is.close();
if (depth == 0 || srcBitmap.getPixels().empty())
{
throw NLMISC::Exception("Failed to load bitmap");
}
// if bitmap is RGBA but has an alpha channel fully transparent,
// we can save it as RGB to optimize it
if (bi.OptimizeTextures > 0 && depth == 32)
{
uint32 size = srcBitmap.getSize(0);
if (size > 0)
{
// get a pointer on original data
uint8 *data = srcBitmap.getPixels().getPtr();
// pointer on first alpha value
uint8 *tmp = data + 3;
uint8 *endData = data + size;
uint8 value = *tmp;
// check if all alphas have the same value
while(tmp < endData && *tmp == value) tmp += 4;
// texture can be converted if all alphas are 0 or 255
if (tmp >= endData && (value == 255 || value == 0))
{
if (bi.OptimizeTextures > 1)
{
// original depth is now 24 bits, since we discarded alpha channel
depth = 24;
// if texture is fully transparent, make it fully opaque
if (value == 0)
{
tmp = data + 3;
while(tmp < endData)
{
*tmp = 255;
tmp += 4;
}
}
NLMISC::COFile os;
if (os.open(fullInputBitmapPath))
{
nlwarning("Optimizing texture %s...", fullInputBitmapPath.c_str());
std::string ext = CFile::getExtension(fullInputBitmapPath);
// resave the texture in optimized same format
if (ext == "png")
{
srcBitmap.writePNG(os, 24);
}
else if (ext == "tga")
{
srcBitmap.writeTGA(os, 24);
}
else
{
nlwarning("Don't support %s format for texture, unable to save it", ext.c_str());
}
}
}
else
{
nlwarning("Texture %s can be optimized", fullInputBitmapPath.c_str());
}
}
}
}
if (srcBitmap.PixelFormat != NLMISC::CBitmap::RGBA)
{
srcBitmap.convertToType(NLMISC::CBitmap::RGBA);
}
}
else
{
nlerror("Unable to open %s. Processing next", fullInputBitmapPath.c_str());
return;
}
}
catch (const NLMISC::Exception &e)
{
nlerror("File or format error with %s (%s). Processing next...", fullInputBitmapPath.c_str(), e.what());
return;
}
}
/// **** Build and prepare build of the .hlsinfo to write.
CHLSBankTextureInfo hlsInfo;
CBitmap hlsInfoSrcBitmap;
hlsInfoSrcBitmap= srcBitmap;
// reduce size of the bitmap of LowDef shift
uint reduceShift= bi.LowDefShift;
if(reduceShift>0)
{
uint w= hlsInfoSrcBitmap.getWidth()>>reduceShift;
uint h= hlsInfoSrcBitmap.getHeight()>>reduceShift;
w= max(w, 1U);
h= max(h, 1U);
hlsInfoSrcBitmap.resample(w, h);
}
// Compress DXTC5 src bitmap
hlsInfo.SrcBitmap.build(hlsInfoSrcBitmap);
// Store info about if where in d4/ dir or not
hlsInfo.DividedBy2= mustDivideBy2;
/// **** check the needed masks
static std::vector<CLoopInfo> masks;
masks.clear();
std::string fileName = NLMISC::CFile::getFilenameWithoutExtension(fileNameWithExtension);
std::string fileExt = NLMISC::strupr(NLMISC::CFile::getExtension(fileNameWithExtension));
uint k;
for (k = 0; k < bi.ColorMasks.size(); ++k)
{
std::string maskName = fileName + "_" + bi.ColorMasks[k].MaskExt + "." + fileExt;
std::string maskFileName = NLMISC::CPath::lookup(maskName, false, false);
if (!maskFileName.empty()) // found the mask ?
{
CLoopInfo li;
li.Counter = 0;
li.MaskID = k;
/// try to load the bitmap
NLMISC::CIFile is;
try
{
if (is.open(maskFileName))
{
// masks are always opaque, if the mask is 8bits, it's in grayscale
li.Mask.loadGrayscaleAsAlpha(false);
uint8 maskDepth = li.Mask.load(is);
is.close();
if (maskDepth == 0 || li.Mask.getPixels().empty())
{
throw NLMISC::Exception("Failed to load mask");
}
// masks can be converted to grayscale files
if (bi.OptimizeTextures > 0 && maskDepth > 8)
{
if (bi.OptimizeTextures > 1)
{
NLMISC::COFile os;
if (os.open(maskFileName))
{
std::string ext = CFile::getExtension(maskFileName);
nlwarning("Optimizing mask %s...", maskFileName.c_str());
// resave the texture in optimized same format
if (ext == "png")
{
li.Mask.writePNG(os, 8);
}
else if (ext == "tga")
{
li.Mask.writeTGA(os, 8);
}
else
{
nlwarning("Don't support %s format for mask, unable to save it", ext.c_str());
}
}
}
else
{
nlwarning("Mask %s can be optimized", maskFileName.c_str());
}
}
if (li.Mask.PixelFormat != NLMISC::CBitmap::RGBA)
{
li.Mask.convertToType(NLMISC::CBitmap::RGBA);
}
/// make sure the mask has the same size
if (li.Mask.getWidth() != srcBitmap.getWidth()
|| li.Mask.getHeight() != srcBitmap.getHeight())
{
throw NLMISC::Exception("Bitmap and mask do not have the same size");
}
masks.push_back(li);
}
else
{
nlerror("Unable to open %s. Processing next", maskFileName.c_str());
return;
}
}
catch (const std::exception &e)
{
nlerror("Error with %s: %s. Aborting this bitmap processing", maskFileName.c_str(), e.what());
return;
}
}
}
// **** Add the masks to the .hlsInfo
hlsInfo.Masks.resize(masks.size());
for (k = 0; k < masks.size(); ++k)
{
CLoopInfo &li= masks[k];
CBitmap tmp= li.Mask;
tmp.resample(hlsInfoSrcBitmap.getWidth(), hlsInfoSrcBitmap.getHeight());
hlsInfo.Masks[k].build(tmp);
}
// **** generate each texture
// NB : if there are no masks the texture just will be copied
for(;;)
{
resultBitmap = srcBitmap;
uint l;
std::string outputFileName = fileName;
// Add an instance entry to the hlsInfo
uint instId= (uint)hlsInfo.Instances.size();
hlsInfo.Instances.resize(instId+1);
CHLSBankTextureInfo::CTextureInstance &hlsTextInstance= hlsInfo.Instances[instId];
hlsTextInstance.Mods.resize(masks.size());
/// build current tex
for (l = 0; l < masks.size(); ++l)
{
uint maskID = masks[l].MaskID;
uint colorID = masks[l].Counter;
/// get the color modifier
const CColorModifier &cm = bi.ColorMasks[maskID].CMs[colorID];
/// apply the mask
float deltaHueApplied;
cm.convertBitmap(resultBitmap, resultBitmap, masks[l].Mask, deltaHueApplied);
/// save the setup in hlsInfo
hlsTextInstance.Mods[l].DHue= deltaHueApplied;
hlsTextInstance.Mods[l].DLum= cm.Lightness;
hlsTextInstance.Mods[l].DSat= cm.Saturation;
/// complete the file name
outputFileName += bi.DefaultSeparator + bi.ColorMasks[maskID].CMs[colorID].ColID;
}
// save good hlsInfo instance name
hlsTextInstance.Name = outputFileName + bi.OutputFormat;
nlinfo("Writing %s", outputFileName.c_str());
/// Save the result. We let propagate exceptions (if there's no more space disk it useless to continue...)
{
std::string fullOutputPath = bi.OutputPath + "/" + outputFileName + bi.OutputFormat;
try
{
NLMISC::COFile os;
if (os.open(fullOutputPath))
{
// divide by 2 when needed.
if(mustDivideBy2)
resultBitmap.resample( (resultBitmap.getWidth()+1)/2, (resultBitmap.getHeight()+1)/2 );
// write the file
if (bi.OutputFormat == ".png")
{
resultBitmap.writePNG(os, depth);
}
else
{
resultBitmap.writeTGA(os, depth);
}
}
else
{
nlerror("Couldn't open %s for writing", fullOutputPath.c_str());
}
}
catch(const NLMISC::EStream &e)
{
nlerror("Couldn't write %s: %s", fullOutputPath.c_str(), e.what());
}
}
/// increment counters
for (l = 0; l < (uint) masks.size(); ++l)
{
++ (masks[l].Counter);
/// check if we have done all colors for this mask
if (masks[l].Counter == bi.ColorMasks[masks[l].MaskID].CMs.size())
{
masks[l].Counter = 0;
}
else
{
break;
}
}
if (l == masks.size()) break; // all cases dones
}
// **** save the TMP hlsInfo
std::string fullHlsInfoPath = bi.HlsInfoPath + fileName + ".hlsinfo";
NLMISC::COFile os;
if (os.open(fullHlsInfoPath))
{
os.serial(hlsInfo);
}
else
{
nlerror("Couldn't write %s", fullHlsInfoPath.c_str());
}
}
Reference in a new issue View git blame Copy permalink