Added checks. Yes it's horrible and needs to be refactored.

This commit is contained in:
dfighter1985 2014-08-03 04:15:12 +02:00
parent 0f2a0f4049
commit c5acb72c32
6 changed files with 305 additions and 19 deletions

View file

@ -656,6 +656,14 @@ void TileEditorMainWindow::onTabChanged( int tab )
m_ui->diffuseTrBT->setChecked( true ); m_ui->diffuseTrBT->setChecked( true );
} }
TileModel::TNodeTileType tabToType( int tabId )
{
if( tabId >= TileModel::TileNodeTypeCount )
return TileModel::TileNodeTypeCount;
return TileModel::TNodeTileType( tabId );
}
void TileEditorMainWindow::onActionAddTile(int tabId) void TileEditorMainWindow::onActionAddTile(int tabId)
{ {
QModelIndex idx = m_ui->tileSetLV->currentIndex(); QModelIndex idx = m_ui->tileSetLV->currentIndex();
@ -683,10 +691,27 @@ void TileEditorMainWindow::onActionAddTile(int tabId)
int c = n->childCount(); int c = n->childCount();
TileModel::TNodeTileType type = tabToType( tabId );
QStringListIterator itr( fileNames ); QStringListIterator itr( fileNames );
while( itr.hasNext() ) while( itr.hasNext() )
{ {
Node *newNode = TileModel::createItemNode( c, TileModel::TileDiffuse, itr.next() ); TileItemNode *newNode = TileModel::createItemNode( type, c, TileModel::TileDiffuse, itr.next() );
if( newNode->hasError() )
{
QString error = newNode->getLastError();
error += "\nContinue?";
int reply = QMessageBox::question( this,
tr( "Error adding tile" ),
error,
QMessageBox::Yes, QMessageBox::No );
if( reply != QMessageBox::Yes )
break;
else
continue;
}
n->appendRow( newNode ); n->appendRow( newNode );
c++; c++;
} }

View file

@ -22,6 +22,8 @@
#include <nel/misc/debug.h> #include <nel/misc/debug.h>
#include <nel/3d/tile_bank.h>
Node::Node() : m_parentItem(0) Node::Node() : m_parentItem(0)
{ {
} }
@ -264,18 +266,230 @@ void TileTypeNode::reindex()
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
NL3D::CTile::TBitmap channelToTBitmap( TileModel::TTileChannel channel )
{
NL3D::CTile::TBitmap bm;
switch( channel )
{
case TileModel::TileDiffuse: bm = NL3D::CTile::diffuse; break;
case TileModel::TileAdditive: bm = NL3D::CTile::additive; break;
case TileModel::TileAlpha: bm = NL3D::CTile::alpha; break;
}
return bm;
}
class TileItemNodePvt class TileItemNodePvt
{ {
public: public:
bool loadImage( TileModel::TTileChannel channel, const QString &fn ) TileItemNodePvt()
{
for( int i = 0; i < TileModel::TileChannelCount; i++ )
m_borderFirst[ i ] = false;
m_id = -1;
}
bool pixmapToCBGRA( QPixmap &pixmap, std::vector< NLMISC::CBGRA >& pixels )
{
QImage img = pixmap.toImage();
if( img.format() != QImage::Format_ARGB32 )
img = img.convertToFormat( QImage::Format_ARGB32 );
if( img.format() != QImage::Format_ARGB32 )
return false;
int c = img.width() * img.height();
const unsigned char *data = img.bits();
const unsigned int *idata = reinterpret_cast< const unsigned int* >( data );
NLMISC::CBGRA bgra;
pixels.clear();
int i = 0;
while( i < c )
{
bgra.A = ( idata[ i ] & 0xFF000000 ) >> 24;
bgra.R = ( idata[ i ] & 0x00FF0000 ) >> 16;
bgra.G = ( idata[ i ] & 0x0000FF00 ) >> 8;
bgra.B = ( idata[ i ] & 0x000000FF );
pixels.push_back( bgra );
i++;
}
return true;
}
int getWidthForType( TileModel::TNodeTileType type, TileModel::TTileChannel channel )
{
int width = -1;
switch( type )
{
case TileModel::Tile128: width = 128; break;
case TileModel::Tile256: width = 256; break;
case TileModel::TileTransition:
{
if( channel != TileModel::TileAlpha )
width = 128;
break;
}
case TileModel::TileDisplacement: width = 32; break;
}
return width;
}
NL3D::CTileSet::TError checkTile( TileModel::TTileChannel channel )
{
if( m_type == TileModel::TileDisplacement )
return NL3D::CTileSet::ok;
if( channel == TileModel::TileAdditive )
return NL3D::CTileSet::ok;
int pixel;
int component;
int index;
NL3D::CTileSet set;
NL3D::CTile::TBitmap bm = channelToTBitmap( channel );
NL3D::CTileSet::TError error = NL3D::CTileSet::ok;
switch( m_type )
{
case TileModel::Tile128:
error = set.checkTile128( bm, m_border[ channel ], pixel, component );
break;
case TileModel::Tile256:
error = set.checkTile256( bm, m_border[ channel ], pixel, component );
break;
case TileModel::TileTransition:
if( channel != TileModel::TileAlpha )
error = set.checkTile128( bm, m_border[ channel ], pixel, component );
else
error = set.checkTileTransition( NL3D::CTileSet::TTransition( m_id ), bm, m_border[ channel ], index, pixel, component );
break;
}
if( error == NL3D::CTileSet::ok )
return NL3D::CTileSet::ok;
if( error == NL3D::CTileSet::addFirstA128128 )
return NL3D::CTileSet::addFirstA128128;
/*
enum TError { ok=0, topInterfaceProblem, bottomInterfaceProblem, leftInterfaceProblem,
rightInterfaceProblem, addFirstA128128, topBottomNotTheSame, rightLeftNotTheSame,
sizeInvalide, errorCount };
*/
static const char* comp[]={"Red", "Green", "Blue", "Alpha", ""};
if( error != NL3D::CTileSet::ok )
{
m_lastError = "ERROR: ";
m_lastError += NL3D::CTileSet::getErrorMessage( error );
m_lastError += "\n";
switch( m_type )
{
case TileModel::Tile128:
case TileModel::Tile256:
m_lastError += QString( "pixel: %1 component: %2" ).arg( pixel ).arg( comp[ component ] );
break;
case TileModel::TileTransition:
if( channel != TileModel::TileAlpha )
{
m_lastError += QString( "pixel: %1 component: %2" ).arg( pixel ).arg( comp[ component ] );
}
else
{
if ((error==NL3D::CTileSet::topInterfaceProblem)||(error==NL3D::CTileSet::bottomInterfaceProblem)||
(error==NL3D::CTileSet::leftInterfaceProblem)||(error==NL3D::CTileSet::rightInterfaceProblem)||
(error==NL3D::CTileSet::topBottomNotTheSame)||(error==NL3D::CTileSet::rightLeftNotTheSame)
||(error==NL3D::CTileSet::topInterfaceProblem))
{
if( index != -1 )
{
m_lastError += QString( "tile: %1 pixel: %2 component: %3" ).arg( index ).arg( pixel ).arg( comp[ component ] );
}
else
{
m_lastError += QString( "incompatible with a 128 tile, pixel: %1 component: %2" ).arg( pixel ).arg( comp[ component ] );
}
}
}
break;
}
}
return error;
}
bool checkPixmap( TileModel::TTileChannel channel, QPixmap &pixmap )
{
int w = pixmap.width();
int h = pixmap.height();
if( w != h )
{
m_lastError = QObject::tr( "Not a square texture." );
return false;
}
int width = getWidthForType( m_type, channel );
if( width != -1 )
{
if( width != w )
{
m_lastError = QObject::tr( "Not the proper size." );
return false;
}
}
std::vector< NLMISC::CBGRA > pixels;
pixmapToCBGRA( pixmap, pixels );
m_border[ channel ].set( w, h, pixels );
NL3D::CTileSet::TError error = checkTile( channel );
if( error == NL3D::CTileSet::addFirstA128128 )
{
m_borderFirst[ channel ] = true;
return true;
}
if( error != NL3D::CTileSet::ok )
return false;
return true;
}
bool loadImage( TileModel::TTileChannel channel, const QString &fn, bool empty = false )
{ {
QPixmap temp; QPixmap temp;
bool b = temp.load( fn ); bool b = temp.load( fn );
if( !b ) if( !b )
{
m_lastError = QObject::tr( "Cannot open file %1" ).arg( fn );
return false; return false;
}
if( !empty )
{
if( !checkPixmap( channel, temp ) )
return false;
}
pixmaps[ channel ] = temp; pixmaps[ channel ] = temp;
@ -291,19 +505,34 @@ public:
return pixmaps[ channel ]; return pixmaps[ channel ];
} }
void setType( TileModel::TNodeTileType type ){ m_type = type; }
void setId( int id ){ m_id = id; }
int id() const{ return m_id; }
QString getLastError() const{ return m_lastError; }
bool borderFirst( TileModel::TTileChannel channel ) const{ return m_borderFirst[ channel ]; }
private: private:
QPixmap pixmaps[ TileModel::TileChannelCount ]; QPixmap pixmaps[ TileModel::TileChannelCount ];
TileModel::TNodeTileType m_type;
NL3D::CTileBorder m_border[ TileModel::TileChannelCount ];
int m_id;
QString m_lastError;
bool m_borderFirst[ TileModel::TileChannelCount ];
}; };
TileModel::TTileChannel TileItemNode::s_displayChannel = TileModel::TileDiffuse; TileModel::TTileChannel TileItemNode::s_displayChannel = TileModel::TileDiffuse;
TileItemNode::TileItemNode(int tileId, TileModel::TTileChannel channel, QString filename, Node *parent) : m_tileId(tileId) TileItemNode::TileItemNode( TileModel::TNodeTileType type, int tileId, TileModel::TTileChannel channel, QString filename, Node *parent)
{ {
m_parentItem = parent; m_parentItem = parent;
//nlinfo("dispalying tile %d - %s", m_tileId, m_tileFilename[TileModel::TileDiffuse].toAscii().data()); //nlinfo("dispalying tile %d - %s", m_tileId, m_tileFilename[TileModel::TileDiffuse].toAscii().data());
pvt = new TileItemNodePvt(); pvt = new TileItemNodePvt();
pvt->setType( type );
pvt->setId( tileId );
m_hasError = false;
setTileFilename( channel, filename ); setTileFilename( channel, filename );
} }
@ -319,11 +548,16 @@ TileItemNode::~TileItemNode()
bool TileItemNode::setTileFilename(TileModel::TTileChannel channel, QString filename) bool TileItemNode::setTileFilename(TileModel::TTileChannel channel, QString filename)
{ {
QString fn = filename; QString fn = filename;
bool empty = false;
if( filename.isEmpty() || ( filename == "empty" ) ) if( filename.isEmpty() || ( filename == "empty" ) )
{
fn = ":/placeHolder/images/empty_image.png"; fn = ":/placeHolder/images/empty_image.png";
empty = true;
}
bool b = pvt->loadImage( channel, fn ); bool b = pvt->loadImage( channel, fn, empty );
m_hasError = !b;
if( !b ) if( !b )
return false; return false;
@ -341,6 +575,26 @@ QString TileItemNode::getTileFilename(TileModel::TTileChannel channel)
return itr.value(); return itr.value();
} }
void TileItemNode::setId( int id )
{
pvt->setId( id );
}
int TileItemNode::id() const
{
return pvt->id();
}
QString TileItemNode::getLastError() const
{
return pvt->getLastError();
}
bool TileItemNode::borderFirst() const
{
return false;
}
QVariant TileItemNode::data(int column, int role) const QVariant TileItemNode::data(int column, int role) const
{ {
QString tileFilename = m_tileFilename[ TileItemNode::s_displayChannel ]; QString tileFilename = m_tileFilename[ TileItemNode::s_displayChannel ];
@ -375,11 +629,11 @@ QVariant TileItemNode::data(int column, int role) const
} }
else if(role == TileModel::TileIndexRole) else if(role == TileModel::TileIndexRole)
{ {
return QVariant("("+QString::number(m_tileId)+")"); return QVariant("("+QString::number(pvt->id())+")");
} }
else if(role == TileModel::TileFilenameIndexRole) else if(role == TileModel::TileFilenameIndexRole)
{ {
return QVariant(tileFilename + " ("+QString::number(m_tileId)+")"); return QVariant(tileFilename + " ("+QString::number(pvt->id())+")");
} }
return QVariant(); return QVariant();

View file

@ -109,26 +109,31 @@ class TileItemNodePvt;
class TileItemNode : public Node class TileItemNode : public Node
{ {
public: public:
TileItemNode(int tileId, TileModel::TTileChannel channel, QString filename, Node *parent=0); TileItemNode( TileModel::TNodeTileType type, int tileId, TileModel::TTileChannel channel, QString filename, Node *parent=0);
virtual ~TileItemNode(); virtual ~TileItemNode();
QVariant data(int column, int role) const; QVariant data(int column, int role) const;
int columnCount() const; int columnCount() const;
bool setTileFilename(TileModel::TTileChannel channel, QString filename); bool setTileFilename(TileModel::TTileChannel channel, QString filename);
QString getTileFilename(TileModel::TTileChannel channel); QString getTileFilename(TileModel::TTileChannel channel);
void setId( int id ){ m_tileId = id; } void setId( int id );
int id() const{ return m_tileId; } int id() const;
QString getLastError() const;
bool borderFirst() const;
static void setDisplayChannel( TileModel::TTileChannel channel ){ s_displayChannel = channel; } static void setDisplayChannel( TileModel::TTileChannel channel ){ s_displayChannel = channel; }
static TileModel::TTileChannel displayChannel(){ return s_displayChannel; } static TileModel::TTileChannel displayChannel(){ return s_displayChannel; }
bool hasError() const{ return m_hasError; }
private: private:
int m_tileId;
QMap<TileModel::TTileChannel, QString> m_tileFilename; QMap<TileModel::TTileChannel, QString> m_tileFilename;
QMap<TileModel::TTileChannel, TileWidget*> m_tileWidget; QMap<TileModel::TTileChannel, TileWidget*> m_tileWidget;
static TileModel::TTileChannel s_displayChannel; static TileModel::TTileChannel s_displayChannel;
TileItemNodePvt *pvt; TileItemNodePvt *pvt;
bool m_hasError;
}; };
#endif // TILE_ITEM_H #endif // TILE_ITEM_H

View file

@ -197,7 +197,7 @@ TileSetNode *TileModel::createTileSetNode(QString tileSetName)
// TODO tie this to CTileSet::count from NeL // TODO tie this to CTileSet::count from NeL
for(int transPos=0; transPos<48; transPos++) for(int transPos=0; transPos<48; transPos++)
{ {
TileItemNode *transTile= new TileItemNode(transPos, TileDiffuse, QString("empty")); TileItemNode *transTile= new TileItemNode( TileModel::TileTransition, transPos, TileDiffuse, QString("empty"));
tileTrans->appendRow(transTile); tileTrans->appendRow(transTile);
} }
@ -209,7 +209,7 @@ TileSetNode *TileModel::createTileSetNode(QString tileSetName)
// TODO tie this to CTileSet::CountDisplace from NeL // TODO tie this to CTileSet::CountDisplace from NeL
for(int dispPos=0; dispPos<16; dispPos++) for(int dispPos=0; dispPos<16; dispPos++)
{ {
TileItemNode *dispTile= new TileItemNode(dispPos, TileDiffuse, QString("empty")); TileItemNode *dispTile= new TileItemNode( TileModel::TileDisplacement, dispPos, TileDiffuse, QString("empty"));
tileDisp->appendRow(dispTile); tileDisp->appendRow(dispTile);
} }
@ -219,9 +219,9 @@ TileSetNode *TileModel::createTileSetNode(QString tileSetName)
return tileSet; return tileSet;
} }
Node *TileModel::createItemNode( int id, TTileChannel channel, const QString &fileName ) TileItemNode *TileModel::createItemNode( TileModel::TNodeTileType type, int id, TTileChannel channel, const QString &fileName )
{ {
return new TileItemNode( id, channel, fileName ); return new TileItemNode( type, id, channel, fileName );
} }
const char *TileModel::getTileTypeName(TileModel::TNodeTileType type) const char *TileModel::getTileTypeName(TileModel::TNodeTileType type)

