diff --git a/code/nel/include/nel/3d/tile_bank.h b/code/nel/include/nel/3d/tile_bank.h
index f391554d3..89b8e2272 100644
--- a/code/nel/include/nel/3d/tile_bank.h
+++ b/code/nel/include/nel/3d/tile_bank.h
@@ -172,6 +172,8 @@ public:
 		return _TileSet.find (name)!=_TileSet.end();
 	}
 
+	void clear(){ _TileSet.clear(); }
+
 	void    serial(class NLMISC::IStream &f) throw(NLMISC::EStream);
 private:
 
diff --git a/code/studio/src/plugins/tile_editor/tile_bank.cpp b/code/studio/src/plugins/tile_editor/tile_bank.cpp
new file mode 100644
index 000000000..f98b4ef38
--- /dev/null
+++ b/code/studio/src/plugins/tile_editor/tile_bank.cpp
@@ -0,0 +1,110 @@
+#include "tile_bank.h"
+#include "nel/3d/tile_bank.h"
+
+#include <QPixmap>
+
+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;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+class TileBankPvt
+{
+public:
+	NL3D::CTileBank m_bank;
+};
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+TileBank::TileBank()
+{
+	m_pvt = new TileBankPvt();
+}
+
+TileBank::~TileBank()
+{
+	delete m_pvt;
+}
+
+void TileBank::addTileSet( const QString &name )
+{
+	m_pvt->m_bank.addTileSet( name.toUtf8().constData() );
+	NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( 0 );
+}
+
+void TileBank::addLand( const QString &name )
+{
+	m_pvt->m_bank.addLand( name.toUtf8().constData() );
+}
+
+void TileBank::setLandSets( int idx, const QStringList &l )
+{
+	NL3D::CTileLand *land = m_pvt->m_bank.getLand( idx );
+	land->clear();
+
+	QStringListIterator itr( l );
+	while( itr.hasNext() )
+	{
+		land->addTileSet( itr.next().toUtf8().constData() );
+	}
+}
+
+bool TileBank::addTileToSet( int idx, const QString &name, const QVariant &pixmap, TileConstants::TTileChannel channel, TileConstants::TNodeTileType type )
+{
+	NL3D::CTileSet *set = m_pvt->m_bank.getTileSet( idx );
+	if( set == NULL )
+		return false;
+
+	QPixmap pm = pixmap.value< QPixmap >();
+	if( pm.isNull() )
+		return false;
+
+	if( pm.width() != pm.height() )
+		return false;
+
+	std::vector< NLMISC::CBGRA > pixels;
+	pixmapToCBGRA( pm, pixels );
+
+	int tile;
+	set->addTile128( tile, m_pvt->m_bank );
+
+	NL3D::CTileBorder border;
+	border.set( pm.width(), pm.height(), pixels );
+
+	
+
+	return true;
+}
\ No newline at end of file
diff --git a/code/studio/src/plugins/tile_editor/tile_bank.h b/code/studio/src/plugins/tile_editor/tile_bank.h
new file mode 100644
index 000000000..ab4d28ee8
--- /dev/null
+++ b/code/studio/src/plugins/tile_editor/tile_bank.h
@@ -0,0 +1,29 @@
+#ifndef TILE_BANK_H
+#define TILE_BANK_H
+
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+#include "tile_constants.h"
+
+class TileBankPvt;
+
+class TileBank
+{
+public:
+	TileBank();
+	~TileBank();
+
+	void addTileSet( const QString &name );
+	void addLand( const QString &name );
+	void setLandSets( int idx, const QStringList &l );
+
+	bool addTileToSet( int idx, const QString &name, const QVariant &pixmap, TileConstants::TTileChannel channel, TileConstants::TNodeTileType type );
+
+private:
+	TileBankPvt *m_pvt;
+};
+
+#endif
+
diff --git a/code/studio/src/plugins/tile_editor/tile_constants.h b/code/studio/src/plugins/tile_editor/tile_constants.h
new file mode 100644
index 000000000..e75664d43
--- /dev/null
+++ b/code/studio/src/plugins/tile_editor/tile_constants.h
@@ -0,0 +1,26 @@
+#ifndef TILE_CONSTANTS_H
+#define TILE_CONSTANTS_H
+
+
+namespace TileConstants
+{
+	enum TTileChannel
+	{
+		TileDiffuse = 0,
+		TileAdditive = 1,
+		TileAlpha = 2,
+		TileChannelCount = 3
+	};
+
+	enum TNodeTileType
+	{
+		Tile128 = 0,
+		Tile256 = 1,
+		TileTransition = 2,
+		TileDisplacement = 3,
+		TileNodeTypeCount = 4
+	};
+}
+
+
+#endif
diff --git a/code/studio/src/plugins/tile_editor/tile_editor_main_window.cpp b/code/studio/src/plugins/tile_editor/tile_editor_main_window.cpp
index aee2002ce..dd3ece7c7 100644
--- a/code/studio/src/plugins/tile_editor/tile_editor_main_window.cpp
+++ b/code/studio/src/plugins/tile_editor/tile_editor_main_window.cpp
@@ -648,7 +648,7 @@ void TileEditorMainWindow::onDiffuseToggled( bool b )
 	if( !b )
 		return;
 
