diff --git a/code/nel/tools/3d/CMakeLists.txt b/code/nel/tools/3d/CMakeLists.txt
index bc21ae69f..02d32afba 100644
--- a/code/nel/tools/3d/CMakeLists.txt
+++ b/code/nel/tools/3d/CMakeLists.txt
@@ -47,6 +47,7 @@ ENDIF(WIN32)
 IF(WITH_QT)
   ADD_SUBDIRECTORY(tile_edit_qt)
   ADD_SUBDIRECTORY(object_viewer_qt)
+  ADD_SUBDIRECTORY(object_viewer_widget)
 ENDIF(WITH_QT)
 
 IF(SQUISH_FOUND)
diff --git a/code/nel/tools/3d/object_viewer_widget/CMakeLists.txt b/code/nel/tools/3d/object_viewer_widget/CMakeLists.txt
new file mode 100644
index 000000000..8a12dfa1d
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/CMakeLists.txt
@@ -0,0 +1,18 @@
+#-----------------------------------------------------------------------------
+#
+#   Object Viewer Widget
+#   Copyright (C) 2010 Adrian Jäkel <aj at elane2k dot com>
+#
+#-----------------------------------------------------------------------------
+
+# This tells the application(s) where to find the installed data.
+#ADD_DEFINITIONS(-DDATA_DIR="\\"${NL_SHARE_PREFIX}/georges_editor_qt/\\"")
+
+ADD_SUBDIRECTORY(src)
+
+#INSTALL(DIRECTORY data/
+#        DESTINATION share/georges_editor_qt/data
+#        COMPONENT data
+#        PATTERN "CVS" EXCLUDE
+#        PATTERN ".svn" EXCLUDE
+#        PATTERN "Makefile*" EXCLUDE)
diff --git a/code/nel/tools/3d/object_viewer_widget/src/CMakeLists.txt b/code/nel/tools/3d/object_viewer_widget/src/CMakeLists.txt
new file mode 100644
index 000000000..36336dca1
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/CMakeLists.txt
@@ -0,0 +1,42 @@
+INCLUDE_DIRECTORIES(
+		${CMAKE_CURRENT_BINARY_DIR} 
+		${CMAKE_CURRENT_SOURCE_DIR} 
+		${LIBXML2_INCLUDE_DIR} 
+		${NEL_INCLUDE_DIR} 
+		${QT_INCLUDES})
+		
+INCLUDE( ${QT_USE_FILE} )
+
+FILE(GLOB OBJECT_VIEWER_WIDGET_SRC *.cpp *.h)
+SET(OBJECT_VIEWER_WIDGET_HDR object_viewer_widget.h)
+
+SET(QT_USE_QTGUI TRUE)
+SET(QT_USE_QTOPENGL TRUE)
+
+QT4_WRAP_CPP( OBJECT_VIEWER_WIDGET_MOC_SRCS ${OBJECT_VIEWER_WIDGET_HDR} )
+
+SOURCE_GROUP(QtGeneratedMocSrc FILES ${OBJECT_VIEWER_WIDGET_MOC_SRCS})
+
+ADD_LIBRARY(object_viewer_widget_qt SHARED 
+		${OBJECT_VIEWER_WIDGET_SRC} 
+		${OBJECT_VIEWER_WIDGET_MOC_SRCS})
+
+TARGET_LINK_LIBRARIES(object_viewer_widget_qt
+		nelmisc 
+		nel3d
+		${QT_LIBRARIES}
+		${QT_QTOPENGL_LIBRARY})
+
+ADD_DEFINITIONS(-DQT_NO_KEYWORDS ${LIBXML2_DEFINITIONS} ${QT_DEFINITIONS})
+ADD_DEFINITIONS(-DQT_PLUGIN)
+ADD_DEFINITIONS(-DQT_SHARED)
+#ADD_DEFINITIONS(-DQT_NO_DEBUG)
+	
+NL_DEFAULT_PROPS(object_viewer_widget_qt "NeL, Tools, 3D: Object Viewer Qt Widget")
+#NL_ADD_RUNTIME_FLAGS(object_viewer_widget_qt)
+
+IF(WITH_PCH)
+  ADD_NATIVE_PRECOMPILED_HEADER(object_viewer_widget_qt ${CMAKE_CURRENT_SOURCE_DIR}/stdpch.h ${CMAKE_CURRENT_SOURCE_DIR}/stdpch.cpp)
+ENDIF(WITH_PCH)
+
+#INSTALL(TARGETS object_viewer_widget_qt RUNTIME DESTINATION bin COMPONENT runtime BUNDLE DESTINATION /Applications)
diff --git a/code/nel/tools/3d/object_viewer_widget/src/entity.cpp b/code/nel/tools/3d/object_viewer_widget/src/entity.cpp
new file mode 100644
index 000000000..f17268419
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/entity.cpp
@@ -0,0 +1,430 @@
+/*
+    Object Viewer Qt
+    Copyright (C) 2010 Dzmitry Kamiahin <dnk-88@tut.by>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "stdpch.h"
+#include "entity.h"
+
+#include <QtCore/QString>
+
+// NeL includes
+#include <nel/misc/path.h>
+#include <nel/3d/u_driver.h>
+#include <nel/3d/u_instance.h>
+#include <nel/3d/u_scene.h>
+#include <nel/3d/u_skeleton.h>
+#include <nel/3d/u_animation_set.h>
+#include <nel/3d/u_animation.h>
+#include <nel/3d/u_play_list_manager.h>
+#include <nel/3d/u_play_list.h>
+#include <nel/3d/u_track.h>
+
+// Project includes
+#include "object_viewer_widget.h"
+
+using namespace NLMISC;
+using namespace NL3D;
+
+namespace NLQT {
+
+CSlotInfo& CSlotInfo::operator=(const CSlotInfo & slotInfo)
+{
+	if ( this != &slotInfo)
+	{
+		Animation = slotInfo.Animation;
+		ClampMode = slotInfo.ClampMode;
+		Enable = slotInfo.Enable;
+		EndBlend = slotInfo.EndBlend;
+		EndTime = slotInfo.EndTime;
+		Offset = slotInfo.Offset;
+		Skeleton = slotInfo.Skeleton;
+		SkeletonInverted = slotInfo.SkeletonInverted;
+		Smoothness = slotInfo.Smoothness;
+		SpeedFactor = slotInfo.SpeedFactor;
+		StartBlend = slotInfo.StartBlend;
+		StartTime = slotInfo.StartTime;
+	}
+	return *this;
+}
+  
+CEntity::CEntity(void):
+		_Name("<Unknown>"), _FileNameShape(""),
+		_FileNameSkeleton(""), _inPlace(false), _incPos(false),
+		_Instance(NULL), _Skeleton(NULL), 
+		_PlayList(NULL), _AnimationSet(NULL)
+{
+	_CharacterScalePos = 1;
+}
+
+CEntity::~CEntity(void)
+{
+	if (_PlayList != NULL)
+	{
+		_PlayList->resetAllChannels();
+		CObjectViewerWidget::objViewWid().getPlayListManager()->deletePlayList (_PlayList);
+		_PlayList = NULL;
+	}
+	if (_AnimationSet != NULL)
+	{
+		CObjectViewerWidget::objViewWid().getDriver()->deleteAnimationSet(_AnimationSet);
+		_AnimationSet = NULL;
+	}
+	if (!_Skeleton.empty())
+	{
+		_Skeleton.detachSkeletonSon(_Instance);
+		CObjectViewerWidget::objViewWid().getScene()->deleteSkeleton(_Skeleton);
+		_Skeleton = NULL;
+	}
+	if (!_Instance.empty())
+	{
+		CObjectViewerWidget::objViewWid().getScene()->deleteInstance(_Instance);
+		_Instance = NULL;
+	}
+}
+
+void CEntity::loadAnimation(std::string &fileName)
+{
+	uint id = _AnimationSet->addAnimation(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());	
+	_AnimationList.push_back(_AnimationSet->getAnimationName(id));
+	_AnimationSet->build();
+	if (!_Skeleton.empty()) _PlayList->registerTransform(_Skeleton);
+	else _PlayList->registerTransform(_Instance);
+}
+
+void CEntity::loadSWT(std::string &fileName)
+{
+	uint id = _AnimationSet->addSkeletonWeight(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());
+	_SWTList.push_back(_AnimationSet->getSkeletonWeightName(id));
+}
+
+void CEntity::addAnimToPlayList(std::string &name)
+{
+	_PlayListAnimation.push_back(name);
+	
+	_AnimationStatus.EndAnim = this->getPlayListLength();
+	
+	_Instance.start();
+}
+
+void CEntity::removeAnimToPlayList(uint row)
+{
+	if (row < _PlayListAnimation.size())
+	 _PlayListAnimation.erase(_PlayListAnimation.begin() + row);
+	
+	_AnimationStatus.EndAnim = this->getPlayListLength();
+}
+
+void CEntity::swapAnimToPlayList(uint row1, uint row2)
+{
+	if ((row1 < _PlayListAnimation.size()) && (row2 < _PlayListAnimation.size()))
+	 std::swap(_PlayListAnimation[row1], _PlayListAnimation[row2]);
+}
+
+void CEntity::playbackAnim(bool play)
+{
+	_AnimationStatus.PlayAnim = play;
+	
+	if (play)
+		_Instance.start();
+	else
+		_Instance.freezeHRC();
+}
+
+void CEntity::reset()
+{
+	_PlayListAnimation.clear();
+	_AnimationList.clear();
+	_SWTList.clear();
+	
+	_PlayList->resetAllChannels();
+}
+
+float CEntity::getPlayListLength()
+{
+	// Accumul all the time
+	float time = 0;
+	for(size_t i = 0; i < _PlayListAnimation.size(); ++i)
+		time += getAnimLength(_PlayListAnimation[i]);
+	return time;
+}
+
+float CEntity::getAnimLength(std::string name)
+{
+	uint id = _AnimationSet->getAnimationIdByName(name.c_str());
+	NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);
+	return anim->getEndTime() - anim->getBeginTime();
+}
+
+void CEntity::update(NL3D::TAnimationTime time)
+{
+	this->resetChannel();
+	switch (_AnimationStatus.Mode) 
+	{
+		case Mode::PlayList:  
+			animatePlayList(time);
+			break;
+		case Mode::Mixer:
+			animateChannelMixer();
+			break;
+	}
+}
+
+
+void CEntity::resetChannel()
+{
+	for(uint i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; i++)
+	 _PlayList->setAnimation(i, UPlayList::empty);
+}
+
+void CEntity::addTransformation (CMatrix &current, UAnimation *anim, float begin, float end, UTrack *posTrack, UTrack *rotquatTrack, 
+									   UTrack *nextPosTrack, UTrack *nextRotquatTrack, bool removeLast)
+{
+	// In place ?
+	if (_inPlace)
+	{
+		// Just identity
+		current.identity();
+	}
+	else
+	{
+		// Remove the start of the animation
+		CQuat rotEnd (0,0,0,1);
+		CVector posEnd (0,0,0);
+		if (rotquatTrack)
+		{
+			// Interpolate the rotation
+			rotquatTrack->interpolate (end, rotEnd);
+		}
+		if (posTrack)
+		{
+			// Interpolate the position
+			posTrack->interpolate (end, posEnd);
+		}
+
+		// Add the final rotation and position
+		CMatrix tmp;
+		tmp.identity ();
+		tmp.setRot (rotEnd);
+		tmp.setPos (posEnd);
+
+		// Incremental ?
+		if (_incPos)
+			current *= tmp;
+		else
+			current = tmp;
+
+		if (removeLast)
+		{
+			CQuat rotStart (0,0,0,1);
+			CVector posStart (0,0,0);
+			if (nextRotquatTrack)
+			{
+				// Interpolate the rotation
+				nextRotquatTrack->interpolate (begin, rotStart);
+			}
+			if (nextPosTrack)
+			{
+				// Interpolate the position
+				nextPosTrack->interpolate (begin, posStart);
+			}
+			// Remove the init rotation and position of the next animation
+			tmp.identity ();
+			tmp.setRot (rotStart);
+			tmp.setPos (posStart);
+			tmp.invert ();
+			current *= tmp;
+
+			// Normalize the mt
+			CVector I = current.getI ();
+			CVector J = current.getJ ();
+			I.z = 0;
+			J.z = 0;
+			J.normalize ();
+			CVector K = I^J;
+			K.normalize ();
+			I = J^K;
+			I.normalize ();
+			tmp.setRot (I, J, K);
+			tmp.setPos (current.getPos ());
+			current = tmp;
+		}
+	}
+}
+
+void CEntity::animatePlayList(NL3D::TAnimationTime time)
+{
+	if (!_PlayListAnimation.empty())
+	{
+		// Animation index
+		uint id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[0].c_str());
+		
+		// Try channel AnimationSet
+		NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);
+		
+		bool there = false;
+
+		UTrack *posTrack = NULL;
+		UTrack *rotQuatTrack = NULL;
+
+		// Current matrix
+		CMatrix current;
+		current.identity();
+
+		// read an animation for init matrix
+		rotQuatTrack = anim->getTrackByName("rotquat");
+		posTrack = anim->getTrackByName("pos");
+
+		there = posTrack || rotQuatTrack;
+
+		// Accumul time
+		float startTime = 0;
+		float endTime = anim->getEndTime() - anim->getBeginTime();
+		
+		uint index = 0;
+		while (time >= endTime)
+		{
+			index++;
+			if (index < _PlayListAnimation.size())
+			{
+				id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
+				NL3D::UAnimation *newAnim = _AnimationSet->getAnimation(id);
+				
+				UTrack *newPosTrack = newAnim->getTrackByName ("pos");
+				UTrack *newRotquatTrack = newAnim->getTrackByName ("rotquat");
+
+				// Add the transformation
+				addTransformation (current, anim, newAnim->getBeginTime(), anim->getEndTime(), posTrack, rotQuatTrack, newPosTrack, newRotquatTrack, true);
+
+
+				anim = newAnim;
+				posTrack = newPosTrack;
+				rotQuatTrack = newRotquatTrack;
+
+				// Add start time
+				startTime = endTime;
+				endTime = startTime + (anim->getEndTime() - anim->getBeginTime());
+			}
+			else 
+			{
+				// Add the transformation
+				addTransformation (current, anim, 0, anim->getEndTime(), posTrack, rotQuatTrack, NULL, NULL, false);
+				break;
+			}
+		}
+		
+		// Time cropped ?
+		if (index >= _PlayListAnimation.size())
+		{
+			// Yes
+			index--;
+			id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
+			anim = _AnimationSet->getAnimation(id);
+		
+			// End time for last anim
+			startTime = anim->getEndTime() - time;
+		}
+		else
+		{
+			// No 
+
+			// Add the transformation
+			addTransformation (current, anim, 0, anim->getBeginTime() + time - startTime, posTrack, rotQuatTrack, NULL, NULL, false);
+
+			id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
+			anim = _AnimationSet->getAnimation(id);
+			
+			// Final time
+			startTime -= anim->getBeginTime();
+		}
+		
+		// Set the slot
+		_PlayList->setAnimation(0, id);
+		_PlayList->setTimeOrigin(0, startTime);
+		_PlayList->setSpeedFactor(0, 1.0f);
+		_PlayList->setWeightSmoothness(0, 1.0f);
+		_PlayList->setStartWeight(0, 1, 0);
+		_PlayList->setEndWeight(0, 1, 1);
+		_PlayList->setWrapMode(0, UPlayList::Clamp);
+		
+		// Setup the pos and rot for this shape
+		if (there)
+		{
+			CVector pos = current.getPos();
+
+			// If a  skeleton model
+			if(!_Skeleton.empty())
+			{
+				// scale animated pos value with the CFG scale
+				pos *= _CharacterScalePos;
+				_Skeleton.setPos(pos);
+				_Skeleton.setRotQuat(current.getRot());
+			}
+			else
+			{
+				_Instance.setPos(pos);
+				_Instance.setRotQuat(current.getRot());
+			}
+		}
+	}
+}
+
+void CEntity::animateChannelMixer()
+{
+	for (uint i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; i++)
+	{
+		if (_SlotInfo[i].Enable)
+		{
+			// Set the animation
+			uint animId =  _AnimationSet->getAnimationIdByName(_SlotInfo[i].Animation);
+			if (animId == UAnimationSet::NotFound) 
+				_PlayList->setAnimation(i, UPlayList::empty);
+			else 
+				_PlayList->setAnimation(i, animId);
+		
+			// Set the skeleton weight
+			uint skelId = _AnimationSet->getSkeletonWeightIdByName(_SlotInfo[i].Skeleton);
+			if (skelId == UAnimationSet::NotFound)
+				_PlayList->setSkeletonWeight(i, UPlayList::empty, false);
+			else
+				_PlayList->setSkeletonWeight(i, skelId, _SlotInfo[i].SkeletonInverted);
+
+			// Set others values
+			_PlayList->setTimeOrigin(i, _SlotInfo[i].Offset);
+			_PlayList->setSpeedFactor(i, _SlotInfo[i].SpeedFactor);
+			_PlayList->setStartWeight(i, _SlotInfo[i].StartBlend, _SlotInfo[i].StartTime);
+			_PlayList->setEndWeight(i, _SlotInfo[i].EndBlend, _SlotInfo[i].EndTime);
+			_PlayList->setWeightSmoothness(i, _SlotInfo[i].Smoothness);
+
+			// Switch between wrap modes
+			switch (_SlotInfo[i].ClampMode)
+			{
+				case 0:
+					_PlayList->setWrapMode (i, UPlayList::Clamp);
+					break;
+				case 1:
+					_PlayList->setWrapMode (i, UPlayList::Repeat);
+					break;
+				case 2:
+					_PlayList->setWrapMode (i, UPlayList::Disable);
+					break;
+			}
+		}
+	}
+}
+
+} /* namespace NLQT */
diff --git a/code/nel/tools/3d/object_viewer_widget/src/entity.h b/code/nel/tools/3d/object_viewer_widget/src/entity.h
new file mode 100644
index 000000000..9fb550652
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/entity.h
@@ -0,0 +1,259 @@
+/*
+    Object Viewer Qt
+    Copyright (C) 2010 Dzmitry Kamiahin <dnk-88@tut.by>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef ENTITY_H
+#define ENTITY_H
+
+#include <nel/misc/types_nl.h>
+
+// STL includes
+#include <map>
+#include <string>
+#include <vector>
+
+// NeL includes
+#include <nel/misc/vector.h>
+#include <nel/misc/vectord.h>
+#include <nel/misc/quat.h>
+#include <nel/3d/animation_time.h>
+#include <nel/3d/u_instance.h>
+#include <nel/3d/u_skeleton.h>
+#include <nel/3d/channel_mixer.h>
+
+namespace NL3D {
+	class UPlayList;
+	class UAnimationSet;
+}
+
+namespace NLQT {
+  
+class CSlotInfo
+{
+public:
+	CSlotInfo ():
+		Animation("empty"), Skeleton("empty"),
+		Offset(0), StartTime(0), EndTime(0),
+		StartBlend(1),	EndBlend (1), Smoothness(1),
+		SpeedFactor(1),	ClampMode(0),
+		SkeletonInverted(false), 
+		Enable(true)	{} ;
+
+	std::string		Animation;
+	std::string		Skeleton;
+	float			Offset;
+	float			StartTime;
+	float			EndTime;
+
+	float			StartBlend;
+	float			EndBlend;
+	float			Smoothness;
+	float			SpeedFactor;
+	sint32			ClampMode;
+	bool			SkeletonInverted;
+	bool			Enable;
+	
+	CSlotInfo &operator=(const CSlotInfo &);
+};
+
+	
+/**
+@class CEntity
+@brief Class manage animated shape.
+@details
+Allows you to load animations for shape and skeleton weight. 
+Contains a built-in playlist. Has management and playback Playlists or Mixer.
+*/
+class CEntity
+{
+public:
+	struct Mode
+	{
+		enum List
+		{
+			PlayList = 1,
+			Mixer
+		};
+	};
+
+	/// Will need for a single or multiple animation shape
+	struct SAnimationStatus
+	{
+		bool	LoopAnim;
+		bool	PlayAnim;
+		float	CurrentTimeAnim;
+		float	StartAnim;
+		float	EndAnim;
+		float	SpeedAnim;
+		int	Mode;
+		
+		SAnimationStatus():
+			LoopAnim(false), PlayAnim(false),
+			CurrentTimeAnim(0), StartAnim(0),
+			EndAnim(0), SpeedAnim(1), Mode(Mode::PlayList) {}
+	};
+ 
+	/// Destructor
+	~CEntity(void);
+
+	/// Loads a file animations
+	/// @param fileName - name animation file
+	void loadAnimation(std::string &fileName);
+	
+	/// Loads a file skeleton weight
+	void loadSWT(std::string &fileName);
+	
+	/// Adds an animation to a playlist
+	/// @param name - name loaded animations
+	void addAnimToPlayList(std::string &name);
+	
+	/// Removes the animation from a playlist
+	/// @param row - number of animations in the playlist
+	void removeAnimToPlayList(uint row);
+	
+	/// Swaps animations to a playlist
+	/// @param row1 - first number of animations in the playlist
+	/// @param row2 - second number of animations in the playlist
+	void swapAnimToPlayList(uint row1, uint row2); 
+	
+	/// Playback animation 
+	void playbackAnim(bool play);
+	
+	/// Reset playlist and animation
+	void reset();
+	
+	/// Get the total time of animation playlist
+	/// @return total time of animation
+	float getPlayListLength();
+	
+	/// get time length single animation
+	float getAnimLength(std::string name);
+	
+	/// Get slot infomation
+	void setSlotInfo(uint num, CSlotInfo& slotInfo) { _SlotInfo[num] = slotInfo; }
+
+	/// Set use mode playlist or mixer
+	void setMode(int mode) { _AnimationStatus.Mode = mode; }
+
+	/// Set in place mode animation
+	void setInPlace(bool enabled) { _inPlace = enabled; }
+
+	/// Get in place mode
+	bool getInPlace() { return _inPlace; }
+
+	/// Set inc position
+	void setIncPos(bool enabled) { _incPos = enabled; }
+
+	/// Get inc position
+	bool getIncPos() { return _incPos; }
+
+	/// Get information about the current status of playing a playlist
+	/// @return struct containing current information playback
+	SAnimationStatus getStatus() { return _AnimationStatus; }
+
+	/// Get name entity
+	/// @return name entity
+	std::string getName() { return _Name; }
+	
+	/// Get file name shape
+	/// @return file name shape
+	std::string getFileNameShape() { return _FileNameShape; }
+	
+	/// Get file name skeleton
+	/// @return file name skeleton
+	std::string getFileNameSkeleton() { return _FileNameSkeleton; }
+	
+	/// Get slot information
+	CSlotInfo getSlotInfo(uint num) { return _SlotInfo[num]; }
+
+	/// Get list loaded animations files
+	std::vector<std::string>& getAnimationList() { return _AnimationList; }
+
+	/// Get playlist animations
+	std::vector<std::string>& getPlayListAnimation() { return _PlayListAnimation; }
+
+	/// Get list loaded skeleton weight template files
+	std::vector<std::string>& getSWTList() { return _SWTList; }
+	
+	/// Get game interface for manipulating Skeleton.
+	NL3D::USkeleton getSkeleton() const { return _Skeleton; }
+	
+private:
+  	/// Constructor
+	CEntity(void);
+
+	/// Update the animate from the playlist or channel mixer
+	/// @param time - current time in second
+	void update(NL3D::TAnimationTime time);
+	
+	void resetChannel();
+	
+	/// Update the animate from the playlist
+	void animatePlayList(NL3D::TAnimationTime time);
+
+	/// Update the animate from the mixer
+	void animateChannelMixer();
+	void addTransformation (NLMISC::CMatrix &current, NL3D::UAnimation *anim, 
+				float begin, float end, 
+				NL3D::UTrack *posTrack, NL3D::UTrack *rotquatTrack, 
+				NL3D::UTrack *nextPosTrack, NL3D::UTrack *nextRotquatTrack, 
+				bool removeLast);
+
+	// The name of the entity
+	std::string			_Name;
+	std::string			_FileNameShape;
+	std::string			_FileNameSkeleton;
+	
+	SAnimationStatus		_AnimationStatus;
+
+	bool 				_inPlace;
+	bool 				_incPos;
+	
+	float 				_CharacterScalePos;
+	
+	// The mesh instance associated to this entity
+	NL3D::UInstance			_Instance;
+
+	// The skeleton binded to the instance
+	NL3D::USkeleton			_Skeleton;
+
+	NL3D::UPlayList			*_PlayList;
+
+	NL3D::UAnimationSet		*_AnimationSet;
+
+	// Animation input file
+	std::vector<std::string>	_AnimationList;
+	
+	// Skeleton weight input file
+	std::vector<std::string>	_SWTList;
+	
+	// Play list animation
+	std::vector<std::string >	_PlayListAnimation;
+		
+	// Slot info for this object
+	CSlotInfo			_SlotInfo[NL3D::CChannelMixer::NumAnimationSlot];
+
+	friend class CObjectViewerWidget;
+}; /* class CEntity */
+
+typedef std::map<std::string, CEntity>	CEntities;
+typedef CEntities::iterator		EIT;
+
+} /* namespace NLQT */
+
+#endif // ENTITY_H
diff --git a/code/nel/tools/3d/object_viewer_widget/src/interfaces.h b/code/nel/tools/3d/object_viewer_widget/src/interfaces.h
new file mode 100644
index 000000000..cbb731029
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/interfaces.h
@@ -0,0 +1,75 @@
+/*
+Object Viewer Qt Widget
+Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef INTERFACES_H
+#define INTERFACES_H
+
+#include <QtPlugin>
+
+namespace NL3D {
+	class UPlayListManager;
+}
+
+namespace NLQT 
+{
+
+	class IObjectViewer 
+	{
+
+	public:
+
+		virtual ~IObjectViewer() {}
+
+		virtual QString name() const = 0;
+
+		// object viewer stuff
+		virtual void init() = 0;
+		virtual void release() = 0;
+		virtual void updateInput() = 0;
+		virtual void renderDriver() = 0;
+		virtual void renderScene() = 0;
+		virtual void renderDebug2D() = 0;
+		virtual void saveScreenshot(const std::string &nameFile, bool jpg, bool png, bool tga) = 0;
+		virtual bool loadMesh (const std::string &meshFileName, const std::string &skelFileName) = 0;
+		virtual void resetScene() = 0;
+		virtual void setBackgroundColor(NLMISC::CRGBA backgroundColor) = 0;
+		virtual void setGraphicsDriver(bool Direct3D) = 0;
+		virtual void setSizeViewport(uint16 w, uint16 h) = 0;
+		virtual void setBloomEffect(bool enabled) = 0;
+		virtual void setCurrentObject(const std::string &name) = 0;
+		virtual const std::string& getCurrentObject() = 0;
+		virtual CEntity& getEntity(const std::string &name) = 0;
+		virtual void getListObjects(std::vector<std::string> &listObj) = 0;
+		virtual NLMISC::CRGBA getBackgroundColor() = 0;
+		virtual bool getDirect3D() = 0;
+		virtual bool getBloomEffect() const = 0;
+		virtual NL3D::UDriver *getDriver() = 0;
+		virtual NL3D::UScene *getScene() = 0;
+		virtual NL3D::UPlayListManager *getPlayListManager() = 0;
+		virtual void setCamera(NLMISC::CAABBox &bbox, NL3D::UTransform &entity, bool high_z) = 0;
+		virtual bool setupLight(const NLMISC::CVector &position, const NLMISC::CVector &direction) = 0;
+		virtual void setVisible(bool visible) = 0;
+		virtual QWidget* getWidget() = 0;
+
+	};
+
+} /* namespace NLQT */
+
+Q_DECLARE_INTERFACE(NLQT::IObjectViewer,"com.ryzom.dev.IObjectViewer/0.1")
+
+#endif 
\ No newline at end of file
diff --git a/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.cpp b/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.cpp
new file mode 100644
index 000000000..94b2b4248
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.cpp
@@ -0,0 +1,763 @@
+/*
+Object Viewer Qt Widget
+Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "object_viewer_widget.h"
+
+// STL includes
+
+// NeL includes
+#include <nel/misc/common.h>
+#include <nel/misc/debug.h>
+#include <nel/misc/file.h>
+#include <nel/misc/bitmap.h>
+#include <nel/misc/path.h>
+#include <nel/3d/u_driver.h>
+#include <nel/3d/driver_user.h>
+#include <nel/3d/u_text_context.h>
+#include <nel/3d/u_scene.h>
+#include <nel/3d/u_light.h>
+#include <nel/3d/u_camera.h>
+#include <nel/3d/u_instance.h>
+#include <nel/3d/u_skeleton.h>
+#include <nel/3d/u_play_list.h>
+#include <nel/3d/u_animation_set.h>
+#include <nel/3d/u_animation.h>
+#include <nel/3d/u_play_list_manager.h>
+#include <nel/3d/u_3d_mouse_listener.h>
+#include <nel/3d/bloom_effect.h>
+
+// Project includes
+
+Q_EXPORT_PLUGIN2(object_viewer_widget_qt, NLQT::CObjectViewerWidget)
+
+using namespace NLMISC;
+using namespace NL3D;
+using namespace std;
+
+namespace NLQT 
+{
+	CObjectViewerWidget *CObjectViewerWidget::_objectViewerWidget = NULL;
+
+	CObjectViewerWidget::CObjectViewerWidget(QWidget *parent)
+		: _isGraphicsInitialized(false), _isGraphicsEnabled(false), 
+		_Driver(NULL), _Light(0), _phi(0), _psi(0),_dist(2),
+		_CameraFocal(75), _CurrentInstance(""), _BloomEffect(false), 
+		_Scene(0), QWidget(parent) 
+	{
+
+		_objectViewerWidget = this;
+
+		_isGraphicsEnabled = true;
+
+		// As a special case, a QTimer with a timeout of 0 will time out as soon as all the events in the window system's event queue have been processed. 
+		// This can be used to do heavy work while providing a snappy user interface.
+		_mainTimer = new QTimer(this);
+		connect(_mainTimer, SIGNAL(timeout()), this, SLOT(updateRender()));
+		// timer->start(); // <- timeout 0
+		// it's heavy on cpu, though, when no 3d driver initialized :)
+		_mainTimer->start(25); // 25fps
+	}
+
+	CObjectViewerWidget::~CObjectViewerWidget()
+	{
+
+	}
+
+	void CObjectViewerWidget::init()
+	{
+		connect(this, SIGNAL(topLevelChanged(bool)),
+			this, SLOT(topLevelChanged(bool)));
+		//H_AUTO2
+		//nldebug("%d %d %d",_nlw->winId(), width(), height());
+
+#if defined(NL_OS_UNIX) && !defined(NL_OS_MAC)
+		dynamic_cast<QNLWidget*>(widget())->makeCurrent();
+#endif // defined(NL_OS_UNIX) && !defined(NL_OS_MAC)
+
+		nlWindow wnd = winId();
+		uint16 w = width();
+		uint16 h = height();
+
+		setMouseTracking(true);
+
+		// set background color from config
+		//NLMISC::CConfigFile::CVar v = Modules::config().getConfigFile().getVar("BackgroundColor");
+		//_BackgroundColor = CRGBA(v.asInt(0), v.asInt(1), v.asInt(2));
+		_BackgroundColor = CRGBA(255, 255, 255);
+
+		// set graphics driver from config
+		//NLMISC::CConfigFile::CVar v2 = Modules::config().getConfigFile().getVar("GraphicsDriver");
+		// Choose driver opengl to work correctly under Linux example
+		_Direct3D = false; //_Driver = OpenGL;
+
+#ifdef NL_OS_WINDOWS
+		//std::string driver = v2.asString();
+		//if (driver == "Direct3D") _Direct3D = true; //m_Driver = Direct3D;
+		//else if (driver == "OpenGL") _Direct3D = false; //m_Driver = OpenGL;
+		//else nlwarning("Invalid driver specified, defaulting to OpenGL");
+#endif
+
+		//Modules::config().setAndCallback("CameraFocal",CConfigCallback(this,&CObjectViewer::cfcbCameraFocal));
+		//Modules::config().setAndCallback("BloomEffect",CConfigCallback(this,&CObjectViewer::cfcbBloomEffect));
+
+		// create the driver
+		nlassert(!_Driver);
+
+		_Driver = UDriver::createDriver(0, _Direct3D, 0);
+		nlassert(_Driver);
+
+		// initialize the window with config file values
+		_Driver->setDisplay(wnd, NL3D::UDriver::CMode(w, h, 32));
+
+		//_Light = ULight::createLight();
+
+		//// set mode of the light
+		//_Light->setMode(ULight::DirectionalLight);
+
+		//// set position of the light
+		//_Light->setPosition(CVector(-20.f, 30.f, 10.f));
+
+		//// white light
+		//_Light->setAmbiant(CRGBA(255, 255, 255));
+
+		//// set and enable the light
+		//_Driver->setLight(0, *_Light);
+		//_Driver->enableLight(0);
+
+		// Create a scene
+		_Scene = _Driver->createScene(true);
+
+		_PlayListManager = _Scene->createPlayListManager();
+
+		//_Scene->enableLightingSystem(true);
+
+		// create the camera
+		UCamera camera = _Scene->getCam();
+
+		camera.setTransformMode (UTransformable::DirectMatrix);
+
+		setSizeViewport(w, h);
+
+		// camera will look at entities
+		camera.lookAt(NLMISC::CVector(_dist,0,1), NLMISC::CVector(0,0,0.5));
+
+		NLMISC::CVector hotSpot=NLMISC::CVector(0,0,0);
+
+		_MouseListener = _Driver->create3dMouseListener();
+		_MouseListener->setMatrix(_Scene->getCam().getMatrix());
+		_MouseListener->setFrustrum(_Scene->getCam().getFrustum());
+		_MouseListener->setHotSpot(hotSpot);
+		_MouseListener->setMouseMode(U3dMouseListener::edit3d);
+
+		NL3D::CBloomEffect::instance().setDriver(_Driver);
+		NL3D::CBloomEffect::instance().setScene(_Scene);
+		NL3D::CBloomEffect::instance().init(!_Direct3D);
+		//NL3D::CBloomEffect::instance().setDensityBloom(Modules::config().getConfigFile().getVar("BloomDensity").asInt());
+		//NL3D::CBloomEffect::instance().setSquareBloom(Modules::config().getConfigFile().getVar("BloomSquare").asBool());
+	}
+
+	void CObjectViewerWidget::release()
+	{
+		//H_AUTO2
+		nldebug("");
+
+		_Driver->delete3dMouseListener(_MouseListener);
+
+		// delete all entities
+		deleteEntities();
+
+		_Scene->deletePlayListManager(_PlayListManager);
+
+		// delete the scene
+		_Driver->deleteScene(_Scene);
+
+		// delete the light
+		delete _Light;
+
+		// release driver
+		nlassert(_Driver);
+		_Driver->release();
+		delete _Driver;
+		_Driver = NULL;
+	}
+
+	void CObjectViewerWidget::updateRender()
+	{
+		//nldebug("CMainWindow::updateRender");
+		updateInitialization(isVisible());
+
+		//QModelIndex index = _dirModel->setRootPath("D:/Dev/Ryzom/code/ryzom/common/data_leveldesign/leveldesign");
+		//_dirTree->setRootIndex(index);
+
+		if (isVisible())
+		{
+			// call all update functions
+			// 01. Update Utilities (configuration etc)
+
+			// 02. Update Time (deltas)
+			// ...
+
+			// 03. Update Receive (network, servertime, receive messages)
+			// ...
+
+			// 04. Update Input (keyboard controls, etc)
+			if (_isGraphicsInitialized)
+				updateInput();
+
+			// 05. Update Weather (sky, snow, wind, fog, sun)
+			// ...
+
+			// 06. Update Entities (movement, do after possible tp from incoming messages etc)
+			//      - Move other entities
+			//      - Update self entity
+			//      - Move bullets
+			// ...
+
+			// 07. Update Landscape (async zone loading near entity)
+			// ...
+
+			// 08. Update Collisions (entities)
+			//      - Update entities
+			//      - Update move container (swap with Update entities? todo: check code!)
+			//      - Update bullets
+			// ...
+
+			// 09. Update Animations (playlists)
+			//      - Needs to be either before or after entities, not sure, 
+			//        there was a problem with wrong order a while ago!!!
+
+
+			//updateAnimation(_AnimationDialog->getTime());
+
+			// 10. Update Camera (depends on entities)
+			// ...
+
+			// 11. Update Interface (login, ui, etc)
+			// ...
+
+			// 12. Update Sound (sound driver)
+			// ...
+
+			// 13. Update Send (network, send new position etc)
+			// ...
+
+			// 14. Update Debug (stuff for dev)
+			// ...
+
+			if (_isGraphicsInitialized && !getDriver()->isLost())
+			{
+				// 01. Render Driver (background color)			
+				renderDriver(); // clear all buffers
+
+				// 02. Render Sky (sky scene)
+				// ...
+
+				// 04. Render Scene (entity scene)
+				renderScene();
+
+				// 05. Render Effects (flare)
+				// ...
+
+				// 06. Render Interface 3D (player names)
+				// ...
+
+				// 07. Render Debug 3D
+				// ...
+
+				// 08. Render Interface 2D (chatboxes etc, optionally does have 3d)
+				// ...
+
+				// 09. Render Debug 2D (stuff for dev)
+				renderDebug2D();
+
+				// swap 3d buffers
+				getDriver()->swapBuffers();
+			}
+		}
+	}
+
+	void CObjectViewerWidget::updateInitialization(bool visible)
+	{
+		//nldebug("CMainWindow::updateInitialization");
+		bool done;
+		do
+		{
+			done = true; // set false whenever change
+			bool wantGraphics = _isGraphicsEnabled && visible;
+			// bool wantLandscape = wantGraphics && m_IsGraphicsInitialized && isLandscapeEnabled;
+
+			// .. stuff that depends on other stuff goes on top to prioritize deinitialization
+
+			// Landscape
+			// ...
+
+			// Graphics (Driver)
+			if (_isGraphicsInitialized)
+			{
+				if (!wantGraphics)
+				{
+					//_isGraphicsInitialized = false;
+					//release();
+					_mainTimer->stop();
+					//done = false;
+				}
+			}
+			else
+			{
+				if (wantGraphics)
+				{
+					init();
+					_isGraphicsInitialized = true;
+					_mainTimer->start(25);
+					//done = false;
+				}
+			}
+		}
+		while (!done);
+	}
+
+	void CObjectViewerWidget::updateInput()
+	{
+		_Driver->EventServer.pump();
+
+		// New matrix from camera
+		_Scene->getCam().setTransformMode(NL3D::UTransformable::DirectMatrix);
+		_Scene->getCam().setMatrix (_MouseListener->getViewMatrix());
+
+		//nldebug("%s",_Scene->getCam().getMatrix().getPos().asString().c_str());
+	}
+
+	void CObjectViewerWidget::renderDriver()
+	{
+		// Render the scene.
+		if((NL3D::CBloomEffect::instance().getDriver() != NULL) && (_BloomEffect))
+		{
+			NL3D::CBloomEffect::instance().initBloom();
+		}
+		_Driver->clearBuffers(_BackgroundColor);
+	}
+
+	void CObjectViewerWidget::renderScene()
+	{
+		// render the scene
+		_Scene->render();
+
+		if((NL3D::CBloomEffect::instance().getDriver() != NULL) && (_BloomEffect))
+		{
+			NL3D::CBloomEffect::instance().endBloom();
+			NL3D::CBloomEffect::instance().endInterfacesDisplayBloom();
+		}
+	}
+
+	void CObjectViewerWidget::renderDebug2D()
+	{
+	}
+
+	void CObjectViewerWidget::saveScreenshot(const std::string &nameFile, bool jpg, bool png, bool tga)
+	{
+		//H_AUTO2
+
+		// FIXME: create screenshot path if it doesn't exist!
+
+		// empty bitmap
+		CBitmap bitmap;
+		// copy the driver buffer to the bitmap
+		_Driver->getBuffer(bitmap);
+		// create the file name
+		string filename = std::string("./") + nameFile;
+		// write the bitmap as a jpg, png or tga to the file
+		if (jpg)
+		{
+			string newfilename = CFile::findNewFile(filename + ".jpg");
+			COFile outputFile(newfilename);
+			bitmap.writeJPG(outputFile, 100);
+			nlinfo("Screenshot '%s' saved", newfilename.c_str());
+		}
+		if (png)
+		{
+			string newfilename = CFile::findNewFile(filename + ".png");
+			COFile outputFile(newfilename);
+			bitmap.writePNG(outputFile, 24);
+			nlinfo("Screenshot '%s' saved", newfilename.c_str());
+		}
+		if (tga)
+		{
+			string newfilename = CFile::findNewFile(filename + ".tga");
+			COFile outputFile(newfilename);
+			bitmap.writeTGA(outputFile, 24, false);
+			nlinfo("Screenshot '%s' saved", newfilename.c_str());
+		}
+	}
+
+	bool CObjectViewerWidget::loadMesh(const std::string &meshFileName, const std::string &skelFileName)
+	{
+		std::string fileName = CFile::getFilenameWithoutExtension(meshFileName);
+		if ( _Entities.count(fileName) != 0) 
+			return false;
+
+		CPath::display();
+		CPath::addSearchPath(CFile::getPath(meshFileName), false, false);
+
+		// create instance of the mesh character
+		UInstance Entity = _Scene->createInstance(meshFileName);
+		
+		CAABBox bbox;
+		Entity.getShapeAABBox(bbox);
+		setCamera(bbox , Entity, true);
+
+		_MouseListener->setMatrix(_Scene->getCam().getMatrix());
+
+		USkeleton Skeleton = _Scene->createSkeleton(skelFileName);
+
+		// if we can't create entity, skip it
+		if (Entity.empty()) return false;
+
+		// create a new entity
+		EIT eit = (_Entities.insert (make_pair (fileName, CEntity()))).first;
+		CEntity	&entity = (*eit).second;
+
+		// set the entity up
+		entity._Name = fileName;
+		entity._FileNameShape = meshFileName;
+		entity._FileNameSkeleton = skelFileName;
+		entity._Instance = Entity;
+		if (!Skeleton.empty()) 
+		{
+			entity._Skeleton = Skeleton;
+			entity._Skeleton.bindSkin (entity._Instance);
+		}
+		entity._AnimationSet = _Driver->createAnimationSet(false);
+		entity._PlayList = _PlayListManager->createPlayList(entity._AnimationSet);
+		return true;
+	}
+
+	void CObjectViewerWidget::setVisible(bool visible)
+	{
+		// called by show()
+		// code assuming visible window needed to init the 3d driver
+		nldebug("%d", visible);
+		if (visible)
+		{
+			QWidget::setVisible(true);
+		}
+		else
+		{
+			QWidget::setVisible(false);
+		}
+	}
+
+	void CObjectViewerWidget::resetScene()
+	{
+		deleteEntities();
+
+		// Reset camera.
+		//..
+
+		// to load files with the same name but located in different directories
+		//CPath::clearMap();
+
+		// load and set search paths from config
+		//Modules::config().configSearchPaths();
+
+		_CurrentInstance = "";
+
+		nlinfo("Scene cleared");
+	}
+
+	void CObjectViewerWidget::setBackgroundColor(NLMISC::CRGBA backgroundColor)
+	{
+		_BackgroundColor = backgroundColor;
+
+		// config file variable changes
+		//Modules::config().getConfigFile().getVar("BackgroundColor").setAsInt(_BackgroundColor.R, 0);
+		//Modules::config().getConfigFile().getVar("BackgroundColor").setAsInt(_BackgroundColor.G, 1);
+		//Modules::config().getConfigFile().getVar("BackgroundColor").setAsInt(_BackgroundColor.B, 2);
+	}
+
+	void CObjectViewerWidget::setGraphicsDriver(bool Direct3D)
+	{
+		//_Direct3D = Direct3D;
+
+		//if (_Direct3D) Modules::config().getConfigFile().getVar("GraphicsDriver").setAsString("Direct3D");
+		//else Modules::config().getConfigFile().getVar("GraphicsDriver").setAsString("OpenGL");
+	}
+
+	void CObjectViewerWidget::setSizeViewport(uint16 w, uint16 h)
+	{
+		_Scene->getCam().setPerspective(_CameraFocal * (float)Pi/180.f, (float)w/h, 0.1f, 1000);
+	}
+
+	void CObjectViewerWidget::setCurrentObject(const std::string &name)
+	{
+		if ((_Entities.count(name) != 0) || ( name.empty() )) _CurrentInstance = name;
+		else nlerror ("Entity %s not found", name.c_str());
+		nlinfo("set current entity %s", _CurrentInstance.c_str());
+	}
+
+	CEntity& CObjectViewerWidget::getEntity(const std::string &name)
+	{
+		if ( _Entities.count(name) == 0) nlerror("Entity %s not found", name.c_str());
+		EIT eit = _Entities.find (name);
+		return (*eit).second;
+	}
+
+	void CObjectViewerWidget::getListObjects(std::vector<std::string> &listObj)
+	{
+		listObj.clear();
+		for (EIT eit = _Entities.begin(); eit != _Entities.end(); ++eit)
+			listObj.push_back((*eit).second._Name);
+	}
+
+	void CObjectViewerWidget::deleteEntity(CEntity &entity)
+	{
+		if (entity._PlayList != NULL)
+		{
+			_PlayListManager->deletePlayList (entity._PlayList);
+			entity._PlayList = NULL;
+		}
+
+		if (entity._AnimationSet != NULL)
+		{
+			_Driver->deleteAnimationSet(entity._AnimationSet);
+			entity._AnimationSet = NULL;
+		}
+
+		if (!entity._Skeleton.empty())
+		{
+			entity._Skeleton.detachSkeletonSon(entity._Instance);
+
+			_Scene->deleteSkeleton(entity._Skeleton);
+			entity._Skeleton = NULL;
+		}
+
+		if (!entity._Instance.empty())
+		{
+			_Scene->deleteInstance(entity._Instance);
+			entity._Instance = NULL;
+		}
+	}
+
+	void CObjectViewerWidget::deleteEntities()
+	{
+		for (EIT eit = _Entities.begin(); eit != _Entities.end(); ++eit)
+		{
+			CEntity	&entity = (*eit).second;
+			deleteEntity(entity);
+		}
+		_Entities.clear();
+	}
+
+	void CObjectViewerWidget::setCamera(CAABBox &bbox, UTransform &entity, bool high_z)
+	{
+		CVector pos(0.f, 0.f, 0.f);
+		CQuat quat(0.f, 0.f, 0.f, 0.f);
+		NL3D::UInstance inst;
+		inst.cast(entity);
+		if (!inst.empty())
+		{
+			inst.getDefaultPos(pos);
+			inst.getDefaultRotQuat(quat);
+			/*
+			if (quat.getAxis().isNull())
+			{
+			quat.set(0, 0, 0, 0);
+			inst.setRotQuat(quat);
+			}
+			*/
+			//		quat.set(1.f, 1.f, 0.f, 0.f);
+
+			//		inst.setRotQuat(quat);
+			//		inst.getRotQuat(quat);
+
+			// check for presence of all textures from each sets
+			//bool allGood = true;
+
+			//for(uint s = 0; s < 5; ++s)
+			//{
+			//	inst.selectTextureSet(s);
+
+			//	uint numMat = inst.getNumMaterials();
+
+			//	// by default, all textures are present
+			//	allGood = true;
+
+			//	for(uint i = 0; i < numMat; ++i)
+			//	{
+			//		UInstanceMaterial mat = inst.getMaterial(i);
+
+			//		for(sint j = 0; j <= mat.getLastTextureStage(); ++j)
+			//		{
+			//			// if a texture is missing
+			//			if (mat.isTextureFile(j) && mat.getTextureFileName(j) == "CTextureMultiFile:Dummy")
+			//				allGood = false;
+			//		}
+			//	}
+
+			//	// if all textures have been found for this set, skip other sets
+			//	if (allGood)
+			//		break;
+			//}
+		}
+
+		// fix scale (some shapes have a different value)
+		entity.setScale(1.f, 1.f, 1.f);
+
+		UCamera Camera = _Scene->getCam();
+		CVector max_radius = bbox.getHalfSize();
+
+		CVector center = bbox.getCenter();
+		entity.setPivot(center);
+		center += pos;
+
+		//_Scene->getCam().setPerspective(_CameraFocal * (float)Pi/180.f, (float)w/h, 0.1f, 1000);
+		float fov = float(_CameraFocal * (float)Pi/180.0);
+		//Camera.setPerspective (fov, 1.0f, 0.1f, 1000.0f);
+		float radius = max(max(max_radius.x, max_radius.y), max_radius.z);
+		if (radius == 0.f) radius = 1.f;
+		float left, right, bottom, top, znear, zfar;
+		Camera.getFrustum(left, right, bottom, top, znear, zfar);
+		float dist = radius / (tan(fov/2));
+		CVector eye(center);
+		/*	if (axis == CVector::I)
+		eye.y -= dist+radius;
+		else if (axis == CVector::J)
+		eye.x += dist+radius;
+		*/
+		//	quat.normalize();
+
+		CVector ax(quat.getAxis());
+
+		//	float angle = quat.getAngle();
+		/*
+		if (ax.isNull())
+		{
+		if (int(angle*100.f) == int(NLMISC::Pi * 200.f))
+		{
+		ax = CVector::J;
+		}
+		}
+		else 
+		*/
+		if (ax.isNull() || ax == CVector::I)
+		{
+			ax = CVector::J;
+		}
+		else if (ax == -CVector::K)
+		{
+			ax = -CVector::J;
+		}
+		/*	else if (ax.x < -0.9f && ax.y == 0.f && ax.z == 0.f)
+		{
+		ax = -CVector::J ;
+		}
+		*/
+		//	ax.normalize();
+
+		eye -= ax * (dist+radius);
+		if (high_z)
+			eye.z += max_radius.z/1.0f;
+		Camera.lookAt(eye, center);
+		setupLight(eye, center - eye);
+	}
+
+	bool CObjectViewerWidget::setupLight(const CVector &position, const CVector &direction)
+	{
+		if (!_Light)
+		_Light = ULight::createLight();
+		if (!_Light) return false;
+
+		// set mode of the light
+		_Light->setMode(ULight::DirectionalLight);
+
+		// set position of the light
+		//	Light->setupDirectional(settings.light_ambiant, settings.light_diffuse, settings.light_specular, settings.light_direction);
+		NLMISC::CRGBA light_ambiant = CRGBA(0,0,0);
+		NLMISC::CRGBA light_diffuse = CRGBA(255,255,255);
+		NLMISC::CRGBA light_specular = CRGBA(255,255,255);
+		NLMISC::CVector light_direction = CVector(0.25, 0.25, 0.25);
+		_Light->setupPointLight(light_ambiant, light_diffuse, light_specular, position, direction + light_direction);
+
+		// set and enable the light
+		_Driver->setLight(0, *_Light);
+		_Driver->enableLight(0);
+
+		return true;
+	}
+
+#if defined(NL_OS_WINDOWS)
+
+	typedef bool (*winProc)(NL3D::IDriver *driver, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+	bool CObjectViewerWidget::winEvent(MSG * message, long * result)
+	{
+		if (getDriver() && getDriver()->isActive())
+		{
+			NL3D::IDriver *driver = dynamic_cast<NL3D::CDriverUser*>(getDriver())->getDriver();
+			if (driver)
+			{
+				winProc proc = (winProc)driver->getWindowProc();
+				return proc(driver, message->hwnd, message->message, message->wParam, message->lParam);
+			}
+		}
+
+		return false;
+	}
+
+#elif defined(NL_OS_MAC)
+
+	typedef bool (*cocoaProc)(NL3D::IDriver*, const void* e);
+
+	bool CObjectViewerWidget::macEvent(EventHandlerCallRef caller, EventRef event)
+	{
+		if(caller)
+			nlerror("You are using QtCarbon! Only QtCocoa supported, please upgrade Qt");
+
+		if (getDriver() && getDriver()->isActive())
+		{
+			NL3D::IDriver *driver = dynamic_cast<NL3D::CDriverUser*>(getDriver())->getDriver();
+			if (driver)
+			{
+				cocoaProc proc = (cocoaProc)driver->getWindowProc();
+				return proc(driver, event);
+			}
+		}
+
+		return false;
+	}
+
+#elif defined(NL_OS_UNIX)
+
+	typedef bool (*x11Proc)(NL3D::IDriver *drv, XEvent *e);
+
+	bool CObjectViewerWidget::x11Event(XEvent *event)
+	{
+		if (getDriver() && getDriver()->isActive())
+		{
+			NL3D::IDriver *driver = dynamic_cast<NL3D::CDriverUser*>(getDriver())->getDriver();
+			if (driver)
+			{
+				x11Proc proc = (x11Proc)driver->getWindowProc();
+				return proc(driver, event);
+			}
+		}
+
+		return false;
+	}
+#endif
+
+} /* namespace NLQT */
diff --git a/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.h b/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.h
new file mode 100644
index 000000000..cf145716b
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.h
@@ -0,0 +1,218 @@
+/*
+Object Viewer Qt Widget
+Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef OBJECT_VIEWER_WIDGET_H
+#define OBJECT_VIEWER_WIDGET_H
+
+// STL includes
+
+// Qt includes
+#include <QtOpenGL/QGLWidget>
+#include <QTimer>
+
+// NeL includes
+#include <nel/misc/rgba.h>
+#include <nel/misc/aabbox.h>
+
+// Project includes
+#include "entity.h"
+#include "interfaces.h"
+
+namespace NL3D 
+{
+	class UDriver;
+	class UScene;
+	class ULight;
+	class UInstance;
+	class UCamera;
+	class USkeleton;
+	class UPlayListManager;
+	class U3dMouseListener;
+}
+
+/**
+namespace NLQT
+@brief namespace NLQT
+*/
+namespace NLQT 
+{
+	class CObjectViewerWidget: 
+		public QWidget, 
+		public IObjectViewer
+	{
+		Q_OBJECT
+		Q_INTERFACES(NLQT::IObjectViewer) 
+
+	public:
+		/// Default constructor.
+		CObjectViewerWidget(QWidget *parent = 0);
+		virtual ~CObjectViewerWidget();
+
+		static CObjectViewerWidget  &objViewWid() { return *_objectViewerWidget; }
+
+		/// Init a driver and create scene.
+		/// @param wnd - handle window.
+		/// @param w - width window.
+		/// @param h - height window.
+		void init();
+
+		/// Release class.
+		void release();
+
+		/// Update mouse and keyboard events. And update camera matrix.
+		void updateInput();
+
+		/// Render Driver (clear all buffers and set background color).
+		void renderDriver();
+
+		/// Render current scene.
+		void renderScene();
+
+		/// Render Debug 2D (stuff for dev).
+		void renderDebug2D();
+
+		/// Make a screenshot of the current scene and save.
+		void saveScreenshot(const std::string &nameFile, bool jpg, bool png, bool tga);
+
+		/// Load a mesh or particle system and add to current scene.
+		/// @param meshFileName - name loading shape or ps file.
+		/// @param skelFileName - name loading skeletin file.
+		/// @return true if file have been loaded, false if file have not been loaded.
+		bool loadMesh (const std::string &meshFileName, const std::string &skelFileName);
+
+		/// Reset current scene.
+		void resetScene();
+
+		/// Set the background color.
+		/// @param backgroundColor - background color.
+		void setBackgroundColor(NLMISC::CRGBA backgroundColor);
+
+		/// Set type driver.
+		/// @param Direct3D - type driver (true - Direct3D) or (false -OpenGL)
+		void setGraphicsDriver(bool Direct3D);
+
+		/// Set size viewport for correct set perspective
+		/// @param w - width window.
+		/// @param h - height window.
+		void setSizeViewport(uint16 w, uint16 h);
+		
+		void setBloomEffect(bool enabled) { _BloomEffect = enabled; }
+
+		/// Select instance from the scene
+		/// @param name - name instance,  "" if no instance edited
+		void setCurrentObject(const std::string &name);
+
+		/// Get current instance from the scene
+		/// @return name current instance, "" if no instance edited
+		const std::string& getCurrentObject() { return _CurrentInstance; }
+
+		/// Get entity from the scene
+		/// @return ref Entity
+		CEntity& getEntity(const std::string &name);
+
+		/// Get full list instances from the scene
+		/// @param listObj - ref of return list instances
+		void getListObjects(std::vector<std::string> &listObj);
+
+		/// Get value background color.
+		/// @return  background color.
+		NLMISC::CRGBA getBackgroundColor() { return _BackgroundColor; }
+
+		/// Get type driver.
+		/// @return true if have used Direct3D driver, false OpenGL driver.
+		inline bool getDirect3D() { return _Direct3D; }
+
+		inline bool getBloomEffect() const { return _BloomEffect; }
+
+		/// Get a pointer to the driver.
+		/// @return pointer to the driver.
+		inline NL3D::UDriver *getDriver() { return _Driver; }
+
+		/// Get a pointer to the scene.
+		/// @return pointer to the scene.
+		inline NL3D::UScene *getScene() { return _Scene; }
+
+		/// Get a manager of playlist
+		/// @return pointer to the UPlayListManager
+		inline NL3D::UPlayListManager *getPlayListManager() { return _PlayListManager; }
+
+		void setCamera(NLMISC::CAABBox &bbox, NL3D::UTransform &entity, bool high_z);
+		bool setupLight(const NLMISC::CVector &position, const NLMISC::CVector &direction);
+
+		virtual void setVisible(bool visible);
+
+		QWidget* getWidget() {return this;}
+
+		virtual QString name() const {return ("ObjectViewerWidget");}
+
+	protected:
+#if defined(NL_OS_WINDOWS)
+		virtual bool winEvent(MSG * message, long * result);
+#elif defined(NL_OS_MAC)
+		virtual bool macEvent(EventHandlerCallRef caller, EventRef event);
+#elif defined(NL_OS_UNIX)
+		virtual bool x11Event(XEvent *event);
+#endif
+
+	private Q_SLOTS:
+		void updateRender();
+
+	private:
+
+		static CObjectViewerWidget  *_objectViewerWidget;
+
+		// render stuff
+		QTimer *_mainTimer;
+		bool _isGraphicsInitialized, _isGraphicsEnabled;
+
+		void updateInitialization(bool visible);
+
+		void deleteEntity (CEntity &entity);
+
+		/// Delete all entities
+		void deleteEntities();
+
+		NLMISC::CRGBA 			_BackgroundColor;
+
+		NL3D::UDriver 			*_Driver;
+		NL3D::UScene 			*_Scene;
+		NL3D::UPlayListManager  *_PlayListManager;
+		NL3D::ULight 			*_Light;
+		NL3D::UCamera 			*_Camera;
+		NL3D::U3dMouseListener  *_MouseListener;
+
+		// The entities storage
+		CEntities		_Entities;
+
+		/// Camera parameters.
+		float _phi, _psi, _dist;
+		float _CameraFocal;
+
+		bool _Direct3D;
+		bool _BloomEffect;
+
+		std::string _CurrentInstance;
+
+		// a temporary solution, and later remove
+		friend class CAnimationSetDialog;
+
+	};/* class CObjectViewerWidget */
+
+} /* namespace NLQT */
+
+#endif // OBJECT_VIEWER_WIDGET_H
diff --git a/code/nel/tools/3d/object_viewer_widget/src/stdpch.cpp b/code/nel/tools/3d/object_viewer_widget/src/stdpch.cpp
new file mode 100644
index 000000000..f555cbb32
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/stdpch.cpp
@@ -0,0 +1,19 @@
+/*
+    Georges Editor Qt
+	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "stdpch.h"
diff --git a/code/nel/tools/3d/object_viewer_widget/src/stdpch.h b/code/nel/tools/3d/object_viewer_widget/src/stdpch.h
new file mode 100644
index 000000000..0ef614792
--- /dev/null
+++ b/code/nel/tools/3d/object_viewer_widget/src/stdpch.h
@@ -0,0 +1,33 @@
+/*
+    Object Viewer Qt
+    Copyright (C) 2010 Dzmitry Kamiahin <dnk-88@tut.by>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef NL_STDPCH_H
+#define NL_STDPCH_H
+
+#include <nel/misc/types_nl.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <nel/misc/common.h>
+
+#endif