Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity

Changed: #1200 Added first version of a possible 3d view qt widget plugin

Browse source
This commit is contained in:
aquiles 2010-11-29 15:39:19 +01:00
parent 5f350f1f00
commit 7626b9463f
10 changed files with 1858 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
code/nel/tools/3d/CMakeLists.txt
View file

@ -47,6 +47,7 @@ ENDIF(WIN32)
IF(WITH_QT) IF(WITH_QT)
ADD_SUBDIRECTORY(tile_edit_qt) ADD_SUBDIRECTORY(tile_edit_qt)
ADD_SUBDIRECTORY(object_viewer_qt) ADD_SUBDIRECTORY(object_viewer_qt)
ADD_SUBDIRECTORY(object_viewer_widget)
ENDIF(WITH_QT) ENDIF(WITH_QT)
IF(SQUISH_FOUND) IF(SQUISH_FOUND)

18
code/nel/tools/3d/object_viewer_widget/CMakeLists.txt Normal file
View file

@ -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)

42
code/nel/tools/3d/object_viewer_widget/src/CMakeLists.txt Normal file
View file

@ -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)

430
code/nel/tools/3d/object_viewer_widget/src/entity.cpp Normal file
View file

@ -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 */

259
code/nel/tools/3d/object_viewer_widget/src/entity.h Normal file
View file

@ -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

75
code/nel/tools/3d/object_viewer_widget/src/interfaces.h Normal file
View file

@ -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

763
code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.cpp Normal file
View file

@ -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 */

218
code/nel/tools/3d/object_viewer_widget/src/object_viewer_widget.h Normal file
View file

@ -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

19
code/nel/tools/3d/object_viewer_widget/src/stdpch.cpp Normal file
View file

@ -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"

33
code/nel/tools/3d/object_viewer_widget/src/stdpch.h Normal file
View file

@ -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