-	TileItemNode::setDisplayChannel( TileModel::TileDiffuse );
+	TileItemNode::setDisplayChannel( TileConstants::TileDiffuse );
 	updateTab();
 }
 
@@ -657,7 +657,7 @@ void TileEditorMainWindow::onAdditiveToggled( bool b )
 	if( !b )
 		return;
 
-	TileItemNode::setDisplayChannel( TileModel::TileAdditive );
+	TileItemNode::setDisplayChannel( TileConstants::TileAdditive );
 	updateTab();
 }
 
@@ -666,7 +666,7 @@ void TileEditorMainWindow::onAlphaToggled( bool b )
 	if( !b )
 		return;
 
-	TileItemNode::setDisplayChannel( TileModel::TileAlpha );
+	TileItemNode::setDisplayChannel( TileConstants::TileAlpha );
 	updateTab();
 }
 
@@ -680,12 +680,12 @@ void TileEditorMainWindow::onTabChanged( int tab )
 	m_ui->diffuseTrBT->setChecked( true );
 }
 
-TileModel::TNodeTileType tabToType( int tabId )
+TileConstants::TNodeTileType tabToType( int tabId )
 {
-	if( tabId >= TileModel::TileNodeTypeCount )
-		return TileModel::TileNodeTypeCount;
+	if( tabId >= TileConstants::TileNodeTypeCount )
+		return TileConstants::TileNodeTypeCount;
 
-	return TileModel::TNodeTileType( tabId );
+	return TileConstants::TNodeTileType( tabId );
 }
 
 void TileEditorMainWindow::onActionAddTile(int tabId)
@@ -705,6 +705,8 @@ void TileEditorMainWindow::onActionAddTile(int tabId)
 	if( !idx.isValid() )
 		return;
 
+	int setId = idx.row();
+
 	TileSetNode *tsn = reinterpret_cast< TileSetNode* >( idx.internalPointer() );
 
 	Node *n = tsn->child( tabId );
@@ -715,12 +717,25 @@ void TileEditorMainWindow::onActionAddTile(int tabId)
 
 	int c = n->childCount();
 