View file

@ -23,6 +23,7 @@
class Node; class Node;
class TileSetNode; class TileSetNode;
class TileItemNode;
class TileModel : public QAbstractItemModel class TileModel : public QAbstractItemModel
{ {
@ -42,7 +43,8 @@ public:
Tile128 = 0, Tile128 = 0,
Tile256 = 1, Tile256 = 1,
TileTransition = 2, TileTransition = 2,
TileDisplacement = 3 TileDisplacement = 3,
TileNodeTypeCount = 4
}; };
enum TTileItemRole enum TTileItemRole
@ -85,7 +87,7 @@ public:
void swapRows( int a, int b ); void swapRows( int a, int b );
TileSetNode *createTileSetNode(QString tileSetName); TileSetNode *createTileSetNode(QString tileSetName);
static Node *createItemNode( int id, TTileChannel channel, const QString &fileName ); static TileItemNode *createItemNode( TileModel::TNodeTileType type, int id, TTileChannel channel, const QString &fileName );
static const char *getTileTypeName(TNodeTileType type); static const char *getTileTypeName(TNodeTileType type);
static uint32 getTileTypeSize(TileModel::TNodeTileType type); static uint32 getTileTypeSize(TileModel::TNodeTileType type);

View file

@ -75,7 +75,7 @@ public:
int idx = set->getTile128( i ); int idx = set->getTile128( i );
NL3D::CTile *tile = bank.getTile( idx ); NL3D::CTile *tile = bank.getTile( idx );
TileItemNode *tin = new TileItemNode( i, TileModel::TileDiffuse, "" ); TileItemNode *tin = new TileItemNode( TileModel::Tile128, i, TileModel::TileDiffuse, "" );
for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ ) for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ )
{ {
@ -94,7 +94,7 @@ public:
int idx = set->getTile256( i ); int idx = set->getTile256( i );
NL3D::CTile *tile = bank.getTile( idx ); NL3D::CTile *tile = bank.getTile( idx );
TileItemNode *tin = new TileItemNode( i, TileModel::TileDiffuse, "" ); TileItemNode *tin = new TileItemNode( TileModel::Tile256, i, TileModel::TileDiffuse, "" );
for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ ) for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ )
{ {