aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-30 21:00:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/tools/3d/tile_edit_qt/browser_model.cpp

760 lines
21 KiB
C++
Raw Normal View History

Changed: Create .desktop file under Linux, see #279
2016-07-25 16:27:53 +00:00
// 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 "common.h"
#include "browser_model.h"
using namespace std;
using namespace NL3D;
using namespace NLMISC;
extern CTileBank tileBankBrowser;
static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
static bool loadPic(const string &path, std::vector<NLMISC::CBGRA> &tampon, uint &width, uint &height)
{
try
{
NLMISC::CIFile file;
if (file.open(path.c_str()))
{
NLMISC::CBitmap bitmap;
bitmap.load(file);
width = bitmap.getWidth();
height = bitmap.getHeight();
tampon.resize(width * height);
bitmap.convertToType(NLMISC::CBitmap::RGBA);
for (uint y = 0; y < height; ++y)
{
for (uint x = 0; x < width; ++x)
{
NLMISC::CRGBA c = bitmap.getPixelColor(x, y, 0);
c.R = (c.R * c.A) / 255;
c.G = (c.G * c.A) / 255;
c.B = (c.B * c.A) / 255;
tampon[(y * width) + x] = c;
}
}
return true;
}
}
Changed: Constification of catches
2016-11-20 11:31:48 +00:00
catch (const NLMISC::Exception& ) { }
Changed: Create .desktop file under Linux, see #279
2016-07-25 16:27:53 +00:00
return false;
}
bool RemovePath (std::string& path, const char* absolutePathToRemplace);
// Rotate a buffer
void rotateBuffer (std::vector<NLMISC::CBGRA> &Buffer, uint &Width, uint &Height)
{
// Make a copy
std::vector<NLMISC::CBGRA> copy = Buffer;
// Rotate
for (uint y=0; y<Width; y++)
{
// Line offset
uint tmp=y*Width;
for (uint x=0; x<Width; x++)
{
Buffer[y+(Width-x-1)*Height]=copy[x+tmp];
}
}
// New size
uint tmp=Width;
Width=Height;
Height=tmp;
}
/////////////////////////////////////////////////////////////////////////////
// Load a Pic and apply Alpha & Rotation
int loadPixmapBuffer(const std::string& path, std::vector<NLMISC::CBGRA>& Buffer, std::vector<NLMISC::CBGRA>* Alpha, int rot)
{
uint Width;
uint Height;
if (loadPic(path, Buffer, Width, Height))
{
while (rot)
{
// Rotate the buffer
rotateBuffer (Buffer, Width, Height);
rot--;
}
if ( (Alpha) && (Alpha->size()==Buffer.size()) )
{
// Pre mul RGB componates by Alpha one
int nPixelCount=(int)(Width*Height);
for (int p=0; p<nPixelCount; p++)
{
// Invert alpha ?
int alpha=(*Alpha)[p].A;
Buffer[p].R=(uint8)(((int)Buffer[p].R*alpha)>>8);
Buffer[p].G=(uint8)(((int)Buffer[p].G*alpha)>>8);
Buffer[p].B=(uint8)(((int)Buffer[p].B*alpha)>>8);
}
}
return 1;
}
else
return 0;
}
/////////////////////////////////////////////////////////////////////////////
//TileInfo
TileInfo::TileInfo():tileType(UnSet)
{
this->loaded = 0;
this->nightLoaded = 0;
this->alphaLoaded = 0;
}
TileInfo::TileInfo(int id, TileType tileType):id(id), tileType(tileType)
{
this->loaded = 0;
this->nightLoaded = 0;
this->alphaLoaded = 0;
}
void TileInfo::Init(int id, TileType tileType)
{
this->id = id;
this->tileType = tileType;
this->loaded = 0;
this->nightLoaded = 0;
this->alphaLoaded = 0;
}
bool TileInfo::Load (int index, std::vector<NLMISC::CBGRA>* Alpha)
{
bool bRes=true;
if (!loaded && getRelativeFileName (Diffuse, index)!="")
{
path = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (Diffuse, index));
if ( !loadPixmapBuffer( path, Bits, Alpha, 0))
{
bRes=false;
QMessageBox::information( NULL, QObject::tr("Can't load Diffuse file"), QString( (path.c_str()) ));
}
else
loaded=1;
}
if (!nightLoaded && getRelativeFileName (Additive, index)!="")
{
nightPath = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (Additive, index));
if (!loadPixmapBuffer( nightPath, nightBits, Alpha, 0))
{
bRes=false;
QMessageBox::information( NULL, QObject::tr("Can't load Additive file"), QString( nightPath.c_str() ) );
}
else
nightLoaded=1;
}
if (!alphaLoaded && getRelativeFileName (::Alpha, index)!="")
{
alphaPath = fixPath(tileBankBrowser.getAbsPath() + getRelativeFileName (::Alpha, index));
if (!loadPixmapBuffer( alphaPath, alphaBits, NULL, tileBankBrowser.getTile (index)->getRotAlpha ()))
{
bRes=false;
QMessageBox::information( NULL, QObject::tr("Can't load Alpha file"), QString( alphaPath.c_str() ) );
}
else
alphaLoaded=1;
}
return bRes;
}
std::string TileInfo::fixPath(const std::string &path) {
// Fix the Windows path issues for subpaths.
std::string searchStr("\\");
std::string replaceStr("/");
string::size_type pos = 0;
std::string pathStr = path;
while( (pos = pathStr.find(searchStr, pos)) != std::string::npos) {
pathStr.replace(pos, searchStr.size(), replaceStr);
pos++;
}
return pathStr;
}
void TileInfo::Delete ()
{
loaded=0;
Bits.resize(0);
nightLoaded=0;
nightBits.resize(0);
alphaLoaded=0;
alphaBits.resize(0);
}
const std::string TileInfo::getRelativeFileName (TileTexture texture, int index)
{
nlassert(this->tileType != UnSet);
std::string currentPath;
if (tileType != Displace)
{
currentPath = tileBankBrowser.getTile(index)->getRelativeFileName ((CTile::TBitmap)texture);
}
else
{
if (texture == Diffuse)
{
currentPath = tileBankBrowser.getDisplacementMap(index);
//TODO titegus: remove MAGIC STRING "EmptyDisplacementMap" in Nel \tile_bank.cpp\void CTileNoise::setEmpty () or add an IsEmpty() method !!!!
if (currentPath == "EmptyDisplacementMap")
currentPath = "";
}
}
return currentPath;
}
//TileList
TileList::TileList()
{
_tileSet = -1;
// Add 48 transitions
int i;
for (i=0; i<CTileSet::count; i++)
{
TileInfo info(i, Transition);
theListTransition.push_back (info);
}
// Add 16 displacements
for (i=0; i<CTileSet::CountDisplace; i++)
{
TileInfo info(i, Displace);
theListDisplacement.push_back (info);
}
}
int TileList::addTile128 ()
{
int index;
tileBankBrowser.getTileSet (_tileSet)->addTile128 (index, tileBankBrowser);
nlassert (index==(sint)theList128.size());
TileInfo info(index, _128x128);
theList128.push_back (info);
return index;
}
int TileList::addTile256 ()
{
int index;
tileBankBrowser.getTileSet (_tileSet)->addTile256 (index, tileBankBrowser);
nlassert (index==(sint)theList256.size());
TileInfo info(index, _256x256);
theList256.push_back (info);
return index;
}
bool TileList::setTile128 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
{
// Remove the absolute path from the path name
std::string troncated = name;
if (RemovePath(troncated, tileBankBrowser.getAbsPath ().c_str()))
{
vector<NLMISC::CBGRA> tampon;
uint Width;
uint Height;
if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
{
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."), QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No));
}
else
{
CTileBorder border;
border.set (Width, Height, tampon);
CTileSet::TError error;
int pixel=-1;
int composante=4;
if (type == CTile::additive)
error=CTileSet::ok;
else
error=tileBankBrowser.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128))
{
QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), pixelMessage, QMessageBox::Yes | QMessageBox::No) );
}
else
{
if (error==CTileSet::addFirstA128128)
tileBankBrowser.getTileSet(_tileSet)->setBorder (type, border);
tileBankBrowser.getTileSet(_tileSet)->setTile128 (tile, troncated, type, tileBankBrowser);
switch (type)
{
case CTile::diffuse:
theList128[tile].loaded=0;
break;
case CTile::additive:
theList128[tile].nightLoaded=0;
break;
case CTile::alpha:
theList128[tile].alphaLoaded=0;
break;
default:
break;
}
Reload(tile, tile + 1, _128x128);
}
}
}
else
{
// Error: bitmap not in the absolute path..
QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"), notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No));
}
return true;
}
bool TileList::setTile256 (int tile, const std::string& name, NL3D::CTile::TBitmap type)
{
// Remove the absolute path from the path name
std::string troncated=name;
if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
{
vector<NLMISC::CBGRA> tampon;
uint Width;
uint Height;
if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
{
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."), QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
}
else
{
CTileBorder border;
border.set (Width, Height, tampon);
CTileSet::TError error;
int pixel=-1;
int composante=4;
if (type == CTile::additive)
error=CTileSet::ok;
else
error=tileBankBrowser.getTileSet(_tileSet)->checkTile256 (type, border, pixel, composante);
if ((error!=CTileSet::ok))
{
QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), pixelMessage, QMessageBox::Yes | QMessageBox::No) );
}
else
{
tileBankBrowser.getTileSet(_tileSet)->setTile256 (tile, troncated, type, tileBankBrowser);
switch (type)
{
case CTile::diffuse:
theList256[tile].loaded=0;
break;
case CTile::additive:
theList256[tile].nightLoaded=0;
break;
case CTile::alpha:
theList256[tile].alphaLoaded=0;
break;
default:
break;
}
Reload(tile, tile + 1, _256x256);
}
}
}
else
{
// Error: bitmap not in the absolute path..
QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"), notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No));
}
return true;
}
bool TileList::setTileTransition (int tile, const std::string& name, NL3D::CTile::TBitmap type)
{
// Remove the absolute path from the path name
std::string troncated=name;
if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
{
// No alpha, use setTileTransitionAlpha
nlassert (CTile::alpha!=type);
vector<NLMISC::CBGRA> tampon;
uint Width;
uint Height;
if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
{
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap."), QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
}
else
{
CTileBorder border;
border.set (Width, Height, tampon);
CTileSet::TError error;
int pixel=-1;
int composante=4;
if (type == CTile::additive)
error=CTileSet::ok;
else
error=tileBankBrowser.getTileSet(_tileSet)->checkTile128 (type, border, pixel, composante);
if ((error!=CTileSet::ok)&&(error!=CTileSet::addFirstA128128))
{
QString pixelMessage = QObject::tr("%1\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), pixelMessage, QMessageBox::Yes | QMessageBox::No) );
}
else
{
if (error==CTileSet::addFirstA128128)
tileBankBrowser.getTileSet(_tileSet)->setBorder (type, border);
tileBankBrowser.getTileSet(_tileSet)->setTileTransition ((CTileSet::TTransition)tile, troncated, type, tileBankBrowser, border);
switch (type)
{
case CTile::diffuse:
theListTransition[tile].loaded=0;
break;
case CTile::additive:
theListTransition[tile].nightLoaded=0;
break;
case CTile::alpha:
theListTransition[tile].alphaLoaded=0;
break;
default:
break;
}
Reload(tile, tile + 1, Transition);
}
}
}
else
{
// Error: bitmap not in the absolute path..
QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"), notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
}
return true;
}
bool TileList::setDisplacement (int tile, const std::string& name, NL3D::CTile::TBitmap type)
{
// Remove the absolute path from the path name
std::string troncated=name;
if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
{
vector<NLMISC::CBGRA> tampon;
uint Width;
uint Height;
if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
{
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap"), QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
}
else
{
// Check the size
if ( (Width!=32) || (Height!=32) )
{
// Error message
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), QString( (troncated+"\nInvalid size: displacement map must be 32x32 8 bits.\nContinue ?").c_str()), QMessageBox::Yes | QMessageBox::No) );
}
else
{
// change the file name of the displacement map
tileBankBrowser.getTileSet(_tileSet)->setDisplacement ((CTileSet::TDisplacement)tile, troncated, tileBankBrowser);
// Loaded
theListDisplacement[tile].loaded=0;
Reload(tile, tile + 1, Displace);
}
}
}
else
{
// Error: bitmap not in the absolute path..
QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"), notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
}
return true;
}
bool TileList::setTileTransitionAlpha (int tile, const std::string& name, int rot)
{
// Remove the absolute path from the path name
std::string troncated=name;
if (RemovePath (troncated, tileBankBrowser.getAbsPath ().c_str()))
{
vector<NLMISC::CBGRA> tampon;
uint Width;
uint Height;
if (!loadPic(tileBankBrowser.getAbsPath ()+troncated, tampon, Width, Height))
{
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't load bitmap"), QString( ((tileBankBrowser.getAbsPath ()+troncated)+"\nContinue ?").c_str() ), QMessageBox::Yes | QMessageBox::No) );
}
else
{
CTileBorder border;
border.set (Width, Height, tampon);
// rotate the border
int rotBis=rot;
while (rotBis)
{
border.rotate ();
rotBis--;
}
CTileSet::TError error;
int indexError;
int pixel=-1;
int composante=4;
if (((error=tileBankBrowser.getTileSet(_tileSet)->checkTileTransition ((CTileSet::TTransition)tile, CTile::alpha, border, indexError,
pixel, composante))!=CTileSet::ok))
{
QString pixelMessage;
if ((error==CTileSet::topInterfaceProblem)||(error==CTileSet::bottomInterfaceProblem)||(error==CTileSet::leftInterfaceProblem)
||(error==CTileSet::rightInterfaceProblem)||(error==CTileSet::topBottomNotTheSame)||(error==CTileSet::rightLeftNotTheSame)
||(error==CTileSet::topInterfaceProblem))
{
if (indexError!=-1)
pixelMessage = QObject::tr("%1.\nIncompatible with tile nb %4.\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]).arg(indexError);
else
pixelMessage = QObject::tr("%1.\nIncompatible with the 128x128 tile.\nPixel: %2(%3).\nContinue ?").arg(CTileSet::getErrorMessage (error)).arg(pixel).arg(comp[composante]);
}
else
pixelMessage = QObject::tr("%1.\nIncompatible filled tile.\nContinue ?").arg(CTileSet::getErrorMessage (error));
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Can't set Bitmap"), pixelMessage, QMessageBox::Yes | QMessageBox::No) );
}
else
{
tileBankBrowser.getTileSet(_tileSet)->setTileTransitionAlpha ((CTileSet::TTransition)tile, troncated, tileBankBrowser, border, rot);
theListTransition[tile].alphaLoaded=0;
theListTransition[tile].Load (tileBankBrowser.getTileSet(_tileSet)->getTransition(tile)->getTile(), NULL);
}
}
}
else
{
// Error: bitmap not in the absolute path..
QString notInAbsolutePathMessage = QObject::tr("The bitmap %1 is not in the absolute path %2.\nContinue ?").arg(name.c_str()).arg(tileBankBrowser.getAbsPath ().c_str());
return ( QMessageBox::Yes == QMessageBox::question( NULL, QObject::tr("Load error"), notInAbsolutePathMessage, QMessageBox::Yes | QMessageBox::No) );
}
return true;
}
void TileList::removeTile128 (int index)
{
tileBankBrowser.getTileSet (_tileSet)->removeTile128 (index, tileBankBrowser);
theList[0].erase (theList[0].begin()+index);
for (int i=0; i<(sint)theList[0].size(); i++)
{
theList[0][i].setId(i);
}
}
void TileList::removeTile256 (int index)
{
tileBankBrowser.getTileSet (_tileSet)->removeTile256 (index, tileBankBrowser);
theList[1].erase (theList[1].begin()+index);
for (int i=0; i<(sint)theList[1].size(); i++)
{
theList[1][i].setId(i);
}
}
void TileList::clearTile128 (int index, CTile::TBitmap bitmap)
{
switch (bitmap)
{
case CTile::diffuse:
theList128[index].loaded=0;
theList128[index].Bits.resize(0);
break;
case CTile::additive:
theList128[index].nightLoaded=0;
theList128[index].nightBits.resize(0);
break;
case CTile::alpha:
nlassert(0);
break;
default:
break;
}
tileBankBrowser.getTileSet (_tileSet)->clearTile128 (index, bitmap, tileBankBrowser);
}
void TileList::clearTile256 (int index, CTile::TBitmap bitmap)
{
switch (bitmap)
{
case CTile::diffuse:
theList256[index].loaded=0;
theList256[index].Bits.resize(0);
break;
case CTile::additive:
theList256[index].nightLoaded=0;
theList256[index].nightBits.resize(0);
break;
case CTile::alpha:
nlassert(0);
break;
default:
break;
}
tileBankBrowser.getTileSet (_tileSet)->clearTile256 (index, bitmap, tileBankBrowser);
}
void TileList::clearTransition (int index, CTile::TBitmap bitmap)
{
switch (bitmap)
{
case CTile::diffuse:
theListTransition[index].loaded=0;
theListTransition[index].Bits.resize(0);
break;
case CTile::additive:
theListTransition[index].nightLoaded=0;
theListTransition[index].nightBits.resize(0);
break;
case CTile::alpha:
theListTransition[index].alphaLoaded=0;
theListTransition[index].alphaBits.resize(0);
break;
default:
break;
}
tileBankBrowser.getTileSet (_tileSet)->clearTransition ((CTileSet::TTransition)index, bitmap, tileBankBrowser);
}
void TileList::clearDisplacement (int index, CTile::TBitmap bitmap)
{
switch (bitmap)
{
case CTile::diffuse:
theListDisplacement[index].loaded=0;
theListDisplacement[index].Bits.resize(0);
break;
case CTile::additive:
nlassert(0);
break;
case CTile::alpha:
nlassert(0);
break;
default:
break;
}
tileBankBrowser.getTileSet (_tileSet)->clearDisplacement ((CTileSet::TDisplacement)index, tileBankBrowser);
}
tilelist::iterator TileList::GetFirst(int n)
{
return theList[n].begin();
}
tilelist::iterator TileList::GetLast(int n)
{
return theList[n].end();
}
tilelist::iterator TileList::Get(int i, int n)
{
return theList[n].begin()+i;
}
int TileList::GetSize(int n)
{
return (int)theList[n].size();
}
void TileList::Reload(int first, int last, TileType n) //recharge en memoire une tranche de tiles
{
for (int i=first; i<last; i++)
{
switch (n)
{
case _128x128:
{
theList[n][i].Load (tileBankBrowser.getTileSet(_tileSet)->getTile128 (i), NULL);
break;
}
case _256x256:
{
theList[n][i].Load (tileBankBrowser.getTileSet(_tileSet)->getTile256 (i), NULL);
break;
}
case Transition:
{
int index=tileBankBrowser.getTileSet(_tileSet)->getTransition (i)->getTile();
if (index!=-1)
theList[n][i].Load (index, &theListTransition[i].alphaBits);
break;
}
case Displace:
{
int index=tileBankBrowser.getTileSet(_tileSet)->getDisplacementTile ((CTileSet::TDisplacement)i);
if (index!=-1)
theList[n][i].Load (index, NULL);
break;
}
default:
break;
}
}
}
Reference in a new issue Copy permalink