-	TileModel::TNodeTileType type = tabToType( tabId );
+	TileConstants::TNodeTileType type = tabToType( tabId );
 
 	QStringListIterator itr( fileNames );
 	while( itr.hasNext() )
 	{
-		TileItemNode *newNode = TileModel::createItemNode( type, c, TileModel::TileDiffuse, itr.next() );
+		TileItemNode *newNode = m_tileModel->createItemNode( setId, type, c, TileConstants::TileDiffuse, itr.next() );
+		if( newNode == NULL )
+		{
+			int reply = QMessageBox::question( this,
+												tr( "Error adding tile" ),
+												tr( "Failed to create tile!\nContinue?" ),
+												QMessageBox::Yes, QMessageBox::No );
+			if( reply != QMessageBox::Yes )
+				break;
+			else
+				continue;
+		}
+
+
 		if( newNode->hasError() )
 		{
 			QString error = newNode->getLastError();
diff --git a/code/studio/src/plugins/tile_editor/tile_item.cpp b/code/studio/src/plugins/tile_editor/tile_item.cpp
index 1daa3c297..56f621dee 100644
--- a/code/studio/src/plugins/tile_editor/tile_item.cpp
+++ b/code/studio/src/plugins/tile_editor/tile_item.cpp
@@ -203,7 +203,7 @@ int TileSetNode::columnCount() const
 
 ///////////////////////////////////////////////////
 
-TileTypeNode::TileTypeNode(TileModel::TNodeTileType type, Node *parent) : m_nodeTileType(type)
+TileTypeNode::TileTypeNode(TileConstants::TNodeTileType type, Node *parent) : m_nodeTileType(type)
 {
 	m_parentItem = parent;
 }
@@ -230,7 +230,7 @@ int TileTypeNode::columnCount() const
 	return 1;
 }
 
-TileModel::TNodeTileType TileTypeNode::getTileType()
+TileConstants::TNodeTileType TileTypeNode::getTileType()
 {
 	return m_nodeTileType;
 }
@@ -266,15 +266,15 @@ void TileTypeNode::reindex()
 
 ///////////////////////////////////////////////////
 
-NL3D::CTile::TBitmap channelToTBitmap( TileModel::TTileChannel channel )
+NL3D::CTile::TBitmap channelToTBitmap( TileConstants::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;
+	case TileConstants::TileDiffuse: bm = NL3D::CTile::diffuse; break;
+	case TileConstants::TileAdditive: bm = NL3D::CTile::additive; break;
+	case TileConstants::TileAlpha: bm = NL3D::CTile::alpha; break;
 	}
 
 	return bm;
@@ -286,7 +286,7 @@ public:
 
 	TileItemNodePvt()
 	{
-		for( int i = 0; i < TileModel::TileChannelCount; i++ )
+		for( int i = 0; i < TileConstants::TileChannelCount; i++ )
 			m_borderFirst[ i ] = false;
 
 		m_id = -1;
@@ -325,33 +325,33 @@ public:
 		return true;
 	}
 
-	int getWidthForType( TileModel::TNodeTileType type, TileModel::TTileChannel channel )
+	int getWidthForType( TileConstants::TNodeTileType type, TileConstants::TTileChannel channel )
 	{
 		int width = -1;
 
 		switch( type )
 		{
-		case TileModel::Tile128: width = 128; break;
-		case TileModel::Tile256: width = 256; break;
-		case TileModel::TileTransition:
+		case TileConstants::Tile128: width = 128; break;
+		case TileConstants::Tile256: width = 256; break;
+		case TileConstants::TileTransition:
 			{
-				if( channel != TileModel::TileAlpha )
+				if( channel != TileConstants::TileAlpha )
 					width = 128;
 				break;
 			}
 
-		case TileModel::TileDisplacement: width = 32; break;
+		case TileConstants::TileDisplacement: width = 32; break;
 		}
 
 		return width;
 	}
 
-	NL3D::CTileSet::TError checkTile( TileModel::TTileChannel channel )
+	NL3D::CTileSet::TError checkTile( TileConstants::TTileChannel channel )
 	{
-		if( m_type == TileModel::TileDisplacement )
+		if( m_type == TileConstants::TileDisplacement )
 			return NL3D::CTileSet::ok;
 
-		if( channel == TileModel::TileAdditive )
+		if( channel == TileConstants::TileAdditive )
 			return NL3D::CTileSet::ok;
 
 		int pixel;
@@ -365,14 +365,14 @@ public:
 
 		switch( m_type )
 		{
-		case TileModel::Tile128:
+		case TileConstants::Tile128:
 			error = set.checkTile128( bm, m_border[ channel ], pixel, component );
 			break;
-		case TileModel::Tile256:
+		case TileConstants::Tile256:
 			error = set.checkTile256( bm, m_border[ channel ], pixel, component );
 			break;
-		case TileModel::TileTransition:
-			if( channel != TileModel::TileAlpha )
+		case TileConstants::TileTransition:
+			if( channel != TileConstants::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 );
@@ -394,13 +394,13 @@ public:
 
 			switch( m_type )
 			{
-			case TileModel::Tile128:
-			case TileModel::Tile256:
+			case TileConstants::Tile128:
+			case TileConstants::Tile256:
 				m_lastError += QString( "pixel: %1 component: %2" ).arg( pixel ).arg( comp[ component ] );
 				break;
 
-			case TileModel::TileTransition:
-				if( channel != TileModel::TileAlpha )
+			case TileConstants::TileTransition:
+				if( channel != TileConstants::TileAlpha )
 				{
 					m_lastError += QString( "pixel: %1 component: %2" ).arg( pixel ).arg( comp[ component ] );
 				}
@@ -429,7 +429,7 @@ public:
 		return error;
 	}
 
-	bool checkPixmap( TileModel::TTileChannel channel, QPixmap &pixmap )
+	bool checkPixmap( TileConstants::TTileChannel channel, QPixmap &pixmap )
 	{
 		int w = pixmap.width();
 		int h = pixmap.height();
@@ -470,7 +470,7 @@ public:
 		return true;
 	}
 	
-	bool loadImage( TileModel::TTileChannel channel, const QString &fn, bool empty = false )
+	bool loadImage( TileConstants::TTileChannel channel, const QString &fn, bool empty = false )
 	{
 		QPixmap temp;
 		bool b = temp.load( fn );
@@ -483,52 +483,54 @@ public:
 
 		m_borderFirst[ channel ] = false;
 		
+		/*
 		if( !empty )
 		{
 			if( !checkPixmap( channel, temp ) )
 				return false;
 		}
+		*/
 
 		pixmaps[ channel ] = temp;
 		
 		return true;
 	}
 
-	void clearImage( TileModel::TTileChannel channel )
+	void clearImage( TileConstants::TTileChannel channel )
 	{
 		pixmaps[ channel ] = QPixmap();
 	}
 
-	const QPixmap& pixMap( TileModel::TTileChannel channel ) const{
+	const QPixmap& pixMap( TileConstants::TTileChannel channel ) const{
 		return pixmaps[ channel ];
 	}
 
-	void setType( TileModel::TNodeTileType type ){ m_type = type; }
+	void setType( TileConstants::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 ]; }
+	bool borderFirst( TileConstants::TTileChannel channel ) const{ return m_borderFirst[ channel ]; }
 
-	const NL3D::CTileBorder &border( TileModel::TTileChannel channel ){ return m_border[ channel ]; }
+	const NL3D::CTileBorder &border( TileConstants::TTileChannel channel ){ return m_border[ channel ]; }
 
 	int alphaRot() const{ return m_alphaRot; }
 	void setAlphaRot( int rot ){ m_alphaRot = rot; }
 
 private:
-	QPixmap pixmaps[ TileModel::TileChannelCount ];
-	TileModel::TNodeTileType m_type;
-	NL3D::CTileBorder m_border[ TileModel::TileChannelCount ];
+	QPixmap pixmaps[ TileConstants::TileChannelCount ];
+	TileConstants::TNodeTileType m_type;
+	NL3D::CTileBorder m_border[ TileConstants::TileChannelCount ];
 	int m_id;
 	QString m_lastError;
-	bool m_borderFirst[ TileModel::TileChannelCount ];
+	bool m_borderFirst[ TileConstants::TileChannelCount ];
 	int m_alphaRot;
 };
 
-TileModel::TTileChannel TileItemNode::s_displayChannel = TileModel::TileDiffuse;
+TileConstants::TTileChannel TileItemNode::s_displayChannel = TileConstants::TileDiffuse;
 int TileItemNode::s_alphaRot = 0;
 
-TileItemNode::TileItemNode( TileModel::TNodeTileType type, int tileId, TileModel::TTileChannel channel, QString filename, Node *parent)
+TileItemNode::TileItemNode( TileConstants::TNodeTileType type, int tileId, TileConstants::TTileChannel channel, QString filename, Node *parent)
 {
 	m_parentItem = parent;
 	//nlinfo("dispalying tile %d - %s", m_tileId, m_tileFilename[TileModel::TileDiffuse].toAscii().data());
@@ -550,7 +552,7 @@ TileItemNode::~TileItemNode()
 	qDeleteAll(m_childItems);
 }
 
-bool TileItemNode::setTileFilename(TileModel::TTileChannel channel, QString filename)
+bool TileItemNode::setTileFilename(TileConstants::TTileChannel channel, QString filename)
 {
 	QString fn = filename;
 	bool empty = false;
@@ -571,9 +573,9 @@ bool TileItemNode::setTileFilename(TileModel::TTileChannel channel, QString file
 	return true;
 }
 
-QString TileItemNode::getTileFilename(TileModel::TTileChannel channel)
+QString TileItemNode::getTileFilename(TileConstants::TTileChannel channel)
 {
-	QMap< TileModel::TTileChannel, QString >::const_iterator itr
+	QMap< TileConstants::TTileChannel, QString >::const_iterator itr
 		= m_tileFilename.find( channel );
 	if( itr == m_tileFilename.end() )
 		return "";
@@ -596,12 +598,12 @@ QString TileItemNode::getLastError() const
 	return pvt->getLastError();
 }
 
-bool TileItemNode::borderFirst( TileModel::TTileChannel channel ) const
+bool TileItemNode::borderFirst( TileConstants::TTileChannel channel ) const
 {
 	return pvt->borderFirst( channel );
 }
 
-const NL3D::CTileBorder& TileItemNode::border( TileModel::TTileChannel channel ) const
+const NL3D::CTileBorder& TileItemNode::border( TileConstants::TTileChannel channel ) const
 {
 	return pvt->border( channel );
 }
@@ -658,4 +660,10 @@ QVariant TileItemNode::data(int column, int role) const
 int TileItemNode::columnCount() const
 {
 	return 1;
-}
\ No newline at end of file
+}
+
+QVariant TileItemNode::pixmap( TileConstants::TTileChannel channel ) const
+{
+	return pvt->pixMap( channel );
+}
+
diff --git a/code/studio/src/plugins/tile_editor/tile_item.h b/code/studio/src/plugins/tile_editor/tile_item.h
index 14bc66fe4..342846ab8 100644
--- a/code/studio/src/plugins/tile_editor/tile_item.h
+++ b/code/studio/src/plugins/tile_editor/tile_item.h
@@ -95,18 +95,18 @@ class TileTypeNode : public Node
 {
 public:
 
-	TileTypeNode(TileModel::TNodeTileType type, Node *parent=0);
+	TileTypeNode(TileConstants::TNodeTileType type, Node *parent=0);
 	virtual ~TileTypeNode();
 	QVariant data(int column, int role) const;
 	int columnCount() const;
 
-	TileModel::TNodeTileType getTileType();
+	TileConstants::TNodeTileType getTileType();
 
 	bool removeChildren( int position, int count );
 
 private:
 	void reindex();
-	TileModel::TNodeTileType m_nodeTileType;
+	TileConstants::TNodeTileType m_nodeTileType;
 };
 
 class TileItemNodePvt;
@@ -114,30 +114,32 @@ class TileItemNodePvt;
 class TileItemNode : public Node
 {
 public:
-	TileItemNode( TileModel::TNodeTileType type, int tileId, TileModel::TTileChannel channel, QString filename, Node *parent=0);
+	TileItemNode( TileConstants::TNodeTileType type, int tileId, TileConstants::TTileChannel channel, QString filename, Node *parent=0);
 	virtual ~TileItemNode();
 	QVariant data(int column, int role) const;
 	int columnCount() const;
-	bool setTileFilename(TileModel::TTileChannel channel, QString filename);
-	QString getTileFilename(TileModel::TTileChannel channel);
+	bool setTileFilename(TileConstants::TTileChannel channel, QString filename);
+	QString getTileFilename(TileConstants::TTileChannel channel);
 	void setId( int id );
 	int id() const;
 	QString getLastError() const;
-	bool borderFirst( TileModel::TTileChannel channel ) const;
-	const NL3D::CTileBorder& border( TileModel::TTileChannel channel ) const;
+	bool borderFirst( TileConstants::TTileChannel channel ) const;
+	const NL3D::CTileBorder& border( TileConstants::TTileChannel channel ) const;
 	int alphaRot() const;
 
-	static void setDisplayChannel( TileModel::TTileChannel channel ){ s_displayChannel = channel; }
-	static TileModel::TTileChannel displayChannel(){ return s_displayChannel; }
+	static void setDisplayChannel( TileConstants::TTileChannel channel ){ s_displayChannel = channel; }
+	static TileConstants::TTileChannel displayChannel(){ return s_displayChannel; }
 	static void setAlphaRot( int rot ){ s_alphaRot = rot; }
 
 	bool hasError() const{ return m_hasError; }
 
-private:
-	QMap<TileModel::TTileChannel, QString> m_tileFilename;
-	QMap<TileModel::TTileChannel, TileWidget*> m_tileWidget;
+	QVariant pixmap( TileConstants::TTileChannel channel ) const;
 
-	static TileModel::TTileChannel s_displayChannel;
+private:
+	QMap<TileConstants::TTileChannel, QString> m_tileFilename;
+	QMap<TileConstants::TTileChannel, TileWidget*> m_tileWidget;
+
+	static TileConstants::TTileChannel s_displayChannel;
 	static int s_alphaRot;
 
 	TileItemNodePvt *pvt;
diff --git a/code/studio/src/plugins/tile_editor/tile_model.cpp b/code/studio/src/plugins/tile_editor/tile_model.cpp
index d1ab0d238..fbdd07223 100644
--- a/code/studio/src/plugins/tile_editor/tile_model.cpp
+++ b/code/studio/src/plugins/tile_editor/tile_model.cpp
@@ -16,6 +16,7 @@
 
 #include "tile_model.h"
 #include "tile_item.h"
+#include "tile_bank.h"
 
 #include <QStringList>
 
@@ -35,6 +36,8 @@ TileModel::TileModel(const QStringList &headers, QObject *parent) : QAbstractIte
 	TileModel::CurrentZoomFactor = TileModel::TileZoom100;
 	m_indexDisplay = true;
 	m_fileDisplay = true;
+
+	m_tileBank = new TileBank();
 }
 
 TileModel::~TileModel()
@@ -182,59 +185,74 @@ TileSetNode *TileModel::createTileSetNode(QString tileSetName)
 	TileSetNode *tileSet = new TileSetNode(tileSetName);
 			
 	// child for 128x128 tiles
-	TileTypeNode *tile128= new TileTypeNode(Tile128);
+	TileTypeNode *tile128= new TileTypeNode( TileConstants::Tile128);
 	tileSet->appendRow(tile128);
 
 	// child for 256x256 tiles
-	TileTypeNode *tile256= new TileTypeNode(Tile256);
+	TileTypeNode *tile256= new TileTypeNode( TileConstants::Tile256);
 	tileSet->appendRow(tile256);
 
 	// child for transition tiles.
-	TileTypeNode *tileTrans= new TileTypeNode(TileTransition);
+	TileTypeNode *tileTrans= new TileTypeNode( TileConstants::TileTransition);
 	tileSet->appendRow(tileTrans);
 
 	// Add the default transition tiles.
 	// TODO tie this to CTileSet::count from NeL
 	for(int transPos=0; transPos<48; transPos++)
 	{				
-		TileItemNode *transTile= new TileItemNode( TileModel::TileTransition, transPos, TileDiffuse, QString("empty"));
+		TileItemNode *transTile= new TileItemNode( TileConstants::TileTransition, transPos, TileConstants::TileDiffuse, QString("empty"));
 		tileTrans->appendRow(transTile);
 	}
 
 	// child for displacement tiles
-	TileTypeNode *tileDisp= new TileTypeNode(TileDisplacement);
+	TileTypeNode *tileDisp= new TileTypeNode( TileConstants::TileDisplacement);
 	tileSet->appendRow(tileDisp);
 
 	// Add the default displacement tiles.
 	// TODO tie this to CTileSet::CountDisplace from NeL
 	for(int dispPos=0; dispPos<16; dispPos++)
 	{
-		TileItemNode *dispTile= new TileItemNode( TileModel::TileDisplacement, dispPos, TileDiffuse, QString("empty"));
+		TileItemNode *dispTile= new TileItemNode( TileConstants::TileDisplacement, dispPos, TileConstants::TileDiffuse, QString("empty"));
 		tileDisp->appendRow(dispTile);
 	}
 
 	// Append them in the correct order to the tile set.
 	this->appendRow(tileSet);
+	m_tileBank->addTileSet(tileSetName);
 
 	return tileSet;
 }
 
-TileItemNode *TileModel::createItemNode( TileModel::TNodeTileType type, int id, TTileChannel channel, const QString &fileName )
+TileItemNode *TileModel::createItemNode( TileConstants::TNodeTileType type, int id, TileConstants::TTileChannel channel, const QString &fileName )
 {
 	return new TileItemNode( type, id, channel, fileName );
 }
 
-const char *TileModel::getTileTypeName(TileModel::TNodeTileType type)
+TileItemNode *TileModel::createItemNode( int idx, TileConstants::TNodeTileType type, int id, TileConstants::TTileChannel channel, const QString &fileName )
+{
+	TileItemNode *n = new TileItemNode( type, id, channel, fileName );
+
+	bool b = m_tileBank->addTileToSet( idx, fileName, n->pixmap( channel ), channel, type );
+	if( !b )
+	{
+		delete n;
+		return NULL;
+	}
+
+	return n;
+}
+
+const char *TileModel::getTileTypeName(TileConstants::TNodeTileType type)
 {
 	switch(type)
 	{
-	case Tile128:
+	case TileConstants::Tile128:
 		return "128";
-	case Tile256:
+	case TileConstants::Tile256:
 		return "256";
-	case TileTransition:
+	case TileConstants::TileTransition:
 		return "Transition";
-	case TileDisplacement:
+	case TileConstants::TileDisplacement:
 		return "Displacement";
 	default:
 		break;
@@ -242,17 +260,17 @@ const char *TileModel::getTileTypeName(TileModel::TNodeTileType type)
 	return "UNKNOWN";
 }
 
-uint32 TileModel::getTileTypeSize(TileModel::TNodeTileType type)
+uint32 TileModel::getTileTypeSize(TileConstants::TNodeTileType type)
 {
 	switch(type)
 	{
-	case Tile128:
+	case TileConstants::Tile128:
 		return 128;
-	case Tile256:
+	case TileConstants::Tile256:
 		return 256;
-	case TileTransition:
+	case TileConstants::TileTransition:
 		return 64;
-	case TileDisplacement:
+	case TileConstants::TileDisplacement:
 		return 32;
 	default:
 		break;
@@ -287,6 +305,16 @@ void TileModel::clear()
 	removeRows( 0, c );
 }
 
+void TileModel::addLand( const QString &name )
+{
+	m_tileBank->addLand( name );
+}
+
+void TileModel::setLandSets( int idx, const QStringList &l )
+{
+	m_tileBank->setLandSets( idx, l );
+}
+
 void TileModel::selectFilenameDisplay(bool selected)
 {
 	m_fileDisplay = selected;
diff --git a/code/studio/src/plugins/tile_editor/tile_model.h b/code/studio/src/plugins/tile_editor/tile_model.h
index c22a43091..8472e6978 100644
--- a/code/studio/src/plugins/tile_editor/tile_model.h
+++ b/code/studio/src/plugins/tile_editor/tile_model.h
@@ -21,32 +21,18 @@
 
 #include <QAbstractListModel>
 
+#include "tile_constants.h"
+
 class Node;
 class TileSetNode;
 class TileItemNode;
+class TileBank;
 
 class TileModel : public QAbstractItemModel
 {
 	Q_OBJECT
 
 public:
-	enum TTileChannel
-	{
-		TileDiffuse = 0,
-		TileAdditive = 1,
-		TileAlpha = 2,
-		TileChannelCount = 3
-	};
-
-	enum TNodeTileType
-	{
-		Tile128 = 0,
-		Tile256 = 1,
-		TileTransition = 2,
-		TileDisplacement = 3,
-		TileNodeTypeCount = 4
-	};
-
 	enum TTileItemRole
 	{
 		TilePixmapRole = Qt::UserRole+1,
@@ -87,10 +73,11 @@ public:
 	void swapRows( int a, int b );
 
 	TileSetNode *createTileSetNode(QString tileSetName);
-	static TileItemNode *createItemNode( TileModel::TNodeTileType type, int id, TTileChannel channel, const QString &fileName );
+	static TileItemNode *createItemNode( TileConstants::TNodeTileType type, int id, TileConstants::TTileChannel channel, const QString &fileName );
+	TileItemNode *createItemNode( int idx, TileConstants::TNodeTileType type, int id, TileConstants::TTileChannel channel, const QString &fileName );
 
-	static const char *getTileTypeName(TNodeTileType type);
-	static uint32 getTileTypeSize(TileModel::TNodeTileType type);
+	static const char *getTileTypeName(TileConstants::TNodeTileType type);
+	static uint32 getTileTypeSize(TileConstants::TNodeTileType type);
 
 	static TTileZoomFactor CurrentZoomFactor;
 
@@ -101,6 +88,9 @@ public:
 	void setTexturePath( const QString &path ){ m_texturePath = path; }
 	QString texturePath() const{ return m_texturePath; }
 
+	void addLand( const QString &name );
+	void setLandSets( int idx, const QStringList &l );
+
 public Q_SLOTS:
 	void selectFilenameDisplay(bool selected);
 	void selectIndexDisplay(bool selected);	
@@ -117,6 +107,8 @@ private:
 	Node *rootItem;
 
 	QString m_texturePath;
+
+	TileBank *m_tileBank;
 };
 
 #endif // TILE_MODEL_H
diff --git a/code/studio/src/plugins/tile_editor/tilebank_loader.cpp b/code/studio/src/plugins/tile_editor/tilebank_loader.cpp
index 73c8007d8..019745afd 100644
--- a/code/studio/src/plugins/tile_editor/tilebank_loader.cpp
+++ b/code/studio/src/plugins/tile_editor/tilebank_loader.cpp
@@ -28,15 +28,15 @@ class TileBankLoaderPvt
 public:
 	NL3D::CTileBank bank;
 
-	static NL3D::CTile::TBitmap channelToTBitmap( TileModel::TTileChannel channel )
+	static NL3D::CTile::TBitmap channelToTBitmap( TileConstants::TTileChannel channel )
 	{
 		NL3D::CTile::TBitmap b = NL3D::CTile::bitmapCount;
 
 		switch( channel )
 		{
-		case TileModel::TileDiffuse: b = NL3D::CTile::diffuse; break;
-		case TileModel::TileAdditive: b = NL3D::CTile::additive; break;
-		case TileModel::TileAlpha: b = NL3D::CTile::alpha; break;
+		case TileConstants::TileDiffuse: b = NL3D::CTile::diffuse; break;
+		case TileConstants::TileAdditive: b = NL3D::CTile::additive; break;
+		case TileConstants::TileAlpha: b = NL3D::CTile::alpha; break;
 		}
 
 		return b;
@@ -75,11 +75,11 @@ public:
 			int idx = set->getTile128( i );
 			NL3D::CTile *tile = bank.getTile( idx );
 
-			TileItemNode *tin = new TileItemNode( TileModel::Tile128, i, TileModel::TileDiffuse, "" );
+			TileItemNode *tin = new TileItemNode( TileConstants::Tile128, i, TileConstants::TileDiffuse, "" );
 
-			for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ )
+			for( int i = TileConstants::TileDiffuse; i < TileConstants::TileAlpha; i++ )
 			{
-				tin->setTileFilename( TileModel::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileModel::TTileChannel( i ) ) ).c_str() );
+				tin->setTileFilename( TileConstants::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileConstants::TTileChannel( i ) ) ).c_str() );
 			}
 
 			node->appendChild( tin );
@@ -94,11 +94,11 @@ public:
 			int idx = set->getTile256( i );
 			NL3D::CTile *tile = bank.getTile( idx );
 
-			TileItemNode *tin = new TileItemNode( TileModel::Tile256, i, TileModel::TileDiffuse, "" );
+			TileItemNode *tin = new TileItemNode( TileConstants::Tile256, i, TileConstants::TileDiffuse, "" );
 
-			for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ )
+			for( int i = TileConstants::TileDiffuse; i < TileConstants::TileAlpha; i++ )
 			{
-				tin->setTileFilename( TileModel::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileModel::TTileChannel( i ) ) ).c_str() );
+				tin->setTileFilename( TileConstants::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileConstants::TTileChannel( i ) ) ).c_str() );
 			}
 
 			node->appendChild( tin );
@@ -115,9 +115,9 @@ public:
 
 			TileItemNode *tin = static_cast< TileItemNode* >( node->child( i ) );
 
-			for( int j = TileModel::TileDiffuse; j <= TileModel::TileAlpha; j++ )
+			for( int j = TileConstants::TileDiffuse; j <= TileConstants::TileAlpha; j++ )
 			{
-				tin->setTileFilename( TileModel::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileModel::TTileChannel( i ) ) ).c_str() );
+				tin->setTileFilename( TileConstants::TTileChannel( i ), tile->getRelativeFileName( channelToTBitmap( TileConstants::TTileChannel( i ) ) ).c_str() );
 			}
 		}
 	}
@@ -130,7 +130,7 @@ public:
 			const char *fn = bank.getDisplacementMap( did );
 
 			TileItemNode *tin = static_cast< TileItemNode* >( node->child( i ) );
-			tin->setTileFilename( TileModel::TileDiffuse, fn );
+			tin->setTileFilename( TileConstants::TileDiffuse, fn );
 		}
 	}
 
diff --git a/code/studio/src/plugins/tile_editor/tilebank_saver.cpp b/code/studio/src/plugins/tile_editor/tilebank_saver.cpp
index 65559505a..10f86eb14 100644
--- a/code/studio/src/plugins/tile_editor/tilebank_saver.cpp
+++ b/code/studio/src/plugins/tile_editor/tilebank_saver.cpp
@@ -27,35 +27,35 @@ class TileBankSaverPvt
 public:
 	NL3D::CTileBank bank;
 
-	static NL3D::CTile::TBitmap channelToTBitmap( TileModel::TTileChannel channel )
+	static NL3D::CTile::TBitmap channelToTBitmap( TileConstants::TTileChannel channel )
 	{
 		NL3D::CTile::TBitmap b = NL3D::CTile::bitmapCount;
 
 		switch( channel )
 		{
-		case TileModel::TileDiffuse: b = NL3D::CTile::diffuse; break;
-		case TileModel::TileAdditive: b = NL3D::CTile::additive; break;
-		case TileModel::TileAlpha: b = NL3D::CTile::alpha; break;
+		case TileConstants::TileDiffuse: b = NL3D::CTile::diffuse; break;
+		case TileConstants::TileAdditive: b = NL3D::CTile::additive; break;
+		case TileConstants::TileAlpha: b = NL3D::CTile::alpha; break;
 		}
 
 		return b;
 	}
 
-	NL3D::CTile* addTileToSet( NL3D::CTileSet *set, TileModel::TNodeTileType type )
+	NL3D::CTile* addTileToSet( NL3D::CTileSet *set, TileConstants::TNodeTileType type )
 	{
 		int idx = -1;
 		int bidx = -1;
 
 		switch( type )
 		{
-		case TileModel::Tile128:
+		case TileConstants::Tile128:
 			{
 				set->addTile128( idx, bank );
 				bidx = set->getTile128( idx );
 				break;
 			}
 
-		case TileModel::Tile256:
+		case TileConstants::Tile256:
 			{
 				set->addTile256( idx, bank );
 				bidx = set->getTile256( idx );
@@ -71,24 +71,24 @@ public:
 
 	void addTilesToSet( NL3D::CTileSet *set, TileTypeNode *node )
 	{
-		TileModel::TNodeTileType type = node->getTileType();
+		TileConstants::TNodeTileType type = node->getTileType();
 
 		for( int i = 0; i < node->childCount(); i++ )
 		{
 			TileItemNode *tin = static_cast< TileItemNode* >( node->child( i ) );
 			NL3D::CTile *tile = addTileToSet( set, type );
 
-			for( int j = TileModel::TileDiffuse; j < TileModel::TileAlpha; j++ )
+			for( int j = TileConstants::TileDiffuse; j < TileConstants::TileAlpha; j++ )
 			{
-				QString fn = tin->getTileFilename( TileModel::TTileChannel( j ) );
-				tile->setFileName( channelToTBitmap( TileModel::TTileChannel( j ) ) , fn.toUtf8().constData() );
+				QString fn = tin->getTileFilename( TileConstants::TTileChannel( j ) );
+				tile->setFileName( channelToTBitmap( TileConstants::TTileChannel( j ) ) , fn.toUtf8().constData() );
 			}
 		}
 	}
 
 	void addTilesToSet( NL3D::CTileSet *set, TileSetNode *node )
 	{
-		for( int i = TileModel::Tile128; i <= TileModel::Tile256; i++ )
+		for( int i = TileConstants::Tile128; i <= TileConstants::Tile256; i++ )
 		{
 			TileTypeNode *tn = static_cast< TileTypeNode* >( node->child( i ) );
 			
@@ -103,9 +103,9 @@ public:
 		{
 			tileNode = static_cast< TileItemNode* >( node->child( i ) );
 
-			for( int j = TileModel::TileDiffuse; j < TileModel::TileAlpha; j++ )
+			for( int j = TileConstants::TileDiffuse; j < TileConstants::TileAlpha; j++ )
 			{
-				TileModel::TTileChannel channel = TileModel::TTileChannel( j );
+				TileConstants::TTileChannel channel = TileConstants::TTileChannel( j );
 				NL3D::CTile::TBitmap bm = channelToTBitmap( channel );
 				const NL3D::CTileBorder &border = tileNode->border( channel );
 
@@ -124,9 +124,9 @@ public:
 		{
 			tileNode = static_cast< TileItemNode* >( node->child( i ) );
 
-			for( int j = TileModel::TileDiffuse; j < TileModel::TileAlpha; j++ )
+			for( int j = TileConstants::TileDiffuse; j < TileConstants::TileAlpha; j++ )
 			{
-				TileModel::TTileChannel channel = TileModel::TTileChannel( j );
+				TileConstants::TTileChannel channel = TileConstants::TTileChannel( j );
 				NL3D::CTile::TBitmap bm = channelToTBitmap( channel );
 				const NL3D::CTileBorder &border = tileNode->border( channel );
 
@@ -140,14 +140,14 @@ public:
 
 	void setupTransitionTile( NL3D::CTileSet *set, TileItemNode *node, int idx )
 	{
-		TileModel::TTileChannel channel;
+		TileConstants::TTileChannel channel;
 		NL3D::CTile::TBitmap bm;
 		NL3D::CTileSet::TTransition tr;
 
 		// Diffuse, Additive
-		for( int i = TileModel::TileDiffuse; i < TileModel::TileAlpha; i++ )
+		for( int i = TileConstants::TileDiffuse; i < TileConstants::TileAlpha; i++ )
 		{
-			channel =TileModel::TTileChannel( i );
+			channel =TileConstants::TTileChannel( i );
 			bm = channelToTBitmap( channel );
 			tr = NL3D::CTileSet::TTransition( idx );
 			const NL3D::CTileBorder &border = node->border( channel );
@@ -159,7 +159,7 @@ public:
 
 		// Alpha
 		{
-			channel = TileModel::TileAlpha;
+			channel = TileConstants::TileAlpha;
 			bm = channelToTBitmap( channel );
 			tr = NL3D::CTileSet::TTransition( idx );
 			const NL3D::CTileBorder &border = node->border( channel );
@@ -187,7 +187,7 @@ public:
 	void setupDisplacementTile( NL3D::CTileSet *set, TileItemNode *node, int idx )
 	{
 		set->setDisplacement( NL3D::CTileSet::TDisplacement( idx ), 
-							node->getTileFilename( TileModel::TileDiffuse ).toUtf8().constData(),
+							node->getTileFilename( TileConstants::TileDiffuse ).toUtf8().constData(),
 							bank );
 	}