aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-23 09:28:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge

Browse source
This commit is contained in:
Nimetu 2014-01-03 18:02:08 +02:00
parent 40dacf5029
commit 9ac6ba900e
36 changed files with 10933 additions and 10933 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
code/nel/tools/3d/object_viewer_qt/src/plugins/CMakeLists.txt
View file

@ -1,23 +1,23 @@
ADD_SUBDIRECTORY(core)
ADD_SUBDIRECTORY(example)
ADD_SUBDIRECTORY(ovqt_sheet_builder)
ADD_SUBDIRECTORY(landscape_editor)
ADD_SUBDIRECTORY(log)
ADD_SUBDIRECTORY(disp_sheet_id)
ADD_SUBDIRECTORY(object_viewer)
ADD_SUBDIRECTORY(georges_editor)
ADD_SUBDIRECTORY(world_editor)
IF(WITH_GUI)
ADD_SUBDIRECTORY(gui_editor)
ENDIF(WITH_GUI)
ADD_SUBDIRECTORY(translation_manager)
ADD_SUBDIRECTORY(bnp_manager)
# Note: Temporarily disabled until development continues.
#ADD_SUBDIRECTORY(zone_painter)
# Ryzom Specific Plugins
IF(WITH_RYZOM AND WITH_RYZOM_TOOLS)
ADD_SUBDIRECTORY(mission_compiler)
ENDIF(WITH_RYZOM AND WITH_RYZOM_TOOLS)
ADD_SUBDIRECTORY(core)
ADD_SUBDIRECTORY(example)
ADD_SUBDIRECTORY(ovqt_sheet_builder)
ADD_SUBDIRECTORY(landscape_editor)
ADD_SUBDIRECTORY(log)
ADD_SUBDIRECTORY(disp_sheet_id)
ADD_SUBDIRECTORY(object_viewer)
ADD_SUBDIRECTORY(georges_editor)
ADD_SUBDIRECTORY(world_editor)
IF(WITH_GUI)
ADD_SUBDIRECTORY(gui_editor)
ENDIF(WITH_GUI)
ADD_SUBDIRECTORY(translation_manager)
ADD_SUBDIRECTORY(bnp_manager)
# Note: Temporarily disabled until development continues.
#ADD_SUBDIRECTORY(zone_painter)
# Ryzom Specific Plugins
IF(WITH_RYZOM AND WITH_RYZOM_TOOLS)
ADD_SUBDIRECTORY(mission_compiler)
ENDIF(WITH_RYZOM AND WITH_RYZOM_TOOLS)

146
code/nel/tools/3d/object_viewer_qt/src/plugins/core/CMakeLists.txt
View file

@ -1,73 +1,73 @@
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES})
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_CORE_PLUGIN_HDR
icore.h
icontext.h
icore_listener.h
ioptions_page.h
core_plugin.h
core.h
main_window.h
menu_manager.h
context_manager.h
settings_dialog.h
search_paths_settings_page.h
general_settings_page.h
plugin_view_dialog.h
)
SET(OVQT_CORE_PLUGIN_UIS settings_dialog.ui
plugin_view_dialog.ui
general_settings_page.ui
search_paths_settings_page.ui
)
SET(OVQT_CORE_PLUGIN_RCS core.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_CORE_PLUGIN_RC_SRCS ${OVQT_CORE_PLUGIN_RCS})
QT4_WRAP_CPP(OVQT_CORE_PLUGIN_MOC_SRC ${OVQT_CORE_PLUGIN_HDR})
QT4_WRAP_UI(OVQT_CORE_PLUGIN_UI_HDRS ${OVQT_CORE_PLUGIN_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_CORE_PLUGIN_UIS} ${OVQT_CORE_PLUGIN_RCS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_CORE_PLUGIN_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocSrc FILES ${OVQT_CORE_PLUGIN_MOC_SRC})
SOURCE_GROUP("Core Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_core SHARED ${SRC} ${OVQT_CORE_PLUGIN_MOC_SRC} ${OVQT_EXT_SYS_SRC} ${OVQT_CORE_PLUGIN_RC_SRCS} ${OVQT_CORE_PLUGIN_UI_HDRS})
TARGET_LINK_LIBRARIES(ovqt_plugin_core nelmisc ${QT_LIBRARIES})
NL_DEFAULT_PROPS(ovqt_plugin_core "NeL, Tools, 3D: Object Viewer Qt Plugin: Core")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_core)
NL_ADD_LIB_SUFFIX(ovqt_plugin_core)
ADD_DEFINITIONS(-DCORE_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
IF(WIN32)
IF(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
ELSE(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
ENDIF(WITH_INSTALL_LIBRARIES)
ELSE(WIN32)
IF(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d)
ELSE(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d)
ENDIF(WITH_INSTALL_LIBRARIES)
ENDIF(WIN32)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_core.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES})
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_CORE_PLUGIN_HDR
icore.h
icontext.h
icore_listener.h
ioptions_page.h
core_plugin.h
core.h
main_window.h
menu_manager.h
context_manager.h
settings_dialog.h
search_paths_settings_page.h
general_settings_page.h
plugin_view_dialog.h
)
SET(OVQT_CORE_PLUGIN_UIS settings_dialog.ui
plugin_view_dialog.ui
general_settings_page.ui
search_paths_settings_page.ui
)
SET(OVQT_CORE_PLUGIN_RCS core.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_CORE_PLUGIN_RC_SRCS ${OVQT_CORE_PLUGIN_RCS})
QT4_WRAP_CPP(OVQT_CORE_PLUGIN_MOC_SRC ${OVQT_CORE_PLUGIN_HDR})
QT4_WRAP_UI(OVQT_CORE_PLUGIN_UI_HDRS ${OVQT_CORE_PLUGIN_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_CORE_PLUGIN_UIS} ${OVQT_CORE_PLUGIN_RCS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_CORE_PLUGIN_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocSrc FILES ${OVQT_CORE_PLUGIN_MOC_SRC})
SOURCE_GROUP("Core Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_core SHARED ${SRC} ${OVQT_CORE_PLUGIN_MOC_SRC} ${OVQT_EXT_SYS_SRC} ${OVQT_CORE_PLUGIN_RC_SRCS} ${OVQT_CORE_PLUGIN_UI_HDRS})
TARGET_LINK_LIBRARIES(ovqt_plugin_core nelmisc ${QT_LIBRARIES})
NL_DEFAULT_PROPS(ovqt_plugin_core "NeL, Tools, 3D: Object Viewer Qt Plugin: Core")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_core)
NL_ADD_LIB_SUFFIX(ovqt_plugin_core)
ADD_DEFINITIONS(-DCORE_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
IF(WIN32)
IF(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
ELSE(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
ENDIF(WITH_INSTALL_LIBRARIES)
ELSE(WIN32)
IF(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} ARCHIVE DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d)
ELSE(WITH_INSTALL_LIBRARIES)
INSTALL(TARGETS ovqt_plugin_core LIBRARY DESTINATION ${NL_LIB_PREFIX} RUNTIME DESTINATION ${NL_BIN_PREFIX} COMPONENT tools3d)
ENDIF(WITH_INSTALL_LIBRARIES)
ENDIF(WIN32)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_core.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)

118
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/CMakeLists.txt
View file

@ -1,59 +1,59 @@
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES})
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_HDR landscape_editor_plugin.h
landscape_editor_window.h
landscape_scene_base.h
landscape_scene.h
list_zones_model.h
list_zones_widget.h
landscape_view.h
project_settings_dialog.h
snapshot_dialog.h
)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS landscape_editor_window.ui
list_zones_widget.ui
project_settings_dialog.ui
shapshot_dialog.ui
)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_RCS landscape_editor.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS ${OVQT_PLUGIN_LANDSCAPE_EDITOR_RCS})
QT4_WRAP_CPP(OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC ${OVQT_PLUGIN_LANDSCAPE_EDITOR_HDR})
QT4_WRAP_UI(OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocQrcSrc FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC} OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS)
SOURCE_GROUP("Landscape Editor Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_landscape_editor SHARED ${SRC}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC}
${OVQT_EXT_SYS_SRC}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS})
TARGET_LINK_LIBRARIES(ovqt_plugin_landscape_editor ovqt_plugin_core nelmisc nel3d nelgeorges nelligo ${QT_LIBRARIES} ${QT_QTOPENGL_LIBRARY})
NL_DEFAULT_PROPS(ovqt_plugin_landscape_editor "NeL, Tools, 3D: Object Viewer Qt Plugin: Landscape Editor")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_landscape_editor)
NL_ADD_LIB_SUFFIX(ovqt_plugin_landscape_editor)
ADD_DEFINITIONS(-DLANDSCAPE_EDITOR_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
INSTALL(TARGETS ovqt_plugin_landscape_editor LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${NL_BIN_PREFIX} ARCHIVE DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
#INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_landscape_editor.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES})
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_HDR landscape_editor_plugin.h
landscape_editor_window.h
landscape_scene_base.h
landscape_scene.h
list_zones_model.h
list_zones_widget.h
landscape_view.h
project_settings_dialog.h
snapshot_dialog.h
)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS landscape_editor_window.ui
list_zones_widget.ui
project_settings_dialog.ui
shapshot_dialog.ui
)
SET(OVQT_PLUGIN_LANDSCAPE_EDITOR_RCS landscape_editor.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS ${OVQT_PLUGIN_LANDSCAPE_EDITOR_RCS})
QT4_WRAP_CPP(OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC ${OVQT_PLUGIN_LANDSCAPE_EDITOR_HDR})
QT4_WRAP_UI(OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UIS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocQrcSrc FILES ${OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC} OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS)
SOURCE_GROUP("Landscape Editor Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_landscape_editor SHARED ${SRC}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_MOC_SRC}
${OVQT_EXT_SYS_SRC}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_UI_HDRS}
${OVQT_PLUGIN_LANDSCAPE_EDITOR_RC_SRCS})
TARGET_LINK_LIBRARIES(ovqt_plugin_landscape_editor ovqt_plugin_core nelmisc nel3d nelgeorges nelligo ${QT_LIBRARIES} ${QT_QTOPENGL_LIBRARY})
NL_DEFAULT_PROPS(ovqt_plugin_landscape_editor "NeL, Tools, 3D: Object Viewer Qt Plugin: Landscape Editor")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_landscape_editor)
NL_ADD_LIB_SUFFIX(ovqt_plugin_landscape_editor)
ADD_DEFINITIONS(-DLANDSCAPE_EDITOR_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
INSTALL(TARGETS ovqt_plugin_landscape_editor LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${NL_BIN_PREFIX} ARCHIVE DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
#INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_landscape_editor.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)

1080
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/builder_zone.cpp
View file

File diff suppressed because it is too large Load diff

412
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/builder_zone_base.cpp
View file

@ -1,206 +1,206 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "builder_zone_base.h"
#include "landscape_scene_base.h"
#include "zone_region_editor.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QDir>
#include <QtGui/QMessageBox>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
int NewLandId = 0;
ZoneBuilderBase::ZoneBuilderBase(LandscapeSceneBase *landscapeScene)
: m_pixmapDatabase(0),
m_landscapeSceneBase(landscapeScene)
{
nlassert(m_landscapeSceneBase);
m_pixmapDatabase = new PixmapDatabase();
m_lastPathName = "";
}
ZoneBuilderBase::~ZoneBuilderBase()
{
delete m_pixmapDatabase;
}
bool ZoneBuilderBase::init(const QString &pathName, bool displayProgress)
{
if (pathName.isEmpty())
return false;
if (pathName != m_lastPathName)
{
m_lastPathName = pathName;
QString zoneBankPath = pathName;
zoneBankPath += "/zoneligos/";
// Init the ZoneBank
m_zoneBank.reset();
if (!initZoneBank (zoneBankPath))
{
m_zoneBank.reset();
return false;
}
// Construct the DataBase from the ZoneBank
QString zoneBitmapPath = pathName;
zoneBitmapPath += "/zonebitmaps/";
m_pixmapDatabase->reset();
if (!m_pixmapDatabase->loadPixmaps(zoneBitmapPath, m_zoneBank, displayProgress))
{
m_zoneBank.reset();
return false;
}
}
return true;
}
int ZoneBuilderBase::loadZoneRegion(const QString &fileName, int defaultId)
{
LandscapeItem landItem;
landItem.zoneRegionObject = new ZoneRegionObject();
landItem.zoneRegionObject->load(fileName.toStdString());
if (!checkOverlaps(landItem.zoneRegionObject->ligoZoneRegion()))
{
delete landItem.zoneRegionObject;
return -1;
}
int id = defaultId;
if (id == -1)
id = NewLandId++;
// landItem.builderZoneRegion = new BuilderZoneRegion(LandCounter);
// landItem.builderZoneRegion->init(this);
m_landscapeSceneBase->addZoneRegion(landItem.zoneRegionObject->ligoZoneRegion());
// landItem.rectItem = m_landscapeScene->createLayerBlackout(landItem.zoneRegionObject->ligoZoneRegion());
m_landscapeMap.insert(id, landItem);
calcMask();
return id;
}
void ZoneBuilderBase::deleteZoneRegion(int id)
{
if (m_landscapeMap.contains(id))
{
m_landscapeSceneBase->delZoneRegion(m_landscapeMap.value(id).zoneRegionObject->ligoZoneRegion());
delete m_landscapeMap.value(id).zoneRegionObject;
// delete m_landscapeMap.value(id).builderZoneRegion;
m_landscapeMap.remove(id);
calcMask();
}
else
nlwarning("Landscape (id %i) not found", id);
}
int ZoneBuilderBase::countZoneRegion() const
{
return m_landscapeMap.size();
}
ZoneRegionObject *ZoneBuilderBase::zoneRegion(int id) const
{
return m_landscapeMap.value(id).zoneRegionObject;
}
bool ZoneBuilderBase::initZoneBank (const QString &pathName)
{
QDir *dir = new QDir(pathName);
QStringList filters;
filters << "*.ligozone";
// Find all ligozone files in dir
QStringList listFiles = dir->entryList(filters, QDir::Files);
std::string error;
Q_FOREACH(QString file, listFiles)
{
//nlinfo(file.toStdString().c_str());
if (!m_zoneBank.addElement((pathName + file).toStdString(), error))
QMessageBox::critical(0, QObject::tr("Landscape editor"), QString(error.c_str()), QMessageBox::Ok);
}
delete dir;
return true;
}
PixmapDatabase *ZoneBuilderBase::pixmapDatabase() const
{
return m_pixmapDatabase;
}
QString ZoneBuilderBase::dataPath() const
{
return m_lastPathName;
}
void ZoneBuilderBase::calcMask()
{
m_minY = m_minX = 1000000;
m_maxY = m_maxX = -1000000;
if (m_landscapeMap.size() == 0)
return;
QMapIterator<int, LandscapeItem> i(m_landscapeMap);
while (i.hasNext())
{
i.next();
const NLLIGO::CZoneRegion &region = i.value().zoneRegionObject->ligoZoneRegion();
if (m_minX > region.getMinX())
m_minX = region.getMinX();
if (m_minY > region.getMinY())
m_minY = region.getMinY();
if (m_maxX < region.getMaxX())
m_maxX = region.getMaxX();
if (m_maxY < region.getMaxY())
m_maxY = region.getMaxY();
}
}
bool ZoneBuilderBase::checkOverlaps(const NLLIGO::CZoneRegion &newZoneRegion)
{
QMapIterator<int, LandscapeItem> it(m_landscapeMap);
while (it.hasNext())
{
it.next();
const NLLIGO::CZoneRegion &zoneRegion = it.value().zoneRegionObject->ligoZoneRegion();
for (sint32 y = zoneRegion.getMinY(); y <= zoneRegion.getMaxY(); ++y)
for (sint32 x = zoneRegion.getMinX(); x <= zoneRegion.getMaxX(); ++x)
{
const std::string &refZoneName = zoneRegion.getName(x, y);
if (refZoneName != STRING_UNUSED)
{
const std::string &zoneName = newZoneRegion.getName(x, y);
if ((zoneName != STRING_UNUSED) && (zoneName != STRING_OUT_OF_BOUND))
return false;
}
}
}
return true;
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "builder_zone_base.h"
#include "landscape_scene_base.h"
#include "zone_region_editor.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QDir>
#include <QtGui/QMessageBox>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
int NewLandId = 0;
ZoneBuilderBase::ZoneBuilderBase(LandscapeSceneBase *landscapeScene)
: m_pixmapDatabase(0),
m_landscapeSceneBase(landscapeScene)
{
nlassert(m_landscapeSceneBase);
m_pixmapDatabase = new PixmapDatabase();
m_lastPathName = "";
}
ZoneBuilderBase::~ZoneBuilderBase()
{
delete m_pixmapDatabase;
}
bool ZoneBuilderBase::init(const QString &pathName, bool displayProgress)
{
if (pathName.isEmpty())
return false;
if (pathName != m_lastPathName)
{
m_lastPathName = pathName;
QString zoneBankPath = pathName;
zoneBankPath += "/zoneligos/";
// Init the ZoneBank
m_zoneBank.reset();
if (!initZoneBank (zoneBankPath))
{
m_zoneBank.reset();
return false;
}
// Construct the DataBase from the ZoneBank
QString zoneBitmapPath = pathName;
zoneBitmapPath += "/zonebitmaps/";
m_pixmapDatabase->reset();
if (!m_pixmapDatabase->loadPixmaps(zoneBitmapPath, m_zoneBank, displayProgress))
{
m_zoneBank.reset();
return false;
}
}
return true;
}
int ZoneBuilderBase::loadZoneRegion(const QString &fileName, int defaultId)
{
LandscapeItem landItem;
landItem.zoneRegionObject = new ZoneRegionObject();
landItem.zoneRegionObject->load(fileName.toStdString());
if (!checkOverlaps(landItem.zoneRegionObject->ligoZoneRegion()))
{
delete landItem.zoneRegionObject;
return -1;
}
int id = defaultId;
if (id == -1)
id = NewLandId++;
// landItem.builderZoneRegion = new BuilderZoneRegion(LandCounter);
// landItem.builderZoneRegion->init(this);
m_landscapeSceneBase->addZoneRegion(landItem.zoneRegionObject->ligoZoneRegion());
// landItem.rectItem = m_landscapeScene->createLayerBlackout(landItem.zoneRegionObject->ligoZoneRegion());
m_landscapeMap.insert(id, landItem);
calcMask();
return id;
}
void ZoneBuilderBase::deleteZoneRegion(int id)
{
if (m_landscapeMap.contains(id))
{
m_landscapeSceneBase->delZoneRegion(m_landscapeMap.value(id).zoneRegionObject->ligoZoneRegion());
delete m_landscapeMap.value(id).zoneRegionObject;
// delete m_landscapeMap.value(id).builderZoneRegion;
m_landscapeMap.remove(id);
calcMask();
}
else
nlwarning("Landscape (id %i) not found", id);
}
int ZoneBuilderBase::countZoneRegion() const
{
return m_landscapeMap.size();
}
ZoneRegionObject *ZoneBuilderBase::zoneRegion(int id) const
{
return m_landscapeMap.value(id).zoneRegionObject;
}
bool ZoneBuilderBase::initZoneBank (const QString &pathName)
{
QDir *dir = new QDir(pathName);
QStringList filters;
filters << "*.ligozone";
// Find all ligozone files in dir
QStringList listFiles = dir->entryList(filters, QDir::Files);
std::string error;
Q_FOREACH(QString file, listFiles)
{
//nlinfo(file.toStdString().c_str());
if (!m_zoneBank.addElement((pathName + file).toStdString(), error))
QMessageBox::critical(0, QObject::tr("Landscape editor"), QString(error.c_str()), QMessageBox::Ok);
}
delete dir;
return true;
}
PixmapDatabase *ZoneBuilderBase::pixmapDatabase() const
{
return m_pixmapDatabase;
}
QString ZoneBuilderBase::dataPath() const
{
return m_lastPathName;
}
void ZoneBuilderBase::calcMask()
{
m_minY = m_minX = 1000000;
m_maxY = m_maxX = -1000000;
if (m_landscapeMap.size() == 0)
return;
QMapIterator<int, LandscapeItem> i(m_landscapeMap);
while (i.hasNext())
{
i.next();
const NLLIGO::CZoneRegion &region = i.value().zoneRegionObject->ligoZoneRegion();
if (m_minX > region.getMinX())
m_minX = region.getMinX();
if (m_minY > region.getMinY())
m_minY = region.getMinY();
if (m_maxX < region.getMaxX())
m_maxX = region.getMaxX();
if (m_maxY < region.getMaxY())
m_maxY = region.getMaxY();
}
}
bool ZoneBuilderBase::checkOverlaps(const NLLIGO::CZoneRegion &newZoneRegion)
{
QMapIterator<int, LandscapeItem> it(m_landscapeMap);
while (it.hasNext())
{
it.next();
const NLLIGO::CZoneRegion &zoneRegion = it.value().zoneRegionObject->ligoZoneRegion();
for (sint32 y = zoneRegion.getMinY(); y <= zoneRegion.getMaxY(); ++y)
for (sint32 x = zoneRegion.getMinX(); x <= zoneRegion.getMaxX(); ++x)
{
const std::string &refZoneName = zoneRegion.getName(x, y);
if (refZoneName != STRING_UNUSED)
{
const std::string &zoneName = newZoneRegion.getName(x, y);
if ((zoneName != STRING_UNUSED) && (zoneName != STRING_OUT_OF_BOUND))
return false;
}
}
}
return true;
}
} /* namespace LandscapeEditor */

4286
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/builder_zone_region.cpp
View file

File diff suppressed because it is too large Load diff

214
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/builder_zone_region.h
View file

@ -1,107 +1,107 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef BUILDER_ZONE_REGION_H
#define BUILDER_ZONE_REGION_H
// Project includes
// NeL includes
#include <nel/ligo/zone_bank.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <string>
#include <vector>
#include <queue>
// Qt includes
namespace LandscapeEditor
{
class ZoneBuilder;
class ToUpdate;
// CZoneRegion contains informations about the zones painted.
// (Legacy class from old world editor. It needs to refactoring!)
class BuilderZoneRegion
{
public:
explicit BuilderZoneRegion(uint regionId);
// New interface
bool init(ZoneBuilder *zoneBuilder);
void add(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void invertCutEdge(sint32 x, sint32 y, uint8 cePos);
void cycleTransition(sint32 x, sint32 y);
bool addNotPropagate(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
/// Brutal adding a zone over empty space do not propagate in any way -> can result
/// in inconsistency when trying the propagation mode
void addForce (sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void del(sint32 x, sint32 y, bool transition = false, ToUpdate *pUpdate = 0);
void move(sint32 x, sint32 y);
uint32 countZones();
void reduceMin();
uint getRegionId() const;
private:
// An element of the graph
struct SMatNode
{
std::string Name;
// Position in the tree (vector of nodes)
std::vector<uint32> Arcs;
};
void addTransition(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void addToUpdateAndCreate(BuilderZoneRegion *builderZoneRegion, sint32 sharePos, sint32 x, sint32 y,
const std::string &newMat, ToUpdate *ptCreate, ToUpdate *ptUpdate);
void putTransitions(sint32 x, sint32 y, const NLLIGO::SPiece &mask, const std::string &matName, ToUpdate *ptUpdate);
void updateTrans(sint32 x, sint32 y, NLLIGO::CZoneBankElement *zoneBankElement = 0);
std::string getNextMatInTree(const std::string &matA, const std::string &matB);
/// Find the fastest way between posA and posB in the MatTree (Dijkstra)
void tryPath(uint32 posA, uint32 posB, std::vector<uint32> &path);
void set(sint32 x, sint32 y, sint32 posX, sint32 posY, const std::string &zoneName, bool transition = false);
void setRot(sint32 x, sint32 y, uint8 rot);
void setFlip(sint32 x, sint32 y, uint8 flip);
void resize(sint32 newMinX, sint32 newMaxX, sint32 newMinY, sint32 newMaxY);
void placePiece(sint32 x, sint32 y, uint8 rot, uint8 flip,
NLLIGO::SPiece &sMask, NLLIGO::SPiece &sPosX, NLLIGO::SPiece &sPosY,
const std::string &eltName);
uint m_regionId;
// To use the global mask
ZoneBuilder *m_zoneBuilder;
// The tree of transition between materials
std::vector<SMatNode> m_matTree;
bool m_firstInit;
};
} /* namespace LandscapeEditor */
#endif // BUILDER_ZONE_REGION_H
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef BUILDER_ZONE_REGION_H
#define BUILDER_ZONE_REGION_H
// Project includes
// NeL includes
#include <nel/ligo/zone_bank.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <string>
#include <vector>
#include <queue>
// Qt includes
namespace LandscapeEditor
{
class ZoneBuilder;
class ToUpdate;
// CZoneRegion contains informations about the zones painted.
// (Legacy class from old world editor. It needs to refactoring!)
class BuilderZoneRegion
{
public:
explicit BuilderZoneRegion(uint regionId);
// New interface
bool init(ZoneBuilder *zoneBuilder);
void add(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void invertCutEdge(sint32 x, sint32 y, uint8 cePos);
void cycleTransition(sint32 x, sint32 y);
bool addNotPropagate(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
/// Brutal adding a zone over empty space do not propagate in any way -> can result
/// in inconsistency when trying the propagation mode
void addForce (sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void del(sint32 x, sint32 y, bool transition = false, ToUpdate *pUpdate = 0);
void move(sint32 x, sint32 y);
uint32 countZones();
void reduceMin();
uint getRegionId() const;
private:
// An element of the graph
struct SMatNode
{
std::string Name;
// Position in the tree (vector of nodes)
std::vector<uint32> Arcs;
};
void addTransition(sint32 x, sint32 y, uint8 rot, uint8 flip, NLLIGO::CZoneBankElement *zoneBankElement);
void addToUpdateAndCreate(BuilderZoneRegion *builderZoneRegion, sint32 sharePos, sint32 x, sint32 y,
const std::string &newMat, ToUpdate *ptCreate, ToUpdate *ptUpdate);
void putTransitions(sint32 x, sint32 y, const NLLIGO::SPiece &mask, const std::string &matName, ToUpdate *ptUpdate);
void updateTrans(sint32 x, sint32 y, NLLIGO::CZoneBankElement *zoneBankElement = 0);
std::string getNextMatInTree(const std::string &matA, const std::string &matB);
/// Find the fastest way between posA and posB in the MatTree (Dijkstra)
void tryPath(uint32 posA, uint32 posB, std::vector<uint32> &path);
void set(sint32 x, sint32 y, sint32 posX, sint32 posY, const std::string &zoneName, bool transition = false);
void setRot(sint32 x, sint32 y, uint8 rot);
void setFlip(sint32 x, sint32 y, uint8 flip);
void resize(sint32 newMinX, sint32 newMaxX, sint32 newMinY, sint32 newMaxY);
void placePiece(sint32 x, sint32 y, uint8 rot, uint8 flip,
NLLIGO::SPiece &sMask, NLLIGO::SPiece &sPosX, NLLIGO::SPiece &sPosY,
const std::string &eltName);
uint m_regionId;
// To use the global mask
ZoneBuilder *m_zoneBuilder;
// The tree of transition between materials
std::vector<SMatNode> m_matTree;
bool m_firstInit;
};
} /* namespace LandscapeEditor */
#endif // BUILDER_ZONE_REGION_H

356
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_actions.cpp
View file

@ -1,178 +1,178 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_actions.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
namespace LandscapeEditor
{
LigoTileCommand::LigoTileCommand(const LigoData &data, const ZonePosition &zonePos,
ZoneBuilder *zoneBuilder, LandscapeScene *scene,
QUndoCommand *parent)
: QUndoCommand(parent),
m_zoneBuilder(zoneBuilder),
m_scene(scene)
{
// Backup position
m_zonePos = zonePos;
// Backup new data
m_newLigoData = data;
// Backup old data
m_zoneBuilder->ligoData(m_oldLigoData, m_zonePos);
}
LigoTileCommand::~LigoTileCommand()
{
}
void LigoTileCommand::undo ()
{
m_zoneBuilder->setLigoData(m_oldLigoData, m_zonePos);
}
void LigoTileCommand::redo ()
{
m_zoneBuilder->setLigoData(m_newLigoData, m_zonePos);
}
UndoScanRegionCommand::UndoScanRegionCommand(bool direction, ZoneBuilder *zoneBuilder, LandscapeScene *scene, QUndoCommand *parent)
: QUndoCommand(parent),
m_direction(direction),
m_zoneBuilder(zoneBuilder),
m_scene(scene)
{
}
UndoScanRegionCommand::~UndoScanRegionCommand()
{
m_zonePositionList.clear();
}
void UndoScanRegionCommand::setScanList(const QList<ZonePosition> &zonePositionList)
{
m_zonePositionList = zonePositionList;
}
void UndoScanRegionCommand::undo()
{
if (m_direction)
applyChanges();
}
void UndoScanRegionCommand::redo()
{
if (!m_direction)
applyChanges();
}
void UndoScanRegionCommand::applyChanges()
{
for (int i = 0; i < m_zonePositionList.size(); ++i)
m_scene->deleteItemZone(m_zonePositionList.at(i));
for (int i = 0; i < m_zonePositionList.size(); ++i)
{
LigoData data;
m_zoneBuilder->ligoData(data, m_zonePositionList.at(i));
m_scene->createItemZone(data, m_zonePositionList.at(i));
}
}
LigoResizeCommand::LigoResizeCommand(int index, sint32 newMinX, sint32 newMaxX,
sint32 newMinY, sint32 newMaxY, ZoneBuilder *zoneBuilder,
QUndoCommand *parent)
: QUndoCommand(parent),
m_zoneBuilder(zoneBuilder)
{
m_index = index;
m_newMinX = newMinX;
m_newMaxX = newMaxX;
m_newMinY = newMinY;
m_newMaxY = newMaxY;
// Backup old region zone
m_oldZoneRegion = m_zoneBuilder->zoneRegion(m_index)->ligoZoneRegion();
}
LigoResizeCommand::~LigoResizeCommand()
{
}
void LigoResizeCommand::undo ()
{
// Restore old region zone
m_zoneBuilder->zoneRegion(m_index)->setLigoZoneRegion(m_oldZoneRegion);
}
void LigoResizeCommand::redo ()
{
// Get the zone region
NLLIGO::CZoneRegion &region = m_zoneBuilder->zoneRegion(m_index)->ligoZoneRegion();
sint32 i, j;
std::vector<LigoData> newZones;
newZones.resize((1 + m_newMaxX - m_newMinX) * (1 + m_newMaxY - m_newMinY));
sint32 newStride = 1 + m_newMaxX - m_newMinX;
sint32 Stride = 1 + region.getMaxX() - region.getMinX();
for (j = m_newMinY; j <= m_newMaxY; ++j)
for (i = m_newMinX; i <= m_newMaxX; ++i)
{
// Ref on the new value
LigoData &data = newZones[(i - m_newMinX) + (j - m_newMinY) * newStride];
// In the old array ?
if ((i >= region.getMinX()) && (i <= region.getMaxX()) &&
(j >= region.getMinY()) && (j <= region.getMaxY()))
{
// Backup values
m_zoneBuilder->ligoData(data, ZonePosition(i, j, m_index));
}
}
region.resize(m_newMinX, m_newMaxX, m_newMinY, m_newMaxY);
for (j = m_newMinY; j <= m_newMaxY; ++j)
for (i = m_newMinX; i <= m_newMaxX; ++i)
{
// Ref on the new value
const LigoData &data = newZones[(i - m_newMinX) + (j - m_newMinY) * newStride];
region.setName(i, j, data.zoneName);
region.setPosX(i, j, data.posX);
region.setPosY(i, j, data.posY);
region.setRot(i, j, data.rot);
region.setFlip(i, j, data.flip);
uint k;
for (k = 0; k < 4; k++)
{
region.setSharingMatNames(i, j, k, data.sharingMatNames[k]);
region.setSharingCutEdges(i, j, k, data.sharingCutEdges[k]);
}
}
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_actions.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
namespace LandscapeEditor
{
LigoTileCommand::LigoTileCommand(const LigoData &data, const ZonePosition &zonePos,
ZoneBuilder *zoneBuilder, LandscapeScene *scene,
QUndoCommand *parent)
: QUndoCommand(parent),
m_zoneBuilder(zoneBuilder),
m_scene(scene)
{
// Backup position
m_zonePos = zonePos;
// Backup new data
m_newLigoData = data;
// Backup old data
m_zoneBuilder->ligoData(m_oldLigoData, m_zonePos);
}
LigoTileCommand::~LigoTileCommand()
{
}
void LigoTileCommand::undo ()
{
m_zoneBuilder->setLigoData(m_oldLigoData, m_zonePos);
}
void LigoTileCommand::redo ()
{
m_zoneBuilder->setLigoData(m_newLigoData, m_zonePos);
}
UndoScanRegionCommand::UndoScanRegionCommand(bool direction, ZoneBuilder *zoneBuilder, LandscapeScene *scene, QUndoCommand *parent)
: QUndoCommand(parent),
m_direction(direction),
m_zoneBuilder(zoneBuilder),
m_scene(scene)
{
}
UndoScanRegionCommand::~UndoScanRegionCommand()
{
m_zonePositionList.clear();
}
void UndoScanRegionCommand::setScanList(const QList<ZonePosition> &zonePositionList)
{
m_zonePositionList = zonePositionList;
}
void UndoScanRegionCommand::undo()
{
if (m_direction)
applyChanges();
}
void UndoScanRegionCommand::redo()
{
if (!m_direction)
applyChanges();
}
void UndoScanRegionCommand::applyChanges()
{
for (int i = 0; i < m_zonePositionList.size(); ++i)
m_scene->deleteItemZone(m_zonePositionList.at(i));
for (int i = 0; i < m_zonePositionList.size(); ++i)
{
LigoData data;
m_zoneBuilder->ligoData(data, m_zonePositionList.at(i));
m_scene->createItemZone(data, m_zonePositionList.at(i));
}
}
LigoResizeCommand::LigoResizeCommand(int index, sint32 newMinX, sint32 newMaxX,
sint32 newMinY, sint32 newMaxY, ZoneBuilder *zoneBuilder,
QUndoCommand *parent)
: QUndoCommand(parent),
m_zoneBuilder(zoneBuilder)
{
m_index = index;
m_newMinX = newMinX;
m_newMaxX = newMaxX;
m_newMinY = newMinY;
m_newMaxY = newMaxY;
// Backup old region zone
m_oldZoneRegion = m_zoneBuilder->zoneRegion(m_index)->ligoZoneRegion();
}
LigoResizeCommand::~LigoResizeCommand()
{
}
void LigoResizeCommand::undo ()
{
// Restore old region zone
m_zoneBuilder->zoneRegion(m_index)->setLigoZoneRegion(m_oldZoneRegion);
}
void LigoResizeCommand::redo ()
{
// Get the zone region
NLLIGO::CZoneRegion &region = m_zoneBuilder->zoneRegion(m_index)->ligoZoneRegion();
sint32 i, j;
std::vector<LigoData> newZones;
newZones.resize((1 + m_newMaxX - m_newMinX) * (1 + m_newMaxY - m_newMinY));
sint32 newStride = 1 + m_newMaxX - m_newMinX;
sint32 Stride = 1 + region.getMaxX() - region.getMinX();
for (j = m_newMinY; j <= m_newMaxY; ++j)
for (i = m_newMinX; i <= m_newMaxX; ++i)
{
// Ref on the new value
LigoData &data = newZones[(i - m_newMinX) + (j - m_newMinY) * newStride];
// In the old array ?
if ((i >= region.getMinX()) && (i <= region.getMaxX()) &&
(j >= region.getMinY()) && (j <= region.getMaxY()))
{
// Backup values
m_zoneBuilder->ligoData(data, ZonePosition(i, j, m_index));
}
}
region.resize(m_newMinX, m_newMaxX, m_newMinY, m_newMaxY);
for (j = m_newMinY; j <= m_newMaxY; ++j)
for (i = m_newMinX; i <= m_newMaxX; ++i)
{
// Ref on the new value
const LigoData &data = newZones[(i - m_newMinX) + (j - m_newMinY) * newStride];
region.setName(i, j, data.zoneName);
region.setPosX(i, j, data.posX);
region.setPosY(i, j, data.posY);
region.setRot(i, j, data.rot);
region.setFlip(i, j, data.flip);
uint k;
for (k = 0; k < 4; k++)
{
region.setSharingMatNames(i, j, k, data.sharingMatNames[k]);
region.setSharingCutEdges(i, j, k, data.sharingCutEdges[k]);
}
}
}
} /* namespace LandscapeEditor */

200
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_editor_plugin.cpp
View file

@ -1,100 +1,100 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_editor_plugin.h"
#include "landscape_editor_window.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include "nel/misc/debug.h"
// Qt includes
#include <QtCore/QObject>
namespace LandscapeEditor
{
LandscapeEditorPlugin::~LandscapeEditorPlugin()
{
Q_FOREACH(QObject *obj, m_autoReleaseObjects)
{
m_plugMan->removeObject(obj);
}
qDeleteAll(m_autoReleaseObjects);
m_autoReleaseObjects.clear();
}
bool LandscapeEditorPlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString)
{
Q_UNUSED(errorString);
m_plugMan = pluginManager;
addAutoReleasedObject(new LandscapeEditorContext(this));
return true;
}
void LandscapeEditorPlugin::extensionsInitialized()
{
}
void LandscapeEditorPlugin::shutdown()
{
}
void LandscapeEditorPlugin::setNelContext(NLMISC::INelContext *nelContext)
{
#ifdef NL_OS_WINDOWS
// Ensure that a context doesn't exist yet.
// This only applies to platforms without PIC, e.g. Windows.
nlassert(!NLMISC::INelContext::isContextInitialised());
#endif // NL_OS_WINDOWS
m_libContext = new NLMISC::CLibraryContext(*nelContext);
}
void LandscapeEditorPlugin::addAutoReleasedObject(QObject *obj)
{
m_plugMan->addObject(obj);
m_autoReleaseObjects.prepend(obj);
}
LandscapeEditorContext::LandscapeEditorContext(QObject *parent)
: IContext(parent),
m_landEditorWindow(0)
{
m_landEditorWindow = new LandscapeEditorWindow();
}
QUndoStack *LandscapeEditorContext::undoStack()
{
return m_landEditorWindow->undoStack();
}
void LandscapeEditorContext::open()
{
m_landEditorWindow->open();
}
QWidget *LandscapeEditorContext::widget()
{
return m_landEditorWindow;
}
}
Q_EXPORT_PLUGIN(LandscapeEditor::LandscapeEditorPlugin)
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_editor_plugin.h"
#include "landscape_editor_window.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include "nel/misc/debug.h"
// Qt includes
#include <QtCore/QObject>
namespace LandscapeEditor
{
LandscapeEditorPlugin::~LandscapeEditorPlugin()
{
Q_FOREACH(QObject *obj, m_autoReleaseObjects)
{
m_plugMan->removeObject(obj);
}
qDeleteAll(m_autoReleaseObjects);
m_autoReleaseObjects.clear();
}
bool LandscapeEditorPlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString)
{
Q_UNUSED(errorString);
m_plugMan = pluginManager;
addAutoReleasedObject(new LandscapeEditorContext(this));
return true;
}
void LandscapeEditorPlugin::extensionsInitialized()
{
}
void LandscapeEditorPlugin::shutdown()
{
}
void LandscapeEditorPlugin::setNelContext(NLMISC::INelContext *nelContext)
{
#ifdef NL_OS_WINDOWS
// Ensure that a context doesn't exist yet.
// This only applies to platforms without PIC, e.g. Windows.
nlassert(!NLMISC::INelContext::isContextInitialised());
#endif // NL_OS_WINDOWS
m_libContext = new NLMISC::CLibraryContext(*nelContext);
}
void LandscapeEditorPlugin::addAutoReleasedObject(QObject *obj)
{
m_plugMan->addObject(obj);
m_autoReleaseObjects.prepend(obj);
}
LandscapeEditorContext::LandscapeEditorContext(QObject *parent)
: IContext(parent),
m_landEditorWindow(0)
{
m_landEditorWindow = new LandscapeEditorWindow();
}
QUndoStack *LandscapeEditorContext::undoStack()
{
return m_landEditorWindow->undoStack();
}
void LandscapeEditorContext::open()
{
m_landEditorWindow->open();
}
QWidget *LandscapeEditorContext::widget()
{
return m_landEditorWindow;
}
}
Q_EXPORT_PLUGIN(LandscapeEditor::LandscapeEditorPlugin)

828
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_editor_window.cpp
View file

@ -1,414 +1,414 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_editor_window.h"
#include "landscape_editor_constants.h"
#include "builder_zone.h"
#include "zone_region_editor.h"
#include "landscape_scene.h"
#include "project_settings_dialog.h"
#include "snapshot_dialog.h"
#include "../core/icore.h"
#include "../core/menu_manager.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QMenu>
#include <QtGui/QFileDialog>
#include <QtGui/QMessageBox>
#include <QtGui/QStatusBar>
namespace LandscapeEditor
{
static const int LANDSCAPE_ID = 32;
int NewLandCounter = 0;
QString _lastDir;
LandscapeEditorWindow::LandscapeEditorWindow(QWidget *parent)
: QMainWindow(parent),
m_currentItem(0),
m_landscapeScene(0),
m_zoneBuilder(0),
m_undoStack(0),
m_oglWidget(0)
{
m_ui.setupUi(this);
m_undoStack = new QUndoStack(this);
m_landscapeScene = new LandscapeScene(160, this);
m_zoneBuilder = new ZoneBuilder(m_landscapeScene, m_ui.zoneListWidget, m_undoStack);
m_ui.zoneListWidget->setZoneBuilder(m_zoneBuilder);
m_ui.zoneListWidget->updateUi();
m_landscapeScene->setZoneBuilder(m_zoneBuilder);
m_ui.graphicsView->setScene(m_landscapeScene);
m_ui.newLandAction->setIcon(QIcon(Core::Constants::ICON_NEW));
m_ui.saveAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_ui.saveLandAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_ui.saveAsLandAction->setIcon(QIcon(Core::Constants::ICON_SAVE_AS));
m_ui.zonesDockWidget->toggleViewAction()->setIcon(QIcon(Constants::ICON_LANDSCAPE_ZONES));
m_ui.landscapesDockWidget->toggleViewAction()->setIcon(QIcon(Constants::ICON_ZONE_ITEM));
m_ui.deleteLandAction->setEnabled(false);
createMenus();
createToolBars();
readSettings();
connect(m_ui.saveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(m_ui.projectSettingsAction, SIGNAL(triggered()), this, SLOT(openProjectSettings()));
connect(m_ui.snapshotAction, SIGNAL(triggered()), this, SLOT(openSnapshotDialog()));
connect(m_ui.enableGridAction, SIGNAL(toggled(bool)), m_ui.graphicsView, SLOT(setVisibleGrid(bool)));
connect(m_ui.newLandAction, SIGNAL(triggered()), this, SLOT(newLand()));
connect(m_ui.setActiveLandAction, SIGNAL(triggered()), this, SLOT(setActiveLand()));
connect(m_ui.saveLandAction, SIGNAL(triggered()), this, SLOT(saveSelectedLand()));
connect(m_ui.saveAsLandAction, SIGNAL(triggered()), this, SLOT(saveAsSelectedLand()));
connect(m_ui.deleteLandAction, SIGNAL(triggered()), this, SLOT(deleteSelectedLand()));
connect(m_ui.transitionModeAction, SIGNAL(toggled(bool)), m_landscapeScene, SLOT(setTransitionMode(bool)));
connect(m_ui.landscapesListWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(customContextMenu()));
m_ui.landscapesListWidget->setContextMenuPolicy(Qt::CustomContextMenu);
m_statusBarTimer = new QTimer(this);
connect(m_statusBarTimer, SIGNAL(timeout()), this, SLOT(updateStatusBar()));
m_statusInfo = new QLabel(this);
m_statusInfo->hide();
Core::ICore::instance()->mainWindow()->statusBar()->addPermanentWidget(m_statusInfo);
}
LandscapeEditorWindow::~LandscapeEditorWindow()
{
writeSettings();
delete m_zoneBuilder;
}
QUndoStack *LandscapeEditorWindow::undoStack() const
{
return m_undoStack;
}
void LandscapeEditorWindow::open()
{
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo land file"), _lastDir,
tr("All NeL Ligo land files (*.land)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
QStringList list = fileNames;
_lastDir = QFileInfo(list.front()).absolutePath();
Q_FOREACH(QString fileName, fileNames)
{
int row = createLandscape(fileName);
if (row != -1)
setActiveLandscape(row);
}
}
setCursor(Qt::ArrowCursor);
}
void LandscapeEditorWindow::save()
{
saveLandscape(m_ui.landscapesListWidget->row(m_currentItem), true);
}
void LandscapeEditorWindow::openProjectSettings()
{
ProjectSettingsDialog *dialog = new ProjectSettingsDialog(m_zoneBuilder->dataPath(), this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
m_zoneBuilder->init(dialog->dataPath(), true);
m_ui.zoneListWidget->updateUi();
}
delete dialog;
}
void LandscapeEditorWindow::openSnapshotDialog()
{
SnapshotDialog *dialog = new SnapshotDialog(this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save screenshot landscape"), _lastDir,
tr("Image file (*.png)"));
setCursor(Qt::WaitCursor);
NLLIGO::CZoneRegion &zoneRegion = m_zoneBuilder->currentZoneRegion()->ligoZoneRegion();
sint32 regionMinX = zoneRegion.getMinX();
sint32 regionMaxX = zoneRegion.getMaxX();
sint32 regionMinY = zoneRegion.getMinY();
sint32 regionMaxY = zoneRegion.getMaxY();
int regionWidth = (regionMaxX - regionMinX + 1);
int regionHeight = (regionMaxY - regionMinY + 1);
int cellSize = m_landscapeScene->cellSize();
QRectF rect(regionMinX * cellSize, abs(regionMaxY) * cellSize, regionWidth * cellSize, regionHeight * cellSize);
if (dialog->isCustomSize())
{
int widthSnapshot = dialog->widthSnapshot();
int heightSnapshot = dialog->heightSnapshot();
if (dialog->isKeepRatio())
heightSnapshot = (widthSnapshot / regionWidth) * regionHeight;
m_landscapeScene->snapshot(fileName, widthSnapshot, heightSnapshot, rect);
}
else
{
m_landscapeScene->snapshot(fileName, regionWidth * dialog->resolutionZone(),
regionHeight * dialog->resolutionZone(), rect);
}
setCursor(Qt::ArrowCursor);
}
delete dialog;
}
void LandscapeEditorWindow::customContextMenu()
{
if (m_ui.landscapesListWidget->currentRow() == -1)
return;
QMenu *popurMenu = new QMenu(this);
popurMenu->addAction(m_ui.setActiveLandAction);
popurMenu->addAction(m_ui.saveLandAction);
popurMenu->addAction(m_ui.saveAsLandAction);
popurMenu->addAction(m_ui.deleteLandAction);
popurMenu->exec(QCursor::pos());
delete popurMenu;
}
void LandscapeEditorWindow::newLand()
{
int row = createLandscape(QString());
if (row != -1)
setActiveLandscape(row);
}
void LandscapeEditorWindow::setActiveLand()
{
setActiveLandscape(m_ui.landscapesListWidget->currentRow());
}
void LandscapeEditorWindow::saveSelectedLand()
{
saveLandscape(m_ui.landscapesListWidget->currentRow(), true);
}
void LandscapeEditorWindow::saveAsSelectedLand()
{
saveLandscape(m_ui.landscapesListWidget->currentRow(), false);
}
void LandscapeEditorWindow::deleteSelectedLand()
{
int row = m_ui.landscapesListWidget->currentRow();
int current_row = m_ui.landscapesListWidget->row(m_currentItem);
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
if (row == current_row)
{
if (row == 0)
++row;
else
--row;
setActiveLandscape(row);
}
m_zoneBuilder->deleteZoneRegion(item->data(LANDSCAPE_ID).toInt());
m_ui.landscapesListWidget->removeItemWidget(item);
delete item;
if (m_ui.landscapesListWidget->count() == 1)
m_ui.deleteLandAction->setEnabled(false);
m_undoStack->clear();
}
int LandscapeEditorWindow::createLandscape(const QString &fileName)
{
int id;
if (fileName.isEmpty())
id = m_zoneBuilder->createZoneRegion();
else
id = m_zoneBuilder->createZoneRegion(fileName);
if (id == -1)
{
QMessageBox::critical(this, "Landscape Editor", tr("Cannot add this zone because it overlaps existing ones"));
return -1;
}
ZoneRegionObject *zoneRegion = m_zoneBuilder->zoneRegion(id);
m_ui.graphicsView->setCenter(QPointF(zoneRegion->ligoZoneRegion().getMinX() * m_landscapeScene->cellSize(),
abs(zoneRegion->ligoZoneRegion().getMinY()) * m_landscapeScene->cellSize()));
QListWidgetItem *item;
if (fileName.isEmpty())
item = new QListWidgetItem(QString("NewLandscape%1").arg(NewLandCounter++), m_ui.landscapesListWidget);
else
item = new QListWidgetItem(fileName, m_ui.landscapesListWidget);
item->setData(LANDSCAPE_ID, id);
item->setFont(QFont("SansSerif", 9, QFont::Normal));
if (m_ui.landscapesListWidget->count() > 1)
m_ui.deleteLandAction->setEnabled(true);
return m_ui.landscapesListWidget->count() - 1;
}
void LandscapeEditorWindow::setActiveLandscape(int row)
{
if ((0 <= row) && (row < m_ui.landscapesListWidget->count()))
{
if (m_currentItem != 0)
m_currentItem->setFont(QFont("SansSerif", 9, QFont::Normal));
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
item->setFont(QFont("SansSerif", 9, QFont::Bold));
m_zoneBuilder->setCurrentZoneRegion(item->data(LANDSCAPE_ID).toInt());
m_currentItem = item;
}
}
void LandscapeEditorWindow::saveLandscape(int row, bool force)
{
if ((0 <= row) && (row < m_ui.landscapesListWidget->count()))
{
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
ZoneRegionObject *regionObject = m_zoneBuilder->zoneRegion(item->data(LANDSCAPE_ID).toInt());
if ((!force) || (regionObject->fileName().empty()))
{
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save NeL Ligo land file"), _lastDir,
tr("NeL Ligo land file (*.land)"));
if (!fileName.isEmpty())
{
regionObject->setFileName(fileName.toStdString());
regionObject->save();
regionObject->setModified(false);
item->setText(fileName);
}
}
else
{
regionObject->save();
regionObject->setModified(false);
}
}
}
void LandscapeEditorWindow::showEvent(QShowEvent *showEvent)
{
QMainWindow::showEvent(showEvent);
if (m_oglWidget != 0)
m_oglWidget->makeCurrent();
m_statusInfo->show();
m_statusBarTimer->start(100);
}
void LandscapeEditorWindow::hideEvent(QHideEvent *hideEvent)
{
QMainWindow::hideEvent(hideEvent);
m_statusInfo->hide();
m_statusBarTimer->stop();
}
void LandscapeEditorWindow::updateStatusBar()
{
m_statusInfo->setText(m_landscapeScene->zoneNameFromMousePos());
}
void LandscapeEditorWindow::createMenus()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
}
void LandscapeEditorWindow::createToolBars()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
//QAction *action = menuManager->action(Core::Constants::NEW);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE_AS);
//m_ui.fileToolBar->addAction(action);
QAction *action = menuManager->action(Core::Constants::OPEN);
m_ui.fileToolBar->addAction(m_ui.newLandAction);
m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.saveAction);
m_ui.fileToolBar->addSeparator();
action = menuManager->action(Core::Constants::UNDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
action = menuManager->action(Core::Constants::REDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
m_ui.zoneToolBar->insertAction(m_ui.enableGridAction, m_ui.landscapesDockWidget->toggleViewAction());
m_ui.zoneToolBar->insertAction(m_ui.enableGridAction, m_ui.zonesDockWidget->toggleViewAction());
}
void LandscapeEditorWindow::readSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::LANDSCAPE_EDITOR_SECTION);
restoreState(settings->value(Constants::LANDSCAPE_WINDOW_STATE).toByteArray());
restoreGeometry(settings->value(Constants::LANDSCAPE_WINDOW_GEOMETRY).toByteArray());
// Read landscape data directory (contains sub-paths: zone logos, zone bitmaps)
m_zoneBuilder->init(settings->value(Constants::LANDSCAPE_DATA_DIRECTORY).toString());
m_ui.zoneListWidget->updateUi();
// Use OpenGL graphics system instead raster graphics system
if (settings->value(Constants::LANDSCAPE_USE_OPENGL, false).toBool())
{
m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer));
m_ui.graphicsView->setViewport(m_oglWidget);
}
settings->endGroup();
}
void LandscapeEditorWindow::writeSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::LANDSCAPE_EDITOR_SECTION);
settings->setValue(Constants::LANDSCAPE_WINDOW_STATE, saveState());
settings->setValue(Constants::LANDSCAPE_WINDOW_GEOMETRY, saveGeometry());
settings->setValue(Constants::LANDSCAPE_DATA_DIRECTORY, m_zoneBuilder->dataPath());
settings->endGroup();
settings->sync();
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_editor_window.h"
#include "landscape_editor_constants.h"
#include "builder_zone.h"
#include "zone_region_editor.h"
#include "landscape_scene.h"
#include "project_settings_dialog.h"
#include "snapshot_dialog.h"
#include "../core/icore.h"
#include "../core/menu_manager.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QMenu>
#include <QtGui/QFileDialog>
#include <QtGui/QMessageBox>
#include <QtGui/QStatusBar>
namespace LandscapeEditor
{
static const int LANDSCAPE_ID = 32;
int NewLandCounter = 0;
QString _lastDir;
LandscapeEditorWindow::LandscapeEditorWindow(QWidget *parent)
: QMainWindow(parent),
m_currentItem(0),
m_landscapeScene(0),
m_zoneBuilder(0),
m_undoStack(0),
m_oglWidget(0)
{
m_ui.setupUi(this);
m_undoStack = new QUndoStack(this);
m_landscapeScene = new LandscapeScene(160, this);
m_zoneBuilder = new ZoneBuilder(m_landscapeScene, m_ui.zoneListWidget, m_undoStack);
m_ui.zoneListWidget->setZoneBuilder(m_zoneBuilder);
m_ui.zoneListWidget->updateUi();
m_landscapeScene->setZoneBuilder(m_zoneBuilder);
m_ui.graphicsView->setScene(m_landscapeScene);
m_ui.newLandAction->setIcon(QIcon(Core::Constants::ICON_NEW));
m_ui.saveAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_ui.saveLandAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_ui.saveAsLandAction->setIcon(QIcon(Core::Constants::ICON_SAVE_AS));
m_ui.zonesDockWidget->toggleViewAction()->setIcon(QIcon(Constants::ICON_LANDSCAPE_ZONES));
m_ui.landscapesDockWidget->toggleViewAction()->setIcon(QIcon(Constants::ICON_ZONE_ITEM));
m_ui.deleteLandAction->setEnabled(false);
createMenus();
createToolBars();
readSettings();
connect(m_ui.saveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(m_ui.projectSettingsAction, SIGNAL(triggered()), this, SLOT(openProjectSettings()));
connect(m_ui.snapshotAction, SIGNAL(triggered()), this, SLOT(openSnapshotDialog()));
connect(m_ui.enableGridAction, SIGNAL(toggled(bool)), m_ui.graphicsView, SLOT(setVisibleGrid(bool)));
connect(m_ui.newLandAction, SIGNAL(triggered()), this, SLOT(newLand()));
connect(m_ui.setActiveLandAction, SIGNAL(triggered()), this, SLOT(setActiveLand()));
connect(m_ui.saveLandAction, SIGNAL(triggered()), this, SLOT(saveSelectedLand()));
connect(m_ui.saveAsLandAction, SIGNAL(triggered()), this, SLOT(saveAsSelectedLand()));
connect(m_ui.deleteLandAction, SIGNAL(triggered()), this, SLOT(deleteSelectedLand()));
connect(m_ui.transitionModeAction, SIGNAL(toggled(bool)), m_landscapeScene, SLOT(setTransitionMode(bool)));
connect(m_ui.landscapesListWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(customContextMenu()));
m_ui.landscapesListWidget->setContextMenuPolicy(Qt::CustomContextMenu);
m_statusBarTimer = new QTimer(this);
connect(m_statusBarTimer, SIGNAL(timeout()), this, SLOT(updateStatusBar()));
m_statusInfo = new QLabel(this);
m_statusInfo->hide();
Core::ICore::instance()->mainWindow()->statusBar()->addPermanentWidget(m_statusInfo);
}
LandscapeEditorWindow::~LandscapeEditorWindow()
{
writeSettings();
delete m_zoneBuilder;
}
QUndoStack *LandscapeEditorWindow::undoStack() const
{
return m_undoStack;
}
void LandscapeEditorWindow::open()
{
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo land file"), _lastDir,
tr("All NeL Ligo land files (*.land)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
QStringList list = fileNames;
_lastDir = QFileInfo(list.front()).absolutePath();
Q_FOREACH(QString fileName, fileNames)
{
int row = createLandscape(fileName);
if (row != -1)
setActiveLandscape(row);
}
}
setCursor(Qt::ArrowCursor);
}
void LandscapeEditorWindow::save()
{
saveLandscape(m_ui.landscapesListWidget->row(m_currentItem), true);
}
void LandscapeEditorWindow::openProjectSettings()
{
ProjectSettingsDialog *dialog = new ProjectSettingsDialog(m_zoneBuilder->dataPath(), this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
m_zoneBuilder->init(dialog->dataPath(), true);
m_ui.zoneListWidget->updateUi();
}
delete dialog;
}
void LandscapeEditorWindow::openSnapshotDialog()
{
SnapshotDialog *dialog = new SnapshotDialog(this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save screenshot landscape"), _lastDir,
tr("Image file (*.png)"));
setCursor(Qt::WaitCursor);
NLLIGO::CZoneRegion &zoneRegion = m_zoneBuilder->currentZoneRegion()->ligoZoneRegion();
sint32 regionMinX = zoneRegion.getMinX();
sint32 regionMaxX = zoneRegion.getMaxX();
sint32 regionMinY = zoneRegion.getMinY();
sint32 regionMaxY = zoneRegion.getMaxY();
int regionWidth = (regionMaxX - regionMinX + 1);
int regionHeight = (regionMaxY - regionMinY + 1);
int cellSize = m_landscapeScene->cellSize();
QRectF rect(regionMinX * cellSize, abs(regionMaxY) * cellSize, regionWidth * cellSize, regionHeight * cellSize);
if (dialog->isCustomSize())
{
int widthSnapshot = dialog->widthSnapshot();
int heightSnapshot = dialog->heightSnapshot();
if (dialog->isKeepRatio())
heightSnapshot = (widthSnapshot / regionWidth) * regionHeight;
m_landscapeScene->snapshot(fileName, widthSnapshot, heightSnapshot, rect);
}
else
{
m_landscapeScene->snapshot(fileName, regionWidth * dialog->resolutionZone(),
regionHeight * dialog->resolutionZone(), rect);
}
setCursor(Qt::ArrowCursor);
}
delete dialog;
}
void LandscapeEditorWindow::customContextMenu()
{
if (m_ui.landscapesListWidget->currentRow() == -1)
return;
QMenu *popurMenu = new QMenu(this);
popurMenu->addAction(m_ui.setActiveLandAction);
popurMenu->addAction(m_ui.saveLandAction);
popurMenu->addAction(m_ui.saveAsLandAction);
popurMenu->addAction(m_ui.deleteLandAction);
popurMenu->exec(QCursor::pos());
delete popurMenu;
}
void LandscapeEditorWindow::newLand()
{
int row = createLandscape(QString());
if (row != -1)
setActiveLandscape(row);
}
void LandscapeEditorWindow::setActiveLand()
{
setActiveLandscape(m_ui.landscapesListWidget->currentRow());
}
void LandscapeEditorWindow::saveSelectedLand()
{
saveLandscape(m_ui.landscapesListWidget->currentRow(), true);
}
void LandscapeEditorWindow::saveAsSelectedLand()
{
saveLandscape(m_ui.landscapesListWidget->currentRow(), false);
}
void LandscapeEditorWindow::deleteSelectedLand()
{
int row = m_ui.landscapesListWidget->currentRow();
int current_row = m_ui.landscapesListWidget->row(m_currentItem);
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
if (row == current_row)
{
if (row == 0)
++row;
else
--row;
setActiveLandscape(row);
}
m_zoneBuilder->deleteZoneRegion(item->data(LANDSCAPE_ID).toInt());
m_ui.landscapesListWidget->removeItemWidget(item);
delete item;
if (m_ui.landscapesListWidget->count() == 1)
m_ui.deleteLandAction->setEnabled(false);
m_undoStack->clear();
}
int LandscapeEditorWindow::createLandscape(const QString &fileName)
{
int id;
if (fileName.isEmpty())
id = m_zoneBuilder->createZoneRegion();
else
id = m_zoneBuilder->createZoneRegion(fileName);
if (id == -1)
{
QMessageBox::critical(this, "Landscape Editor", tr("Cannot add this zone because it overlaps existing ones"));
return -1;
}
ZoneRegionObject *zoneRegion = m_zoneBuilder->zoneRegion(id);
m_ui.graphicsView->setCenter(QPointF(zoneRegion->ligoZoneRegion().getMinX() * m_landscapeScene->cellSize(),
abs(zoneRegion->ligoZoneRegion().getMinY()) * m_landscapeScene->cellSize()));
QListWidgetItem *item;
if (fileName.isEmpty())
item = new QListWidgetItem(QString("NewLandscape%1").arg(NewLandCounter++), m_ui.landscapesListWidget);
else
item = new QListWidgetItem(fileName, m_ui.landscapesListWidget);
item->setData(LANDSCAPE_ID, id);
item->setFont(QFont("SansSerif", 9, QFont::Normal));
if (m_ui.landscapesListWidget->count() > 1)
m_ui.deleteLandAction->setEnabled(true);
return m_ui.landscapesListWidget->count() - 1;
}
void LandscapeEditorWindow::setActiveLandscape(int row)
{
if ((0 <= row) && (row < m_ui.landscapesListWidget->count()))
{
if (m_currentItem != 0)
m_currentItem->setFont(QFont("SansSerif", 9, QFont::Normal));
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
item->setFont(QFont("SansSerif", 9, QFont::Bold));
m_zoneBuilder->setCurrentZoneRegion(item->data(LANDSCAPE_ID).toInt());
m_currentItem = item;
}
}
void LandscapeEditorWindow::saveLandscape(int row, bool force)
{
if ((0 <= row) && (row < m_ui.landscapesListWidget->count()))
{
QListWidgetItem *item = m_ui.landscapesListWidget->item(row);
ZoneRegionObject *regionObject = m_zoneBuilder->zoneRegion(item->data(LANDSCAPE_ID).toInt());
if ((!force) || (regionObject->fileName().empty()))
{
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save NeL Ligo land file"), _lastDir,
tr("NeL Ligo land file (*.land)"));
if (!fileName.isEmpty())
{
regionObject->setFileName(fileName.toStdString());
regionObject->save();
regionObject->setModified(false);
item->setText(fileName);
}
}
else
{
regionObject->save();
regionObject->setModified(false);
}
}
}
void LandscapeEditorWindow::showEvent(QShowEvent *showEvent)
{
QMainWindow::showEvent(showEvent);
if (m_oglWidget != 0)
m_oglWidget->makeCurrent();
m_statusInfo->show();
m_statusBarTimer->start(100);
}
void LandscapeEditorWindow::hideEvent(QHideEvent *hideEvent)
{
QMainWindow::hideEvent(hideEvent);
m_statusInfo->hide();
m_statusBarTimer->stop();
}
void LandscapeEditorWindow::updateStatusBar()
{
m_statusInfo->setText(m_landscapeScene->zoneNameFromMousePos());
}
void LandscapeEditorWindow::createMenus()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
}
void LandscapeEditorWindow::createToolBars()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
//QAction *action = menuManager->action(Core::Constants::NEW);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE_AS);
//m_ui.fileToolBar->addAction(action);
QAction *action = menuManager->action(Core::Constants::OPEN);
m_ui.fileToolBar->addAction(m_ui.newLandAction);
m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.saveAction);
m_ui.fileToolBar->addSeparator();
action = menuManager->action(Core::Constants::UNDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
action = menuManager->action(Core::Constants::REDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
m_ui.zoneToolBar->insertAction(m_ui.enableGridAction, m_ui.landscapesDockWidget->toggleViewAction());
m_ui.zoneToolBar->insertAction(m_ui.enableGridAction, m_ui.zonesDockWidget->toggleViewAction());
}
void LandscapeEditorWindow::readSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::LANDSCAPE_EDITOR_SECTION);
restoreState(settings->value(Constants::LANDSCAPE_WINDOW_STATE).toByteArray());
restoreGeometry(settings->value(Constants::LANDSCAPE_WINDOW_GEOMETRY).toByteArray());
// Read landscape data directory (contains sub-paths: zone logos, zone bitmaps)
m_zoneBuilder->init(settings->value(Constants::LANDSCAPE_DATA_DIRECTORY).toString());
m_ui.zoneListWidget->updateUi();
// Use OpenGL graphics system instead raster graphics system
if (settings->value(Constants::LANDSCAPE_USE_OPENGL, false).toBool())
{
m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer));
m_ui.graphicsView->setViewport(m_oglWidget);
}
settings->endGroup();
}
void LandscapeEditorWindow::writeSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::LANDSCAPE_EDITOR_SECTION);
settings->setValue(Constants::LANDSCAPE_WINDOW_STATE, saveState());
settings->setValue(Constants::LANDSCAPE_WINDOW_GEOMETRY, saveGeometry());
settings->setValue(Constants::LANDSCAPE_DATA_DIRECTORY, m_zoneBuilder->dataPath());
settings->endGroup();
settings->sync();
}
} /* namespace LandscapeEditor */

996
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_scene.cpp
View file

@ -1,498 +1,498 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_scene.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtGui/QPainter>
#include <QtGui/QGraphicsPixmapItem>
#include <QtGui/QGraphicsSimpleTextItem>
#include <QApplication>
namespace LandscapeEditor
{
static const int ZONE_NAME = 0;
static const int LAYER_ZONES = 2;
static const int LAYER_EMPTY_ZONES = 3;
static const int LAYER_BLACKOUT = 4;
const char *const LAYER_BLACKOUT_NAME = "blackout";
const int MAX_SCENE_WIDTH = 256;
const int MAX_SCENE_HEIGHT = 256;
LandscapeScene::LandscapeScene(int sizeCell, QObject *parent)
: QGraphicsScene(parent),
m_cellSize(sizeCell),
m_transitionMode(false),
m_mouseButton(Qt::NoButton),
m_zoneBuilder(0)
{
setSceneRect(QRectF(0, m_cellSize, MAX_SCENE_WIDTH * m_cellSize, MAX_SCENE_HEIGHT * m_cellSize));
}
LandscapeScene::~LandscapeScene()
{
}
int LandscapeScene::cellSize() const
{
return m_cellSize;
}
void LandscapeScene::setZoneBuilder(ZoneBuilder *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
QGraphicsItem *LandscapeScene::createItemZone(const LigoData &data, const ZonePosition &zonePos)
{
if ((data.zoneName == STRING_OUT_OF_BOUND) || (checkUnderZone(zonePos.x, zonePos.y)))
return 0;
if (data.zoneName == STRING_UNUSED)
return createItemEmptyZone(zonePos);
if ((m_zoneBuilder == 0) || (data.zoneName.empty()))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilder->pixmapDatabase()->pixmap(QString(data.zoneName.c_str()));
if (pixmap == 0)
return 0;
// Rotate the image counterclockwise
QMatrix matrix;
matrix.rotate(-data.rot * 90.0);
QGraphicsPixmapItem *item;
if (data.flip == 0)
{
item = addPixmap(pixmap->transformed(matrix, Qt::SmoothTransformation));
}
else
{
// mirror image
QImage mirrorImage = pixmap->toImage();
QPixmap mirrorPixmap = QPixmap::fromImage(mirrorImage.mirrored(true, false));
item = addPixmap(mirrorPixmap.transformed(matrix, Qt::SmoothTransformation));
}
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
sint32 sizeX = 1, sizeY = 1;
sizeX = float(pixmap->width()) / m_zoneBuilder->pixmapDatabase()->textureSize();
sizeY = float(pixmap->width()) / m_zoneBuilder->pixmapDatabase()->textureSize();
sint32 deltaX = 0, deltaY = 0;
// Calculate offset for graphics item (for items with size that are larger than 1)
if ((sizeX > 1) || (sizeY > 1))
{
if (data.flip == 0)
{
switch (data.rot)
{
case 0:
deltaX = -data.posX;
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = -data.posX + sizeX - 1;
break;
case 2:
deltaX = -(sizeX - 1 - data.posX);
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = data.posX;
break;
}
}
else
{
switch (data.rot)
{
case 0:
deltaX = -(sizeX - 1 - data.posX);
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = +data.posX;
break;
case 2:
deltaX = -data.posX;
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = -data.posX + sizeX - 1;
break;
}
}
}
// Set position graphics item with offset for large piece
item->setPos((zonePos.x + deltaX) * m_cellSize, (abs(int(zonePos.y + deltaY))) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilder->pixmapDatabase()->textureSize());
item->setData(ZONE_NAME, QString(data.zoneName.c_str()));
// for not full item zone
item->setZValue(LAYER_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsItem *LandscapeScene::createItemEmptyZone(const ZonePosition &zonePos)
{
if (m_zoneBuilder == 0)
return 0;
if (checkUnderZone(zonePos.x, zonePos.y))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilder->pixmapDatabase()->pixmap(QString(STRING_UNUSED));
if (pixmap == 0)
return 0;
QGraphicsPixmapItem *item = addPixmap(*pixmap);
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
// Set position graphics item
item->setPos(zonePos.x * m_cellSize, abs(int(zonePos.y)) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilder->pixmapDatabase()->textureSize());
// for not full item zone
item->setZValue(LAYER_EMPTY_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsRectItem *LandscapeScene::createLayerBlackout(const NLLIGO::CZoneRegion &zoneRegion)
{
QGraphicsRectItem *rectItem = addRect(zoneRegion.getMinX() * m_cellSize,
abs(zoneRegion.getMaxY()) * m_cellSize,
(abs(zoneRegion.getMaxX() - zoneRegion.getMinX()) + 1) * m_cellSize,
(abs(zoneRegion.getMaxY() - zoneRegion.getMinY()) + 1) * m_cellSize,
Qt::NoPen, QBrush(QColor(0, 0, 0, 50)));
rectItem->setZValue(LAYER_BLACKOUT);
rectItem->setData(ZONE_NAME, QString(LAYER_BLACKOUT_NAME));
return rectItem;
}
void LandscapeScene::deleteItemZone(const ZonePosition &zonePos)
{
QGraphicsItem *item = itemAt(zonePos.x * m_cellSize, abs(zonePos.y) * m_cellSize);
if ((item != 0) && (item->data(ZONE_NAME).toString() != QString(LAYER_BLACKOUT_NAME)))
{
removeItem(item);
delete item;
}
}
void LandscapeScene::addZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
std::string zoneName = zoneRegion.getName(i, j);
if (zoneName == STRING_UNUSED)
{
ZonePosition zonePos(i, j, -1);
QGraphicsItem *item = createItemEmptyZone(zonePos);
}
else if (!zoneName.empty())
{
LigoData data;
ZonePosition zonePos(i, j, -1);
data.zoneName = zoneName;
data.rot = zoneRegion.getRot(i, j);
data.flip = zoneRegion.getFlip(i, j);
data.posX = zoneRegion.getPosX(i, j);
data.posY = zoneRegion.getPosY(i, j);
QGraphicsItem *item = createItemZone(data, zonePos);
}
}
}
}
void LandscapeScene::delZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
deleteItemZone(ZonePosition(i, -j, -1));
}
}
}
void LandscapeScene::snapshot(const QString &fileName, int width, int height, const QRectF &landRect)
{
if (m_zoneBuilder == 0)
return;
// Create image
QImage image(landRect.width(), landRect.height(), QImage::Format_RGB888);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, true);
// Add white background
painter.setBrush(QBrush(Qt::white));
painter.setPen(Qt::NoPen);
painter.drawRect(0, 0, landRect.width(), landRect.height());
// Paint landscape
render(&painter, QRectF(0, 0, landRect.width(), landRect.height()), landRect);
QImage scaledImage = image.scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
scaledImage.save(fileName);
}
QString LandscapeScene::zoneNameFromMousePos() const
{
if ((m_posY > 0) || (m_posY < -MAX_SCENE_HEIGHT) ||
(m_posX < 0) || (m_posX > MAX_SCENE_WIDTH))
return "NOT A VALID ZONE";
return QString("%1_%2%3 %4 %5 ").arg(-m_posY).arg(QChar('A' + (m_posX/26))).
arg(QChar('A' + (m_posX%26))).arg(m_mouseX, 0,'f',2).arg(-m_mouseY, 0,'f',2);
}
void LandscapeScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
if ((x < 0) || (y < 0))
return;
m_posX = sint32(floor(x / m_cellSize));
m_posY = sint32(-floor(y / m_cellSize));
if (m_zoneBuilder == 0)
return;
if (m_transitionMode)
{
if (mouseEvent->button() == Qt::LeftButton)
// Need add offset(= cellSize) on y axes
m_zoneBuilder->addTransition(sint(x), sint(-y + m_cellSize));
}
else
{
if (mouseEvent->button() == Qt::LeftButton)
m_zoneBuilder->addZone(m_posX, m_posY);
else if (mouseEvent->button() == Qt::RightButton)
m_zoneBuilder->delZone(m_posX, m_posY);
}
m_mouseButton = mouseEvent->button();
QGraphicsScene::mousePressEvent(mouseEvent);
}
void LandscapeScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
sint32 posX = sint32(floor(x / m_cellSize));
sint32 posY = sint32(-floor(y / m_cellSize));
if ((m_posX != posX || m_posY != posY) &&
(m_mouseButton == Qt::LeftButton ||
m_mouseButton == Qt::RightButton))
{
if (m_transitionMode)
{
}
else
{
if (m_mouseButton == Qt::LeftButton)
m_zoneBuilder->addZone(posX, posY);
else if (m_mouseButton == Qt::RightButton)
m_zoneBuilder->delZone(posX, posY);
}
m_posX = posX;
m_posY = posY;
QApplication::processEvents();
}
m_posX = posX;
m_posY = posY;
m_mouseX = mouseEvent->scenePos().x();
m_mouseY = mouseEvent->scenePos().y() - m_cellSize;
QGraphicsScene::mouseMoveEvent(mouseEvent);
}
void LandscapeScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
m_mouseButton = Qt::NoButton;
}
bool LandscapeScene::checkUnderZone(const int posX, const int posY)
{
QGraphicsItem *item = itemAt((posX * m_cellSize), abs(posY) * m_cellSize);
if (item != 0)
{
//if (item->data(ZONE_NAME) == QString(LAYER_BLACKOUT_NAME))
// return false;
//else
return true;
}
return false;
}
bool LandscapeScene::transitionMode() const
{
return m_transitionMode;
}
void LandscapeScene::setTransitionMode(bool enabled)
{
m_transitionMode = enabled;
update();
}
void LandscapeScene::drawForeground(QPainter *painter, const QRectF &rect)
{
QGraphicsScene::drawForeground(painter, rect);
if ((m_zoneBuilder->currentIdZoneRegion() != -1) && (m_transitionMode))
drawTransition(painter, rect);
}
void LandscapeScene::drawTransition(QPainter *painter, const QRectF &rect)
{
int left = int(floor(rect.left() / m_cellSize));
int right = int(floor(rect.right() / m_cellSize));
int top = int(floor(rect.top() / m_cellSize));
int bottom = int(floor(rect.bottom() / m_cellSize));
QVector<QLine> redLines;
QVector<QLine> whiteLines;
for (int i = left; i < right + 1; ++i)
{
for (int j = top; j < bottom + 1; ++j)
{
// Get LIGO data
NLLIGO::CZoneRegion &zoneRegion = m_zoneBuilder->currentZoneRegion()->ligoZoneRegion();
uint8 ceUp = zoneRegion.getCutEdge (i, -j, 0);
uint8 ceLeft = zoneRegion.getCutEdge (i, -j, 2);
if ((ceUp > 0) && (ceUp < 3))
{
// Calculate position vertical lines
int x1, x2, y1, y2;
y1 = j * m_cellSize + m_cellSize / 12.0f;
y2 = y1 - (m_cellSize / 6.0f);
x1 = i * m_cellSize + 3.0f * m_cellSize / 12.0f;
x2 = i * m_cellSize + 5.0f * m_cellSize / 12.0f;
if (ceUp == 1)
{
whiteLines.push_back(QLine(x1, y1, x1, y2));
whiteLines.push_back(QLine(x2, y1, x2, y2));
}
else
{
redLines.push_back(QLine(x1, y1, x1, y2));
redLines.push_back(QLine(x2, y1, x2, y2));
}
x1 = i * m_cellSize + 7.0f * m_cellSize / 12.0f;
x2 = i * m_cellSize + 9.0f * m_cellSize / 12.0f;
if (ceUp == 1)
{
redLines.push_back(QLine(x1, y1, x1, y2));
redLines.push_back(QLine(x2, y1, x2, y2));
}
else
{
whiteLines.push_back(QLine(x1, y1, x1, y2));
whiteLines.push_back(QLine(x2, y1, x2, y2));
}
}
if ((ceLeft > 0) && (ceLeft < 3))
{
// Calculate position horizontal lines
int x1, x2, y1, y2;
x1 = i * m_cellSize - m_cellSize / 12.0f;
x2 = x1 + (m_cellSize / 6.0f);
y1 = j * m_cellSize + 3.0f * m_cellSize / 12.0f;
y2 = j * m_cellSize + 5.0f * m_cellSize / 12.0f;
if (ceLeft == 1)
{
redLines.push_back(QLine(x1, y1, x2, y1));
redLines.push_back(QLine(x1, y2, x2, y2));
}
else
{
whiteLines.push_back(QLine(x1, y1, x2, y1));
whiteLines.push_back(QLine(x1, y2, x2, y2));
}
y1 = j * m_cellSize + 7.0f * m_cellSize / 12.0f;
y2 = j * m_cellSize + 9.0f * m_cellSize / 12.0f;
if (ceLeft == 1)
{
whiteLines.push_back(QLine(x1, y1, x2, y1));
whiteLines.push_back(QLine(x1, y2, x2, y2));
}
else
{
redLines.push_back(QLine(x1, y1, x2, y1));
redLines.push_back(QLine(x1, y2, x2, y2));
}
}
}
}
// Draw lines
painter->setPen(QPen(Qt::red, 0, Qt::SolidLine));
painter->drawLines(redLines);
painter->setPen(QPen(Qt::white, 0, Qt::SolidLine));
painter->drawLines(whiteLines);
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_scene.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtGui/QPainter>
#include <QtGui/QGraphicsPixmapItem>
#include <QtGui/QGraphicsSimpleTextItem>
#include <QApplication>
namespace LandscapeEditor
{
static const int ZONE_NAME = 0;
static const int LAYER_ZONES = 2;
static const int LAYER_EMPTY_ZONES = 3;
static const int LAYER_BLACKOUT = 4;
const char *const LAYER_BLACKOUT_NAME = "blackout";
const int MAX_SCENE_WIDTH = 256;
const int MAX_SCENE_HEIGHT = 256;
LandscapeScene::LandscapeScene(int sizeCell, QObject *parent)
: QGraphicsScene(parent),
m_cellSize(sizeCell),
m_transitionMode(false),
m_mouseButton(Qt::NoButton),
m_zoneBuilder(0)
{
setSceneRect(QRectF(0, m_cellSize, MAX_SCENE_WIDTH * m_cellSize, MAX_SCENE_HEIGHT * m_cellSize));
}
LandscapeScene::~LandscapeScene()
{
}
int LandscapeScene::cellSize() const
{
return m_cellSize;
}
void LandscapeScene::setZoneBuilder(ZoneBuilder *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
QGraphicsItem *LandscapeScene::createItemZone(const LigoData &data, const ZonePosition &zonePos)
{
if ((data.zoneName == STRING_OUT_OF_BOUND) || (checkUnderZone(zonePos.x, zonePos.y)))
return 0;
if (data.zoneName == STRING_UNUSED)
return createItemEmptyZone(zonePos);
if ((m_zoneBuilder == 0) || (data.zoneName.empty()))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilder->pixmapDatabase()->pixmap(QString(data.zoneName.c_str()));
if (pixmap == 0)
return 0;
// Rotate the image counterclockwise
QMatrix matrix;
matrix.rotate(-data.rot * 90.0);
QGraphicsPixmapItem *item;
if (data.flip == 0)
{
item = addPixmap(pixmap->transformed(matrix, Qt::SmoothTransformation));
}
else
{
// mirror image
QImage mirrorImage = pixmap->toImage();
QPixmap mirrorPixmap = QPixmap::fromImage(mirrorImage.mirrored(true, false));
item = addPixmap(mirrorPixmap.transformed(matrix, Qt::SmoothTransformation));
}
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
sint32 sizeX = 1, sizeY = 1;
sizeX = float(pixmap->width()) / m_zoneBuilder->pixmapDatabase()->textureSize();
sizeY = float(pixmap->width()) / m_zoneBuilder->pixmapDatabase()->textureSize();
sint32 deltaX = 0, deltaY = 0;
// Calculate offset for graphics item (for items with size that are larger than 1)
if ((sizeX > 1) || (sizeY > 1))
{
if (data.flip == 0)
{
switch (data.rot)
{
case 0:
deltaX = -data.posX;
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = -data.posX + sizeX - 1;
break;
case 2:
deltaX = -(sizeX - 1 - data.posX);
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = data.posX;
break;
}
}
else
{
switch (data.rot)
{
case 0:
deltaX = -(sizeX - 1 - data.posX);
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = +data.posX;
break;
case 2:
deltaX = -data.posX;
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = -data.posX + sizeX - 1;
break;
}
}
}
// Set position graphics item with offset for large piece
item->setPos((zonePos.x + deltaX) * m_cellSize, (abs(int(zonePos.y + deltaY))) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilder->pixmapDatabase()->textureSize());
item->setData(ZONE_NAME, QString(data.zoneName.c_str()));
// for not full item zone
item->setZValue(LAYER_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsItem *LandscapeScene::createItemEmptyZone(const ZonePosition &zonePos)
{
if (m_zoneBuilder == 0)
return 0;
if (checkUnderZone(zonePos.x, zonePos.y))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilder->pixmapDatabase()->pixmap(QString(STRING_UNUSED));
if (pixmap == 0)
return 0;
QGraphicsPixmapItem *item = addPixmap(*pixmap);
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
// Set position graphics item
item->setPos(zonePos.x * m_cellSize, abs(int(zonePos.y)) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilder->pixmapDatabase()->textureSize());
// for not full item zone
item->setZValue(LAYER_EMPTY_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsRectItem *LandscapeScene::createLayerBlackout(const NLLIGO::CZoneRegion &zoneRegion)
{
QGraphicsRectItem *rectItem = addRect(zoneRegion.getMinX() * m_cellSize,
abs(zoneRegion.getMaxY()) * m_cellSize,
(abs(zoneRegion.getMaxX() - zoneRegion.getMinX()) + 1) * m_cellSize,
(abs(zoneRegion.getMaxY() - zoneRegion.getMinY()) + 1) * m_cellSize,
Qt::NoPen, QBrush(QColor(0, 0, 0, 50)));
rectItem->setZValue(LAYER_BLACKOUT);
rectItem->setData(ZONE_NAME, QString(LAYER_BLACKOUT_NAME));
return rectItem;
}
void LandscapeScene::deleteItemZone(const ZonePosition &zonePos)
{
QGraphicsItem *item = itemAt(zonePos.x * m_cellSize, abs(zonePos.y) * m_cellSize);
if ((item != 0) && (item->data(ZONE_NAME).toString() != QString(LAYER_BLACKOUT_NAME)))
{
removeItem(item);
delete item;
}
}
void LandscapeScene::addZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
std::string zoneName = zoneRegion.getName(i, j);
if (zoneName == STRING_UNUSED)
{
ZonePosition zonePos(i, j, -1);
QGraphicsItem *item = createItemEmptyZone(zonePos);
}
else if (!zoneName.empty())
{
LigoData data;
ZonePosition zonePos(i, j, -1);
data.zoneName = zoneName;
data.rot = zoneRegion.getRot(i, j);
data.flip = zoneRegion.getFlip(i, j);
data.posX = zoneRegion.getPosX(i, j);
data.posY = zoneRegion.getPosY(i, j);
QGraphicsItem *item = createItemZone(data, zonePos);
}
}
}
}
void LandscapeScene::delZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
deleteItemZone(ZonePosition(i, -j, -1));
}
}
}
void LandscapeScene::snapshot(const QString &fileName, int width, int height, const QRectF &landRect)
{
if (m_zoneBuilder == 0)
return;
// Create image
QImage image(landRect.width(), landRect.height(), QImage::Format_RGB888);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, true);
// Add white background
painter.setBrush(QBrush(Qt::white));
painter.setPen(Qt::NoPen);
painter.drawRect(0, 0, landRect.width(), landRect.height());
// Paint landscape
render(&painter, QRectF(0, 0, landRect.width(), landRect.height()), landRect);
QImage scaledImage = image.scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
scaledImage.save(fileName);
}
QString LandscapeScene::zoneNameFromMousePos() const
{
if ((m_posY > 0) || (m_posY < -MAX_SCENE_HEIGHT) ||
(m_posX < 0) || (m_posX > MAX_SCENE_WIDTH))
return "NOT A VALID ZONE";
return QString("%1_%2%3 %4 %5 ").arg(-m_posY).arg(QChar('A' + (m_posX/26))).
arg(QChar('A' + (m_posX%26))).arg(m_mouseX, 0,'f',2).arg(-m_mouseY, 0,'f',2);
}
void LandscapeScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
if ((x < 0) || (y < 0))
return;
m_posX = sint32(floor(x / m_cellSize));
m_posY = sint32(-floor(y / m_cellSize));
if (m_zoneBuilder == 0)
return;
if (m_transitionMode)
{
if (mouseEvent->button() == Qt::LeftButton)
// Need add offset(= cellSize) on y axes
m_zoneBuilder->addTransition(sint(x), sint(-y + m_cellSize));
}
else
{
if (mouseEvent->button() == Qt::LeftButton)
m_zoneBuilder->addZone(m_posX, m_posY);
else if (mouseEvent->button() == Qt::RightButton)
m_zoneBuilder->delZone(m_posX, m_posY);
}
m_mouseButton = mouseEvent->button();
QGraphicsScene::mousePressEvent(mouseEvent);
}
void LandscapeScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
sint32 posX = sint32(floor(x / m_cellSize));
sint32 posY = sint32(-floor(y / m_cellSize));
if ((m_posX != posX || m_posY != posY) &&
(m_mouseButton == Qt::LeftButton ||
m_mouseButton == Qt::RightButton))
{
if (m_transitionMode)
{
}
else
{
if (m_mouseButton == Qt::LeftButton)
m_zoneBuilder->addZone(posX, posY);
else if (m_mouseButton == Qt::RightButton)
m_zoneBuilder->delZone(posX, posY);
}
m_posX = posX;
m_posY = posY;
QApplication::processEvents();
}
m_posX = posX;
m_posY = posY;
m_mouseX = mouseEvent->scenePos().x();
m_mouseY = mouseEvent->scenePos().y() - m_cellSize;
QGraphicsScene::mouseMoveEvent(mouseEvent);
}
void LandscapeScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
m_mouseButton = Qt::NoButton;
}
bool LandscapeScene::checkUnderZone(const int posX, const int posY)
{
QGraphicsItem *item = itemAt((posX * m_cellSize), abs(posY) * m_cellSize);
if (item != 0)
{
//if (item->data(ZONE_NAME) == QString(LAYER_BLACKOUT_NAME))
// return false;
//else
return true;
}
return false;
}
bool LandscapeScene::transitionMode() const
{
return m_transitionMode;
}
void LandscapeScene::setTransitionMode(bool enabled)
{
m_transitionMode = enabled;
update();
}
void LandscapeScene::drawForeground(QPainter *painter, const QRectF &rect)
{
QGraphicsScene::drawForeground(painter, rect);
if ((m_zoneBuilder->currentIdZoneRegion() != -1) && (m_transitionMode))
drawTransition(painter, rect);
}
void LandscapeScene::drawTransition(QPainter *painter, const QRectF &rect)
{
int left = int(floor(rect.left() / m_cellSize));
int right = int(floor(rect.right() / m_cellSize));
int top = int(floor(rect.top() / m_cellSize));
int bottom = int(floor(rect.bottom() / m_cellSize));
QVector<QLine> redLines;
QVector<QLine> whiteLines;
for (int i = left; i < right + 1; ++i)
{
for (int j = top; j < bottom + 1; ++j)
{
// Get LIGO data
NLLIGO::CZoneRegion &zoneRegion = m_zoneBuilder->currentZoneRegion()->ligoZoneRegion();
uint8 ceUp = zoneRegion.getCutEdge (i, -j, 0);
uint8 ceLeft = zoneRegion.getCutEdge (i, -j, 2);
if ((ceUp > 0) && (ceUp < 3))
{
// Calculate position vertical lines
int x1, x2, y1, y2;
y1 = j * m_cellSize + m_cellSize / 12.0f;
y2 = y1 - (m_cellSize / 6.0f);
x1 = i * m_cellSize + 3.0f * m_cellSize / 12.0f;
x2 = i * m_cellSize + 5.0f * m_cellSize / 12.0f;
if (ceUp == 1)
{
whiteLines.push_back(QLine(x1, y1, x1, y2));
whiteLines.push_back(QLine(x2, y1, x2, y2));
}
else
{
redLines.push_back(QLine(x1, y1, x1, y2));
redLines.push_back(QLine(x2, y1, x2, y2));
}
x1 = i * m_cellSize + 7.0f * m_cellSize / 12.0f;
x2 = i * m_cellSize + 9.0f * m_cellSize / 12.0f;
if (ceUp == 1)
{
redLines.push_back(QLine(x1, y1, x1, y2));
redLines.push_back(QLine(x2, y1, x2, y2));
}
else
{
whiteLines.push_back(QLine(x1, y1, x1, y2));
whiteLines.push_back(QLine(x2, y1, x2, y2));
}
}
if ((ceLeft > 0) && (ceLeft < 3))
{
// Calculate position horizontal lines
int x1, x2, y1, y2;
x1 = i * m_cellSize - m_cellSize / 12.0f;
x2 = x1 + (m_cellSize / 6.0f);
y1 = j * m_cellSize + 3.0f * m_cellSize / 12.0f;
y2 = j * m_cellSize + 5.0f * m_cellSize / 12.0f;
if (ceLeft == 1)
{
redLines.push_back(QLine(x1, y1, x2, y1));
redLines.push_back(QLine(x1, y2, x2, y2));
}
else
{
whiteLines.push_back(QLine(x1, y1, x2, y1));
whiteLines.push_back(QLine(x1, y2, x2, y2));
}
y1 = j * m_cellSize + 7.0f * m_cellSize / 12.0f;
y2 = j * m_cellSize + 9.0f * m_cellSize / 12.0f;
if (ceLeft == 1)
{
whiteLines.push_back(QLine(x1, y1, x2, y1));
whiteLines.push_back(QLine(x1, y2, x2, y2));
}
else
{
redLines.push_back(QLine(x1, y1, x2, y1));
redLines.push_back(QLine(x1, y2, x2, y2));
}
}
}
}
// Draw lines
painter->setPen(QPen(Qt::red, 0, Qt::SolidLine));
painter->drawLines(redLines);
painter->setPen(QPen(Qt::white, 0, Qt::SolidLine));
painter->drawLines(whiteLines);
}
} /* namespace LandscapeEditor */

662
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_scene_base.cpp
View file

@ -1,331 +1,331 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_scene_base.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtGui/QPainter>
#include <QtGui/QGraphicsPixmapItem>
#include <QtGui/QGraphicsSimpleTextItem>
#include <QApplication>
namespace LandscapeEditor
{
static const int ZONE_NAME = 0;
static const int LAYER_ZONES = 2;
static const int LAYER_EMPTY_ZONES = 3;
// TODO: delete
const char *const LAYER_BLACKOUT_NAME = "blackout";
const int MAX_SCENE_WIDTH = 256;
const int MAX_SCENE_HEIGHT = 256;
LandscapeSceneBase::LandscapeSceneBase(int sizeCell, QObject *parent)
: QGraphicsScene(parent),
m_cellSize(sizeCell),
m_zoneBuilderBase(0)
{
setSceneRect(QRectF(0, m_cellSize, MAX_SCENE_WIDTH * m_cellSize, MAX_SCENE_HEIGHT * m_cellSize));
}
LandscapeSceneBase::~LandscapeSceneBase()
{
}
int LandscapeSceneBase::cellSize() const
{
return m_cellSize;
}
void LandscapeSceneBase::setZoneBuilder(ZoneBuilderBase *zoneBuilder)
{
m_zoneBuilderBase = zoneBuilder;
}
QGraphicsItem *LandscapeSceneBase::createItemZone(const LigoData &data, const ZonePosition &zonePos)
{
if ((data.zoneName == STRING_OUT_OF_BOUND) || (checkUnderZone(zonePos.x, zonePos.y)))
return 0;
if (data.zoneName == STRING_UNUSED)
return createItemEmptyZone(zonePos);
if ((m_zoneBuilderBase == 0) || (data.zoneName.empty()))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilderBase->pixmapDatabase()->pixmap(QString(data.zoneName.c_str()));
if (pixmap == 0)
return 0;
// Rotate the image counter clockwise
QMatrix matrix;
matrix.rotate(-data.rot * 90.0);
QGraphicsPixmapItem *item;
if (data.flip == 0)
{
item = addPixmap(pixmap->transformed(matrix, Qt::SmoothTransformation));
}
else
{
// mirror image
QImage mirrorImage = pixmap->toImage();
QPixmap mirrorPixmap = QPixmap::fromImage(mirrorImage.mirrored(true, false));
item = addPixmap(mirrorPixmap.transformed(matrix, Qt::SmoothTransformation));
}
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
sint32 sizeX = 1, sizeY = 1;
sizeX = float(pixmap->width()) / m_zoneBuilderBase->pixmapDatabase()->textureSize();
sizeY = float(pixmap->width()) / m_zoneBuilderBase->pixmapDatabase()->textureSize();
sint32 deltaX = 0, deltaY = 0;
// Calculate offset for graphics item (for items with size that are larger than 1)
if ((sizeX > 1) || (sizeY > 1))
{
if (data.flip == 0)
{
switch (data.rot)
{
case 0:
deltaX = -data.posX;
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = -data.posX + sizeX - 1;
break;
case 2:
deltaX = -(sizeX - 1 - data.posX);
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = data.posX;
break;
}
}
else
{
switch (data.rot)
{
case 0:
deltaX = -(sizeX - 1 - data.posX);
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = +data.posX;
break;
case 2:
deltaX = -data.posX;
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = -data.posX + sizeX - 1;
break;
}
}
}
// Set position graphics item with offset for large piece
item->setPos((zonePos.x + deltaX) * m_cellSize, (abs(int(zonePos.y + deltaY))) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilderBase->pixmapDatabase()->textureSize());
item->setData(ZONE_NAME, QString(data.zoneName.c_str()));
// for not full item zone
item->setZValue(LAYER_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsItem *LandscapeSceneBase::createItemEmptyZone(const ZonePosition &zonePos)
{
if (m_zoneBuilderBase == 0)
return 0;
if (checkUnderZone(zonePos.x, zonePos.y))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilderBase->pixmapDatabase()->pixmap(QString(STRING_UNUSED));
if (pixmap == 0)
return 0;
QGraphicsPixmapItem *item = addPixmap(*pixmap);
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
// Set position graphics item
item->setPos(zonePos.x * m_cellSize, abs(int(zonePos.y)) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilderBase->pixmapDatabase()->textureSize());
// for not full item zone
item->setZValue(LAYER_EMPTY_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
void LandscapeSceneBase::deleteItemZone(const ZonePosition &zonePos)
{
QList<QGraphicsItem *> listItems = items(QPointF(zonePos.x * m_cellSize + 10, abs(zonePos.y) * m_cellSize + 10),
Qt::IntersectsItemBoundingRect, Qt::AscendingOrder);
Q_FOREACH(QGraphicsItem *item, listItems)
{
if (qgraphicsitem_cast<QGraphicsPixmapItem *>(item) != 0)
{
removeItem(item);
delete item;
return;
}
}
}
void LandscapeSceneBase::addZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
std::string zoneName = zoneRegion.getName(i, j);
if (zoneName == STRING_UNUSED)
{
ZonePosition zonePos(i, j, -1);
QGraphicsItem *item = createItemEmptyZone(zonePos);
}
else if (!zoneName.empty())
{
LigoData data;
ZonePosition zonePos(i, j, -1);
data.zoneName = zoneName;
data.rot = zoneRegion.getRot(i, j);
data.flip = zoneRegion.getFlip(i, j);
data.posX = zoneRegion.getPosX(i, j);
data.posY = zoneRegion.getPosY(i, j);
QGraphicsItem *item = createItemZone(data, zonePos);
}
}
}
}
void LandscapeSceneBase::delZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
deleteItemZone(ZonePosition(i, -j, -1));
}
}
}
void LandscapeSceneBase::snapshot(const QString &fileName, int width, int height, const QRectF &landRect)
{
if (m_zoneBuilderBase == 0)
return;
// Create image
QImage image(landRect.width(), landRect.height(), QImage::Format_RGB888);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, true);
// Add white background
painter.setBrush(QBrush(Qt::white));
painter.setPen(Qt::NoPen);
painter.drawRect(0, 0, landRect.width(), landRect.height());
// Paint landscape
render(&painter, QRectF(0, 0, landRect.width(), landRect.height()), landRect);
QImage scaledImage = image.scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
scaledImage.save(fileName);
}
QString LandscapeSceneBase::zoneNameFromMousePos() const
{
if ((m_posY > 0) || (m_posY < -MAX_SCENE_HEIGHT) ||
(m_posX < 0) || (m_posX > MAX_SCENE_WIDTH))
return "NOT A VALID ZONE";
return QString("%1_%2%3 %4 %5 ").arg(-m_posY+1).arg(QChar('A' + (m_posX/26))).
arg(QChar('A' + (m_posX%26))).arg(m_mouseX, 0,'f',2).arg(-m_mouseY, 0,'f',2);
}
void LandscapeSceneBase::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
QGraphicsScene::mousePressEvent(mouseEvent);
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
m_posX = sint32(floor(x / m_cellSize));
m_posY = sint32(-floor(y / m_cellSize));
}
void LandscapeSceneBase::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
m_mouseX = mouseEvent->scenePos().x();
m_mouseY = mouseEvent->scenePos().y() - m_cellSize;
m_posX = sint32(floor(m_mouseX / m_cellSize));
m_posY = sint32(-floor(m_mouseY / m_cellSize));
QGraphicsScene::mouseMoveEvent(mouseEvent);
}
bool LandscapeSceneBase::checkUnderZone(const int posX, const int posY)
{
// TODO: Why crash program?
// QList<QGraphicsItem *> listItems = items(QPointF(posX * m_cellSize + 10, abs(posY) * m_cellSize + 10),
// Qt::IntersectsItemBoundingRect, Qt::AscendingOrder);
QList<QGraphicsItem *> listItems = items();
QPointF point(posX, abs(posY));
Q_FOREACH(QGraphicsItem *item, listItems)
{
if (item->pos() == point)
{
if (qgraphicsitem_cast<QGraphicsPixmapItem *>(item) != 0)
return true;
}
}
return false;
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_scene_base.h"
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtGui/QPainter>
#include <QtGui/QGraphicsPixmapItem>
#include <QtGui/QGraphicsSimpleTextItem>
#include <QApplication>
namespace LandscapeEditor
{
static const int ZONE_NAME = 0;
static const int LAYER_ZONES = 2;
static const int LAYER_EMPTY_ZONES = 3;
// TODO: delete
const char *const LAYER_BLACKOUT_NAME = "blackout";
const int MAX_SCENE_WIDTH = 256;
const int MAX_SCENE_HEIGHT = 256;
LandscapeSceneBase::LandscapeSceneBase(int sizeCell, QObject *parent)
: QGraphicsScene(parent),
m_cellSize(sizeCell),
m_zoneBuilderBase(0)
{
setSceneRect(QRectF(0, m_cellSize, MAX_SCENE_WIDTH * m_cellSize, MAX_SCENE_HEIGHT * m_cellSize));
}
LandscapeSceneBase::~LandscapeSceneBase()
{
}
int LandscapeSceneBase::cellSize() const
{
return m_cellSize;
}
void LandscapeSceneBase::setZoneBuilder(ZoneBuilderBase *zoneBuilder)
{
m_zoneBuilderBase = zoneBuilder;
}
QGraphicsItem *LandscapeSceneBase::createItemZone(const LigoData &data, const ZonePosition &zonePos)
{
if ((data.zoneName == STRING_OUT_OF_BOUND) || (checkUnderZone(zonePos.x, zonePos.y)))
return 0;
if (data.zoneName == STRING_UNUSED)
return createItemEmptyZone(zonePos);
if ((m_zoneBuilderBase == 0) || (data.zoneName.empty()))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilderBase->pixmapDatabase()->pixmap(QString(data.zoneName.c_str()));
if (pixmap == 0)
return 0;
// Rotate the image counter clockwise
QMatrix matrix;
matrix.rotate(-data.rot * 90.0);
QGraphicsPixmapItem *item;
if (data.flip == 0)
{
item = addPixmap(pixmap->transformed(matrix, Qt::SmoothTransformation));
}
else
{
// mirror image
QImage mirrorImage = pixmap->toImage();
QPixmap mirrorPixmap = QPixmap::fromImage(mirrorImage.mirrored(true, false));
item = addPixmap(mirrorPixmap.transformed(matrix, Qt::SmoothTransformation));
}
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
sint32 sizeX = 1, sizeY = 1;
sizeX = float(pixmap->width()) / m_zoneBuilderBase->pixmapDatabase()->textureSize();
sizeY = float(pixmap->width()) / m_zoneBuilderBase->pixmapDatabase()->textureSize();
sint32 deltaX = 0, deltaY = 0;
// Calculate offset for graphics item (for items with size that are larger than 1)
if ((sizeX > 1) || (sizeY > 1))
{
if (data.flip == 0)
{
switch (data.rot)
{
case 0:
deltaX = -data.posX;
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = -data.posX + sizeX - 1;
break;
case 2:
deltaX = -(sizeX - 1 - data.posX);
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = data.posX;
break;
}
}
else
{
switch (data.rot)
{
case 0:
deltaX = -(sizeX - 1 - data.posX);
deltaY = -data.posY + sizeY - 1;
break;
case 1:
deltaX = -(sizeY - 1 - data.posY);
deltaY = +data.posX;
break;
case 2:
deltaX = -data.posX;
deltaY = data.posY;
break;
case 3:
deltaX = -data.posY;
deltaY = -data.posX + sizeX - 1;
break;
}
}
}
// Set position graphics item with offset for large piece
item->setPos((zonePos.x + deltaX) * m_cellSize, (abs(int(zonePos.y + deltaY))) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilderBase->pixmapDatabase()->textureSize());
item->setData(ZONE_NAME, QString(data.zoneName.c_str()));
// for not full item zone
item->setZValue(LAYER_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
QGraphicsItem *LandscapeSceneBase::createItemEmptyZone(const ZonePosition &zonePos)
{
if (m_zoneBuilderBase == 0)
return 0;
if (checkUnderZone(zonePos.x, zonePos.y))
return 0;
// Get image from pixmap database
QPixmap *pixmap = m_zoneBuilderBase->pixmapDatabase()->pixmap(QString(STRING_UNUSED));
if (pixmap == 0)
return 0;
QGraphicsPixmapItem *item = addPixmap(*pixmap);
// Enable bilinear filtering
item->setTransformationMode(Qt::SmoothTransformation);
// Set position graphics item
item->setPos(zonePos.x * m_cellSize, abs(int(zonePos.y)) * m_cellSize);
// The size graphics item should be equal or proportional m_cellSize
item->setScale(float(m_cellSize) / m_zoneBuilderBase->pixmapDatabase()->textureSize());
// for not full item zone
item->setZValue(LAYER_EMPTY_ZONES);
item->setShapeMode(QGraphicsPixmapItem::BoundingRectShape);
return item;
}
void LandscapeSceneBase::deleteItemZone(const ZonePosition &zonePos)
{
QList<QGraphicsItem *> listItems = items(QPointF(zonePos.x * m_cellSize + 10, abs(zonePos.y) * m_cellSize + 10),
Qt::IntersectsItemBoundingRect, Qt::AscendingOrder);
Q_FOREACH(QGraphicsItem *item, listItems)
{
if (qgraphicsitem_cast<QGraphicsPixmapItem *>(item) != 0)
{
removeItem(item);
delete item;
return;
}
}
}
void LandscapeSceneBase::addZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
std::string zoneName = zoneRegion.getName(i, j);
if (zoneName == STRING_UNUSED)
{
ZonePosition zonePos(i, j, -1);
QGraphicsItem *item = createItemEmptyZone(zonePos);
}
else if (!zoneName.empty())
{
LigoData data;
ZonePosition zonePos(i, j, -1);
data.zoneName = zoneName;
data.rot = zoneRegion.getRot(i, j);
data.flip = zoneRegion.getFlip(i, j);
data.posX = zoneRegion.getPosX(i, j);
data.posY = zoneRegion.getPosY(i, j);
QGraphicsItem *item = createItemZone(data, zonePos);
}
}
}
}
void LandscapeSceneBase::delZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
for (sint32 i = zoneRegion.getMinX(); i <= zoneRegion.getMaxX(); ++i)
{
for (sint32 j = zoneRegion.getMinY(); j <= zoneRegion.getMaxY(); ++j)
{
deleteItemZone(ZonePosition(i, -j, -1));
}
}
}
void LandscapeSceneBase::snapshot(const QString &fileName, int width, int height, const QRectF &landRect)
{
if (m_zoneBuilderBase == 0)
return;
// Create image
QImage image(landRect.width(), landRect.height(), QImage::Format_RGB888);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, true);
// Add white background
painter.setBrush(QBrush(Qt::white));
painter.setPen(Qt::NoPen);
painter.drawRect(0, 0, landRect.width(), landRect.height());
// Paint landscape
render(&painter, QRectF(0, 0, landRect.width(), landRect.height()), landRect);
QImage scaledImage = image.scaled(width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
scaledImage.save(fileName);
}
QString LandscapeSceneBase::zoneNameFromMousePos() const
{
if ((m_posY > 0) || (m_posY < -MAX_SCENE_HEIGHT) ||
(m_posX < 0) || (m_posX > MAX_SCENE_WIDTH))
return "NOT A VALID ZONE";
return QString("%1_%2%3 %4 %5 ").arg(-m_posY+1).arg(QChar('A' + (m_posX/26))).
arg(QChar('A' + (m_posX%26))).arg(m_mouseX, 0,'f',2).arg(-m_mouseY, 0,'f',2);
}
void LandscapeSceneBase::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
QGraphicsScene::mousePressEvent(mouseEvent);
qreal x = mouseEvent->scenePos().x();
qreal y = mouseEvent->scenePos().y();
m_posX = sint32(floor(x / m_cellSize));
m_posY = sint32(-floor(y / m_cellSize));
}
void LandscapeSceneBase::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
m_mouseX = mouseEvent->scenePos().x();
m_mouseY = mouseEvent->scenePos().y() - m_cellSize;
m_posX = sint32(floor(m_mouseX / m_cellSize));
m_posY = sint32(-floor(m_mouseY / m_cellSize));
QGraphicsScene::mouseMoveEvent(mouseEvent);
}
bool LandscapeSceneBase::checkUnderZone(const int posX, const int posY)
{
// TODO: Why crash program?
// QList<QGraphicsItem *> listItems = items(QPointF(posX * m_cellSize + 10, abs(posY) * m_cellSize + 10),
// Qt::IntersectsItemBoundingRect, Qt::AscendingOrder);
QList<QGraphicsItem *> listItems = items();
QPointF point(posX, abs(posY));
Q_FOREACH(QGraphicsItem *item, listItems)
{
if (item->pos() == point)
{
if (qgraphicsitem_cast<QGraphicsPixmapItem *>(item) != 0)
return true;
}
}
return false;
}
} /* namespace LandscapeEditor */

508
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/landscape_view.cpp
View file

@ -1,254 +1,254 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_view.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QApplication>
namespace LandscapeEditor
{
LandscapeView::LandscapeView(QWidget *parent)
: QGraphicsView(parent),
m_visibleGrid(true),
m_visibleText(true)
{
setTransformationAnchor(AnchorUnderMouse);
setBackgroundBrush(QBrush(Qt::lightGray));
m_cellSize = 160;
m_maxView = 0.06;
m_minView = 32.0;
m_maxViewText = 0.6;
//A modified version of centerOn(), handles special cases
setCenter(QPointF(500.0, 500.0));
}
LandscapeView::~LandscapeView()
{
}
bool LandscapeView::isVisibleGrid() const
{
return m_visibleGrid;
}
void LandscapeView::setVisibleGrid(bool visible)
{
m_visibleGrid = visible;
scene()->update();
}
void LandscapeView::setVisibleText(bool visible)
{
m_visibleText = visible;
scene()->update();
}
void LandscapeView::wheelEvent(QWheelEvent *event)
{
//How fast we zoom
float numSteps = (( event->delta() / 8 ) / 15) * 1.2;
QMatrix mat = matrix();
QPointF mousePosition = event->pos();
mat.translate((width() / 2) - mousePosition.x(), (height() / 2) - mousePosition.y());
if ( numSteps > 0 )
mat.scale(numSteps, numSteps);
else
mat.scale(-1 / numSteps, -1 / numSteps);
mat.translate(mousePosition.x() - (width() / 2), mousePosition.y() - (height() / 2));
//Adjust to the new center for correct zooming
setMatrix(mat);
event->accept();
}
void LandscapeView::mousePressEvent(QMouseEvent *event)
{
QGraphicsView::mousePressEvent(event);
if (event->button() != Qt::MiddleButton)
return;
//For panning the view
m_lastPanPoint = event->pos();
setCursor(Qt::ClosedHandCursor);
}
void LandscapeView::mouseMoveEvent(QMouseEvent *event)
{
if(!m_lastPanPoint.isNull())
{
//Get how much we panned
QPointF delta = mapToScene(m_lastPanPoint) - mapToScene(event->pos());
m_lastPanPoint = event->pos();
//Update the center ie. do the pan
setCenter(getCenter() + delta);
}
QGraphicsView::mouseMoveEvent(event);
}
void LandscapeView::mouseReleaseEvent(QMouseEvent *event)
{
m_lastPanPoint = QPoint();
setCursor(Qt::ArrowCursor);
QGraphicsView::mouseReleaseEvent(event);
}
void LandscapeView::resizeEvent(QResizeEvent *event)
{
//Get the rectangle of the visible area in scene coords
QRectF visibleArea = mapToScene(rect()).boundingRect();
setCenter(visibleArea.center());
//Call the subclass resize so the scrollbars are updated correctly
QGraphicsView::resizeEvent(event);
}
void LandscapeView::setCenter(const QPointF &centerPoint)
{
//Get the rectangle of the visible area in scene coords
QRectF visibleArea = mapToScene(rect()).boundingRect();
//Get the scene area
QRectF sceneBounds = sceneRect();
double boundX = visibleArea.width() / 2.0;
double boundY = visibleArea.height() / 2.0;
double boundWidth = sceneBounds.width() - 2.0 * boundX;
double boundHeight = sceneBounds.height() - 2.0 * boundY;
//The max boundary that the centerPoint can be to
QRectF bounds(boundX, boundY, boundWidth, boundHeight);
if(bounds.contains(centerPoint))
{
//We are within the bounds
m_currentCenterPoint = centerPoint;
}
else
{
//We need to clamp or use the center of the screen
if(visibleArea.contains(sceneBounds))
{
//Use the center of scene ie. we can see the whole scene
m_currentCenterPoint = sceneBounds.center();
}
else
{
m_currentCenterPoint = centerPoint;
//We need to clamp the center. The centerPoint is too large
if (centerPoint.x() > bounds.x() + bounds.width())
m_currentCenterPoint.setX(bounds.x() + bounds.width());
else if(centerPoint.x() < bounds.x())
m_currentCenterPoint.setX(bounds.x());
if(centerPoint.y() > bounds.y() + bounds.height())
m_currentCenterPoint.setY(bounds.y() + bounds.height());
else if(centerPoint.y() < bounds.y())
m_currentCenterPoint.setY(bounds.y());
}
}
//Update the scrollbars
centerOn(m_currentCenterPoint);
}
QPointF LandscapeView::getCenter() const
{
//return m_currentCenterPoint;
return mapToScene(viewport()->rect().center());
}
void LandscapeView::drawForeground(QPainter *painter, const QRectF &rect)
{
QGraphicsView::drawForeground(painter, rect);
if (!m_visibleGrid)
return;
painter->setPen(QPen(Qt::white, 0, Qt::SolidLine));
drawGrid(painter, rect);
if (!m_visibleText)
return;
if (transform().m11() > m_maxViewText)
{
painter->setPen(QPen(Qt::white, 0.5, Qt::SolidLine));
drawZoneNames(painter, rect);
}
}
void LandscapeView::drawGrid(QPainter *painter, const QRectF &rect)
{
qreal left = m_cellSize * floor(rect.left() / m_cellSize);
qreal top = m_cellSize * floor(rect.top() / m_cellSize);
QVector<QLine> lines;
// Calculate vertical lines
while (left < rect.right())
{
lines.push_back(QLine(int(left), int(rect.bottom()), int(left), int(rect.top())));
left += m_cellSize;
}
// Calculate horizontal lines
while (top < rect.bottom())
{
lines.push_back(QLine(int(rect.left()), int(top), int(rect.right()), int(top)));
top += m_cellSize;
}
// Draw lines
painter->drawLines(lines);
}
void LandscapeView::drawZoneNames(QPainter *painter, const QRectF &rect)
{
int leftSide = int(floor(rect.left() / m_cellSize));
int rightSide = int(floor(rect.right() / m_cellSize));
int topSide = int(floor(rect.top() / m_cellSize));
int bottomSide = int(floor(rect.bottom() / m_cellSize));
for (int i = leftSide; i < rightSide + 1; ++i)
{
for (int j = topSide; j < bottomSide + 1; ++j)
{
QString text = QString("%1_%2%3").arg(j).arg(QChar('A' + (i / 26))).arg(QChar('A' + (i % 26)));
painter->drawText(i * m_cellSize + 5, j * m_cellSize + 15, text);
}
}
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "landscape_view.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QApplication>
namespace LandscapeEditor
{
LandscapeView::LandscapeView(QWidget *parent)
: QGraphicsView(parent),
m_visibleGrid(true),
m_visibleText(true)
{
setTransformationAnchor(AnchorUnderMouse);
setBackgroundBrush(QBrush(Qt::lightGray));
m_cellSize = 160;
m_maxView = 0.06;
m_minView = 32.0;
m_maxViewText = 0.6;
//A modified version of centerOn(), handles special cases
setCenter(QPointF(500.0, 500.0));
}
LandscapeView::~LandscapeView()
{
}
bool LandscapeView::isVisibleGrid() const
{
return m_visibleGrid;
}
void LandscapeView::setVisibleGrid(bool visible)
{
m_visibleGrid = visible;
scene()->update();
}
void LandscapeView::setVisibleText(bool visible)
{
m_visibleText = visible;
scene()->update();
}
void LandscapeView::wheelEvent(QWheelEvent *event)
{
//How fast we zoom
float numSteps = (( event->delta() / 8 ) / 15) * 1.2;
QMatrix mat = matrix();
QPointF mousePosition = event->pos();
mat.translate((width() / 2) - mousePosition.x(), (height() / 2) - mousePosition.y());
if ( numSteps > 0 )
mat.scale(numSteps, numSteps);
else
mat.scale(-1 / numSteps, -1 / numSteps);
mat.translate(mousePosition.x() - (width() / 2), mousePosition.y() - (height() / 2));
//Adjust to the new center for correct zooming
setMatrix(mat);
event->accept();
}
void LandscapeView::mousePressEvent(QMouseEvent *event)
{
QGraphicsView::mousePressEvent(event);
if (event->button() != Qt::MiddleButton)
return;
//For panning the view
m_lastPanPoint = event->pos();
setCursor(Qt::ClosedHandCursor);
}
void LandscapeView::mouseMoveEvent(QMouseEvent *event)
{
if(!m_lastPanPoint.isNull())
{
//Get how much we panned
QPointF delta = mapToScene(m_lastPanPoint) - mapToScene(event->pos());
m_lastPanPoint = event->pos();
//Update the center ie. do the pan
setCenter(getCenter() + delta);
}
QGraphicsView::mouseMoveEvent(event);
}
void LandscapeView::mouseReleaseEvent(QMouseEvent *event)
{
m_lastPanPoint = QPoint();
setCursor(Qt::ArrowCursor);
QGraphicsView::mouseReleaseEvent(event);
}
void LandscapeView::resizeEvent(QResizeEvent *event)
{
//Get the rectangle of the visible area in scene coords
QRectF visibleArea = mapToScene(rect()).boundingRect();
setCenter(visibleArea.center());
//Call the subclass resize so the scrollbars are updated correctly
QGraphicsView::resizeEvent(event);
}
void LandscapeView::setCenter(const QPointF &centerPoint)
{
//Get the rectangle of the visible area in scene coords
QRectF visibleArea = mapToScene(rect()).boundingRect();
//Get the scene area
QRectF sceneBounds = sceneRect();
double boundX = visibleArea.width() / 2.0;
double boundY = visibleArea.height() / 2.0;
double boundWidth = sceneBounds.width() - 2.0 * boundX;
double boundHeight = sceneBounds.height() - 2.0 * boundY;
//The max boundary that the centerPoint can be to
QRectF bounds(boundX, boundY, boundWidth, boundHeight);
if(bounds.contains(centerPoint))
{
//We are within the bounds
m_currentCenterPoint = centerPoint;
}
else
{
//We need to clamp or use the center of the screen
if(visibleArea.contains(sceneBounds))
{
//Use the center of scene ie. we can see the whole scene
m_currentCenterPoint = sceneBounds.center();
}
else
{
m_currentCenterPoint = centerPoint;
//We need to clamp the center. The centerPoint is too large
if (centerPoint.x() > bounds.x() + bounds.width())
m_currentCenterPoint.setX(bounds.x() + bounds.width());
else if(centerPoint.x() < bounds.x())
m_currentCenterPoint.setX(bounds.x());
if(centerPoint.y() > bounds.y() + bounds.height())
m_currentCenterPoint.setY(bounds.y() + bounds.height());
else if(centerPoint.y() < bounds.y())
m_currentCenterPoint.setY(bounds.y());
}
}
//Update the scrollbars
centerOn(m_currentCenterPoint);
}
QPointF LandscapeView::getCenter() const
{
//return m_currentCenterPoint;
return mapToScene(viewport()->rect().center());
}
void LandscapeView::drawForeground(QPainter *painter, const QRectF &rect)
{
QGraphicsView::drawForeground(painter, rect);
if (!m_visibleGrid)
return;
painter->setPen(QPen(Qt::white, 0, Qt::SolidLine));
drawGrid(painter, rect);
if (!m_visibleText)
return;
if (transform().m11() > m_maxViewText)
{
painter->setPen(QPen(Qt::white, 0.5, Qt::SolidLine));
drawZoneNames(painter, rect);
}
}
void LandscapeView::drawGrid(QPainter *painter, const QRectF &rect)
{
qreal left = m_cellSize * floor(rect.left() / m_cellSize);
qreal top = m_cellSize * floor(rect.top() / m_cellSize);
QVector<QLine> lines;
// Calculate vertical lines
while (left < rect.right())
{
lines.push_back(QLine(int(left), int(rect.bottom()), int(left), int(rect.top())));
left += m_cellSize;
}
// Calculate horizontal lines
while (top < rect.bottom())
{
lines.push_back(QLine(int(rect.left()), int(top), int(rect.right()), int(top)));
top += m_cellSize;
}
// Draw lines
painter->drawLines(lines);
}
void LandscapeView::drawZoneNames(QPainter *painter, const QRectF &rect)
{
int leftSide = int(floor(rect.left() / m_cellSize));
int rightSide = int(floor(rect.right() / m_cellSize));
int topSide = int(floor(rect.top() / m_cellSize));
int bottomSide = int(floor(rect.bottom() / m_cellSize));
for (int i = leftSide; i < rightSide + 1; ++i)
{
for (int j = topSide; j < bottomSide + 1; ++j)
{
QString text = QString("%1_%2%3").arg(j).arg(QChar('A' + (i / 26))).arg(QChar('A' + (i % 26)));
painter->drawText(i * m_cellSize + 5, j * m_cellSize + 15, text);
}
}
}
} /* namespace LandscapeEditor */

274
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/list_zones_model.cpp
View file

@ -1,137 +1,137 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "list_zones_model.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
// STL includes
#include <string>
#include <vector>
// Qt includes
#include <QApplication>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
ListZonesModel::ListZonesModel(int scaleRatio, QObject *parent)
: QAbstractListModel(parent),
m_scaleRatio(scaleRatio)
{
}
ListZonesModel::~ListZonesModel()
{
resetModel();
}
int ListZonesModel::rowCount(const QModelIndex & /* parent */) const
{
return m_listNames.count();
}
int ListZonesModel::columnCount(const QModelIndex & /* parent */) const
{
return 1;
}
QVariant ListZonesModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
switch (role)
{
case Qt::TextAlignmentRole:
return int(Qt::AlignLeft | Qt::AlignVCenter);
case Qt::DisplayRole:
return m_listNames.at(index.row());
case Qt::DecorationRole:
{
QPixmap *pixmap = getPixmap(m_listNames.at(index.row()));
return qVariantFromValue(*pixmap);
}
default:
return QVariant();
}
}
QVariant ListZonesModel::headerData(int section, Qt::Orientation, int role) const
{
return QVariant();
}
void ListZonesModel::setScaleRatio(int scaleRatio)
{
m_scaleRatio = scaleRatio;
}
void ListZonesModel::setListZones(QStringList &listZones)
{
beginResetModel();
m_listNames.clear();
m_listNames = listZones;
endResetModel();
}
void ListZonesModel::resetModel()
{
beginResetModel();
QStringList listNames(m_pixmapMap.keys());
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = m_pixmapMap.value(name);
delete pixmap;
}
m_pixmapMap.clear();
m_listNames.clear();
endResetModel();
}
void ListZonesModel::rebuildModel(PixmapDatabase *pixmapDatabase)
{
resetModel();
beginResetModel();
QStringList listNames;
listNames = pixmapDatabase->listPixmaps();
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = pixmapDatabase->pixmap(name);
QPixmap *smallPixmap = new QPixmap(pixmap->scaled(pixmap->width() / m_scaleRatio, pixmap->height() / m_scaleRatio));
m_pixmapMap.insert(name, smallPixmap);
}
endResetModel();
}
QPixmap *ListZonesModel::getPixmap(const QString &zoneName) const
{
QPixmap *result = 0;
if (!m_pixmapMap.contains(zoneName))
nlwarning("QPixmap %s not found", zoneName.toStdString().c_str());
else
result = m_pixmapMap.value(zoneName);
return result;
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "list_zones_model.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
// STL includes
#include <string>
#include <vector>
// Qt includes
#include <QApplication>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
ListZonesModel::ListZonesModel(int scaleRatio, QObject *parent)
: QAbstractListModel(parent),
m_scaleRatio(scaleRatio)
{
}
ListZonesModel::~ListZonesModel()
{
resetModel();
}
int ListZonesModel::rowCount(const QModelIndex & /* parent */) const
{
return m_listNames.count();
}
int ListZonesModel::columnCount(const QModelIndex & /* parent */) const
{
return 1;
}
QVariant ListZonesModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
switch (role)
{
case Qt::TextAlignmentRole:
return int(Qt::AlignLeft | Qt::AlignVCenter);
case Qt::DisplayRole:
return m_listNames.at(index.row());
case Qt::DecorationRole:
{
QPixmap *pixmap = getPixmap(m_listNames.at(index.row()));
return qVariantFromValue(*pixmap);
}
default:
return QVariant();
}
}
QVariant ListZonesModel::headerData(int section, Qt::Orientation, int role) const
{
return QVariant();
}
void ListZonesModel::setScaleRatio(int scaleRatio)
{
m_scaleRatio = scaleRatio;
}
void ListZonesModel::setListZones(QStringList &listZones)
{
beginResetModel();
m_listNames.clear();
m_listNames = listZones;
endResetModel();
}
void ListZonesModel::resetModel()
{
beginResetModel();
QStringList listNames(m_pixmapMap.keys());
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = m_pixmapMap.value(name);
delete pixmap;
}
m_pixmapMap.clear();
m_listNames.clear();
endResetModel();
}
void ListZonesModel::rebuildModel(PixmapDatabase *pixmapDatabase)
{
resetModel();
beginResetModel();
QStringList listNames;
listNames = pixmapDatabase->listPixmaps();
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = pixmapDatabase->pixmap(name);
QPixmap *smallPixmap = new QPixmap(pixmap->scaled(pixmap->width() / m_scaleRatio, pixmap->height() / m_scaleRatio));
m_pixmapMap.insert(name, smallPixmap);
}
endResetModel();
}
QPixmap *ListZonesModel::getPixmap(const QString &zoneName) const
{
QPixmap *result = 0;
if (!m_pixmapMap.contains(zoneName))
nlwarning("QPixmap %s not found", zoneName.toStdString().c_str());
else
result = m_pixmapMap.value(zoneName);
return result;
}
} /* namespace LandscapeEditor */

616
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/list_zones_widget.cpp
View file

@ -1,308 +1,308 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "list_zones_widget.h"
#include "list_zones_model.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/zone_bank.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <vector>
#include <string>
// Qt includes
#include <QtGui/QIcon>
#include <QtCore/QModelIndex>
namespace LandscapeEditor
{
ListZonesWidget::ListZonesWidget(QWidget *parent)
: QWidget(parent),
m_rotCycle(0),
m_flipCycle(0),
m_listZonesModel(0),
m_zoneBuilder(0)
{
m_ui.setupUi(this);
m_listZonesModel = new ListZonesModel(4, this);
m_ui.listView->setModel(m_listZonesModel);
m_ui.addFilterButton_1->setChecked(false);
m_ui.addFilterButton_2->setChecked(false);
m_ui.addFilterButton_3->setChecked(false);
connect(m_ui.categoryTypeComboBox_1, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_1(QString)));
connect(m_ui.categoryTypeComboBox_2, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_2(QString)));
connect(m_ui.categoryTypeComboBox_3, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_3(QString)));
connect(m_ui.categoryTypeComboBox_4, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_4(QString)));
connect(m_ui.categoryValueComboBox_1, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_2, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_3, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_4, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_2, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_3, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_4, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
}
ListZonesWidget::~ListZonesWidget()
{
}
void ListZonesWidget::updateUi()
{
if (m_zoneBuilder == 0)
return;
disableSignals(true);
std::vector<std::string> listCategoryType;
m_zoneBuilder->getZoneBank().getCategoriesType(listCategoryType);
QStringList listCategories;
listCategories << STRING_UNUSED;
for (size_t i = 0; i < listCategoryType.size(); ++i)
listCategories << QString(listCategoryType[i].c_str());
m_ui.categoryTypeComboBox_1->clear();
m_ui.categoryTypeComboBox_2->clear();
m_ui.categoryTypeComboBox_3->clear();
m_ui.categoryTypeComboBox_4->clear();
m_ui.categoryValueComboBox_1->clear();
m_ui.categoryValueComboBox_2->clear();
m_ui.categoryValueComboBox_3->clear();
m_ui.categoryValueComboBox_4->clear();
m_ui.categoryTypeComboBox_1->addItems(listCategories);
m_ui.categoryTypeComboBox_2->addItems(listCategories);
m_ui.categoryTypeComboBox_3->addItems(listCategories);
m_ui.categoryTypeComboBox_4->addItems(listCategories);
disableSignals(false);
m_listZonesModel->rebuildModel(m_zoneBuilder->pixmapDatabase());
}
QString ListZonesWidget::currentZoneName()
{
QString zoneName = "";
QModelIndex index = m_ui.listView->currentIndex();
if (index.isValid())
zoneName = index.data().toString();
if (m_ui.zoneSelectComboBox->currentIndex() == 1)
{
// Random value
if (m_listSelection.size() > 0)
{
uint32 randZone = uint32(NLMISC::frand(m_listSelection.size()));
NLMISC::clamp(randZone, (uint32)0, uint32(m_listSelection.size() - 1));
zoneName = m_listSelection[randZone];
}
}
else if (m_ui.zoneSelectComboBox->currentIndex() == 2)
{
// Full cycle
if (m_listSelection.size() > 0)
{
zoneName = m_listSelection[m_zoneNameCycle];
m_zoneNameCycle++;
m_zoneNameCycle = m_zoneNameCycle % m_listSelection.size();
}
}
return zoneName;
}
int ListZonesWidget::currentRot()
{
int rot = m_ui.rotComboBox->currentIndex();
if (rot == 4)
{
// Random value
uint32 randRot = uint32(NLMISC::frand(4.0));
NLMISC::clamp(randRot, (uint32)0, (uint32)3);
rot = int(randRot);
}
else if (rot == 5)
{
// Full cycle
rot = m_rotCycle;
m_rotCycle++;
m_rotCycle = m_rotCycle % 4;
}
return rot;
}
int ListZonesWidget::currentFlip()
{
int flip = m_ui.flipComboBox->currentIndex();
if (flip == 2)
{
// Random value
uint32 randFlip = uint32(NLMISC::frand(2.0));
NLMISC::clamp (randFlip, (uint32)0, (uint32)1);
flip = int(randFlip);
}
else if (flip == 3)
{
// Full cycle
flip = m_flipCycle;
m_flipCycle++;
m_flipCycle = m_flipCycle % 2;
}
return flip;
}
bool ListZonesWidget::isNotPropogate() const
{
return m_ui.propogateCheckBox->isChecked();
}
bool ListZonesWidget::isForce() const
{
return m_ui.forceCheckBox->isChecked();
}
void ListZonesWidget::setZoneBuilder(ZoneBuilder *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
void ListZonesWidget::updateFilters_1(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_1->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_1->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_2(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_2->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_2->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_3(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_3->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_3->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_4(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_4->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_4->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateListZones()
{
// Execute the filter
NLLIGO::CZoneBank &zoneBank = m_zoneBuilder->getZoneBank();
zoneBank.resetSelection ();
if(m_ui.categoryTypeComboBox_1->currentIndex() > 0 )
zoneBank.addOrSwitch (m_ui.categoryTypeComboBox_1->currentText().toStdString()
, m_ui.categoryValueComboBox_1->currentText().toStdString());
if(m_ui.categoryTypeComboBox_2->currentIndex() > 0 )
{
if (m_ui.logicComboBox_2->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_2->currentText().toStdString()
,m_ui.categoryValueComboBox_2->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_2->currentText().toStdString()
,m_ui.categoryValueComboBox_2->currentText().toStdString());
}
if(m_ui.categoryTypeComboBox_3->currentIndex() > 0 )
{
if (m_ui.logicComboBox_3->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_3->currentText().toStdString()
,m_ui.categoryValueComboBox_3->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_3->currentText().toStdString()
,m_ui.categoryValueComboBox_3->currentText().toStdString());
}
if(m_ui.categoryTypeComboBox_4->currentIndex() > 0 )
{
if (m_ui.logicComboBox_4->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_4->currentText().toStdString()
,m_ui.categoryValueComboBox_4->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_4->currentText().toStdString()
,m_ui.categoryValueComboBox_4->currentText().toStdString());
}
std::vector<NLLIGO::CZoneBankElement *> currentSelection;
zoneBank.getSelection (currentSelection);
m_listSelection.clear();
m_zoneNameCycle = 0;
for (size_t i = 0; i < currentSelection.size(); ++i)
m_listSelection << currentSelection[i]->getName().c_str();
m_listZonesModel->setListZones(m_listSelection);
}
void ListZonesWidget::disableSignals(bool block)
{
m_ui.categoryTypeComboBox_1->blockSignals(block);
m_ui.categoryTypeComboBox_2->blockSignals(block);
m_ui.categoryTypeComboBox_3->blockSignals(block);
m_ui.categoryTypeComboBox_4->blockSignals(block);
m_ui.categoryValueComboBox_1->blockSignals(block);
m_ui.categoryValueComboBox_2->blockSignals(block);
m_ui.categoryValueComboBox_3->blockSignals(block);
m_ui.categoryValueComboBox_4->blockSignals(block);
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "list_zones_widget.h"
#include "list_zones_model.h"
#include "builder_zone.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/zone_bank.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <vector>
#include <string>
// Qt includes
#include <QtGui/QIcon>
#include <QtCore/QModelIndex>
namespace LandscapeEditor
{
ListZonesWidget::ListZonesWidget(QWidget *parent)
: QWidget(parent),
m_rotCycle(0),
m_flipCycle(0),
m_listZonesModel(0),
m_zoneBuilder(0)
{
m_ui.setupUi(this);
m_listZonesModel = new ListZonesModel(4, this);
m_ui.listView->setModel(m_listZonesModel);
m_ui.addFilterButton_1->setChecked(false);
m_ui.addFilterButton_2->setChecked(false);
m_ui.addFilterButton_3->setChecked(false);
connect(m_ui.categoryTypeComboBox_1, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_1(QString)));
connect(m_ui.categoryTypeComboBox_2, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_2(QString)));
connect(m_ui.categoryTypeComboBox_3, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_3(QString)));
connect(m_ui.categoryTypeComboBox_4, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateFilters_4(QString)));
connect(m_ui.categoryValueComboBox_1, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_2, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_3, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.categoryValueComboBox_4, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_2, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_3, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
connect(m_ui.logicComboBox_4, SIGNAL(currentIndexChanged(int)), this, SLOT(updateListZones()));
}
ListZonesWidget::~ListZonesWidget()
{
}
void ListZonesWidget::updateUi()
{
if (m_zoneBuilder == 0)
return;
disableSignals(true);
std::vector<std::string> listCategoryType;
m_zoneBuilder->getZoneBank().getCategoriesType(listCategoryType);
QStringList listCategories;
listCategories << STRING_UNUSED;
for (size_t i = 0; i < listCategoryType.size(); ++i)
listCategories << QString(listCategoryType[i].c_str());
m_ui.categoryTypeComboBox_1->clear();
m_ui.categoryTypeComboBox_2->clear();
m_ui.categoryTypeComboBox_3->clear();
m_ui.categoryTypeComboBox_4->clear();
m_ui.categoryValueComboBox_1->clear();
m_ui.categoryValueComboBox_2->clear();
m_ui.categoryValueComboBox_3->clear();
m_ui.categoryValueComboBox_4->clear();
m_ui.categoryTypeComboBox_1->addItems(listCategories);
m_ui.categoryTypeComboBox_2->addItems(listCategories);
m_ui.categoryTypeComboBox_3->addItems(listCategories);
m_ui.categoryTypeComboBox_4->addItems(listCategories);
disableSignals(false);
m_listZonesModel->rebuildModel(m_zoneBuilder->pixmapDatabase());
}
QString ListZonesWidget::currentZoneName()
{
QString zoneName = "";
QModelIndex index = m_ui.listView->currentIndex();
if (index.isValid())
zoneName = index.data().toString();
if (m_ui.zoneSelectComboBox->currentIndex() == 1)
{
// Random value
if (m_listSelection.size() > 0)
{
uint32 randZone = uint32(NLMISC::frand(m_listSelection.size()));
NLMISC::clamp(randZone, (uint32)0, uint32(m_listSelection.size() - 1));
zoneName = m_listSelection[randZone];
}
}
else if (m_ui.zoneSelectComboBox->currentIndex() == 2)
{
// Full cycle
if (m_listSelection.size() > 0)
{
zoneName = m_listSelection[m_zoneNameCycle];
m_zoneNameCycle++;
m_zoneNameCycle = m_zoneNameCycle % m_listSelection.size();
}
}
return zoneName;
}
int ListZonesWidget::currentRot()
{
int rot = m_ui.rotComboBox->currentIndex();
if (rot == 4)
{
// Random value
uint32 randRot = uint32(NLMISC::frand(4.0));
NLMISC::clamp(randRot, (uint32)0, (uint32)3);
rot = int(randRot);
}
else if (rot == 5)
{
// Full cycle
rot = m_rotCycle;
m_rotCycle++;
m_rotCycle = m_rotCycle % 4;
}
return rot;
}
int ListZonesWidget::currentFlip()
{
int flip = m_ui.flipComboBox->currentIndex();
if (flip == 2)
{
// Random value
uint32 randFlip = uint32(NLMISC::frand(2.0));
NLMISC::clamp (randFlip, (uint32)0, (uint32)1);
flip = int(randFlip);
}
else if (flip == 3)
{
// Full cycle
flip = m_flipCycle;
m_flipCycle++;
m_flipCycle = m_flipCycle % 2;
}
return flip;
}
bool ListZonesWidget::isNotPropogate() const
{
return m_ui.propogateCheckBox->isChecked();
}
bool ListZonesWidget::isForce() const
{
return m_ui.forceCheckBox->isChecked();
}
void ListZonesWidget::setZoneBuilder(ZoneBuilder *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
void ListZonesWidget::updateFilters_1(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_1->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_1->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_2(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_2->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_2->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_3(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_3->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_3->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateFilters_4(const QString &value)
{
disableSignals(true);
std::vector<std::string> allCategoryValues;
m_zoneBuilder->getZoneBank().getCategoryValues(value.toStdString(), allCategoryValues);
m_ui.categoryValueComboBox_4->clear();
for(size_t i = 0; i < allCategoryValues.size(); ++i)
m_ui.categoryValueComboBox_4->addItem(QString(allCategoryValues[i].c_str()));
disableSignals(false);
updateListZones();
}
void ListZonesWidget::updateListZones()
{
// Execute the filter
NLLIGO::CZoneBank &zoneBank = m_zoneBuilder->getZoneBank();
zoneBank.resetSelection ();
if(m_ui.categoryTypeComboBox_1->currentIndex() > 0 )
zoneBank.addOrSwitch (m_ui.categoryTypeComboBox_1->currentText().toStdString()
, m_ui.categoryValueComboBox_1->currentText().toStdString());
if(m_ui.categoryTypeComboBox_2->currentIndex() > 0 )
{
if (m_ui.logicComboBox_2->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_2->currentText().toStdString()
,m_ui.categoryValueComboBox_2->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_2->currentText().toStdString()
,m_ui.categoryValueComboBox_2->currentText().toStdString());
}
if(m_ui.categoryTypeComboBox_3->currentIndex() > 0 )
{
if (m_ui.logicComboBox_3->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_3->currentText().toStdString()
,m_ui.categoryValueComboBox_3->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_3->currentText().toStdString()
,m_ui.categoryValueComboBox_3->currentText().toStdString());
}
if(m_ui.categoryTypeComboBox_4->currentIndex() > 0 )
{
if (m_ui.logicComboBox_4->currentIndex() == 0) // AND switch wanted
zoneBank.addAndSwitch(m_ui.categoryTypeComboBox_4->currentText().toStdString()
,m_ui.categoryValueComboBox_4->currentText().toStdString());
else // OR switch wanted
zoneBank.addOrSwitch(m_ui.categoryTypeComboBox_4->currentText().toStdString()
,m_ui.categoryValueComboBox_4->currentText().toStdString());
}
std::vector<NLLIGO::CZoneBankElement *> currentSelection;
zoneBank.getSelection (currentSelection);
m_listSelection.clear();
m_zoneNameCycle = 0;
for (size_t i = 0; i < currentSelection.size(); ++i)
m_listSelection << currentSelection[i]->getName().c_str();
m_listZonesModel->setListZones(m_listSelection);
}
void ListZonesWidget::disableSignals(bool block)
{
m_ui.categoryTypeComboBox_1->blockSignals(block);
m_ui.categoryTypeComboBox_2->blockSignals(block);
m_ui.categoryTypeComboBox_3->blockSignals(block);
m_ui.categoryTypeComboBox_4->blockSignals(block);
m_ui.categoryValueComboBox_1->blockSignals(block);
m_ui.categoryValueComboBox_2->blockSignals(block);
m_ui.categoryValueComboBox_3->blockSignals(block);
m_ui.categoryValueComboBox_4->blockSignals(block);
}
} /* namespace LandscapeEditor */

18
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/ovqt_plugin_landscape_editor.xml
View file

@ -1,10 +1,10 @@
<plugin-spec>
<library-name>ovqt_plugin_landscape_editor</library-name>
<name>LandscapeEditor</name>
<version>0.8</version>
<vendor>GSoC2011_dnk-88</vendor>
<description>Landscape editor ovqt plugin.</description>
<dependencies>
<dependency plugin-name="Core" version="0.8"/>
</dependencies>
<plugin-spec>
<library-name>ovqt_plugin_landscape_editor</library-name>
<name>LandscapeEditor</name>
<version>0.8</version>
<vendor>GSoC2011_dnk-88</vendor>
<description>Landscape editor ovqt plugin.</description>
<dependencies>
<dependency plugin-name="Core" version="0.8"/>
</dependencies>
</plugin-spec>

308
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/pixmap_database.cpp
View file

@ -1,154 +1,154 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <vector>
#include <string>
// Qt includes
#include <QtCore/QDir>
#include <QtGui/QPainter>
#include <QtGui/QMessageBox>
#include <QtGui/QApplication>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
PixmapDatabase::PixmapDatabase(int textureSize)
: m_textureSize(textureSize),
m_errorPixmap(0)
{
// Create pixmap for case if pixmap and LIGO files not found
m_errorPixmap = new QPixmap(QSize(m_textureSize, m_textureSize));
QPainter painter(m_errorPixmap);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(m_errorPixmap->rect(), QBrush(QColor(Qt::black)));
painter.setFont(QFont("Helvetica [Cronyx]", 14));
painter.setPen(QPen(Qt::red, 2, Qt::SolidLine));
painter.drawText(m_errorPixmap->rect(), Qt::AlignCenter | Qt::TextWordWrap,
QObject::tr("Pixmap and LIGO files not found."));
painter.end();
}
PixmapDatabase::~PixmapDatabase()
{
delete m_errorPixmap;
reset();
}
bool PixmapDatabase::loadPixmaps(const QString &zonePath, NLLIGO::CZoneBank &zoneBank, bool displayProgress)
{
QProgressDialog *progressDialog;
std::vector<std::string> listNames;
zoneBank.getCategoryValues ("zone", listNames);
if (displayProgress)
{
progressDialog = new QProgressDialog(QObject::tr("Loading ligo zones."), QObject::tr("Cancel"), 0, listNames.size());
progressDialog->show();
}
for (uint i = 0; i < listNames.size(); ++i)
{
QApplication::processEvents();
if (displayProgress)
progressDialog->setValue(i);
NLLIGO::CZoneBankElement *zoneBankItem = zoneBank.getElementByZoneName (listNames[i]);
// Read the texture file
QString zonePixmapName(listNames[i].c_str());
uint8 sizeX = zoneBankItem->getSizeX();
uint8 sizeY = zoneBankItem->getSizeY();
QPixmap *pixmap = new QPixmap(zonePath + zonePixmapName + ".png");
if (pixmap->isNull())
{
// Generate filled pixmap if could not load pixmap
QPixmap *emptyPixmap = new QPixmap(QSize(sizeX * m_textureSize, sizeY * m_textureSize));
QPainter painter(emptyPixmap);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(emptyPixmap->rect(), QBrush(QColor(Qt::black)));
painter.setFont(QFont("Helvetica [Cronyx]", 18));
painter.setPen(QPen(Qt::red, 2, Qt::SolidLine));
painter.drawText(emptyPixmap->rect(), Qt::AlignCenter, QObject::tr("Pixmap not found"));
painter.end();
delete pixmap;
m_pixmapMap.insert(zonePixmapName, emptyPixmap);
nlwarning(QString("not found " + zonePath + zonePixmapName + ".png").toStdString().c_str());
}
// All pixmaps must be have same size
else if (pixmap->width() != sizeX * m_textureSize)
{
QPixmap *scaledPixmap = new QPixmap(pixmap->scaled(sizeX * m_textureSize, sizeY * m_textureSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
delete pixmap;
m_pixmapMap.insert(zonePixmapName, scaledPixmap);
}
else
m_pixmapMap.insert(zonePixmapName, pixmap);
}
QPixmap *pixmap = new QPixmap(zonePath + "_unused_.png");
QPixmap *scaledPixmap = new QPixmap(pixmap->scaled(m_textureSize, m_textureSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
delete pixmap;
m_pixmapMap.insert(QString(STRING_UNUSED), scaledPixmap);
if (displayProgress)
delete progressDialog;
return true;
}
void PixmapDatabase::reset()
{
QStringList listNames(m_pixmapMap.keys());
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = m_pixmapMap.value(name);
delete pixmap;
}
m_pixmapMap.clear();
}
QStringList PixmapDatabase::listPixmaps() const
{
return m_pixmapMap.keys();
}
QPixmap *PixmapDatabase::pixmap(const QString &zoneName) const
{
QPixmap *result = m_errorPixmap;
if (!m_pixmapMap.contains(zoneName))
nlwarning("QPixmap %s not found", zoneName.toStdString().c_str());
else
result = m_pixmapMap.value(zoneName);
return result;
}
int PixmapDatabase::textureSize() const
{
return m_textureSize;
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "pixmap_database.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/zone_region.h>
// STL includes
#include <vector>
#include <string>
// Qt includes
#include <QtCore/QDir>
#include <QtGui/QPainter>
#include <QtGui/QMessageBox>
#include <QtGui/QApplication>
#include <QtGui/QProgressDialog>
namespace LandscapeEditor
{
PixmapDatabase::PixmapDatabase(int textureSize)
: m_textureSize(textureSize),
m_errorPixmap(0)
{
// Create pixmap for case if pixmap and LIGO files not found
m_errorPixmap = new QPixmap(QSize(m_textureSize, m_textureSize));
QPainter painter(m_errorPixmap);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(m_errorPixmap->rect(), QBrush(QColor(Qt::black)));
painter.setFont(QFont("Helvetica [Cronyx]", 14));
painter.setPen(QPen(Qt::red, 2, Qt::SolidLine));
painter.drawText(m_errorPixmap->rect(), Qt::AlignCenter | Qt::TextWordWrap,
QObject::tr("Pixmap and LIGO files not found."));
painter.end();
}
PixmapDatabase::~PixmapDatabase()
{
delete m_errorPixmap;
reset();
}
bool PixmapDatabase::loadPixmaps(const QString &zonePath, NLLIGO::CZoneBank &zoneBank, bool displayProgress)
{
QProgressDialog *progressDialog;
std::vector<std::string> listNames;
zoneBank.getCategoryValues ("zone", listNames);
if (displayProgress)
{
progressDialog = new QProgressDialog(QObject::tr("Loading ligo zones."), QObject::tr("Cancel"), 0, listNames.size());
progressDialog->show();
}
for (uint i = 0; i < listNames.size(); ++i)
{
QApplication::processEvents();
if (displayProgress)
progressDialog->setValue(i);
NLLIGO::CZoneBankElement *zoneBankItem = zoneBank.getElementByZoneName (listNames[i]);
// Read the texture file
QString zonePixmapName(listNames[i].c_str());
uint8 sizeX = zoneBankItem->getSizeX();
uint8 sizeY = zoneBankItem->getSizeY();
QPixmap *pixmap = new QPixmap(zonePath + zonePixmapName + ".png");
if (pixmap->isNull())
{
// Generate filled pixmap if could not load pixmap
QPixmap *emptyPixmap = new QPixmap(QSize(sizeX * m_textureSize, sizeY * m_textureSize));
QPainter painter(emptyPixmap);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(emptyPixmap->rect(), QBrush(QColor(Qt::black)));
painter.setFont(QFont("Helvetica [Cronyx]", 18));
painter.setPen(QPen(Qt::red, 2, Qt::SolidLine));
painter.drawText(emptyPixmap->rect(), Qt::AlignCenter, QObject::tr("Pixmap not found"));
painter.end();
delete pixmap;
m_pixmapMap.insert(zonePixmapName, emptyPixmap);
nlwarning(QString("not found " + zonePath + zonePixmapName + ".png").toStdString().c_str());
}
// All pixmaps must be have same size
else if (pixmap->width() != sizeX * m_textureSize)
{
QPixmap *scaledPixmap = new QPixmap(pixmap->scaled(sizeX * m_textureSize, sizeY * m_textureSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
delete pixmap;
m_pixmapMap.insert(zonePixmapName, scaledPixmap);
}
else
m_pixmapMap.insert(zonePixmapName, pixmap);
}
QPixmap *pixmap = new QPixmap(zonePath + "_unused_.png");
QPixmap *scaledPixmap = new QPixmap(pixmap->scaled(m_textureSize, m_textureSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
delete pixmap;
m_pixmapMap.insert(QString(STRING_UNUSED), scaledPixmap);
if (displayProgress)
delete progressDialog;
return true;
}
void PixmapDatabase::reset()
{
QStringList listNames(m_pixmapMap.keys());
Q_FOREACH(QString name, listNames)
{
QPixmap *pixmap = m_pixmapMap.value(name);
delete pixmap;
}
m_pixmapMap.clear();
}
QStringList PixmapDatabase::listPixmaps() const
{
return m_pixmapMap.keys();
}
QPixmap *PixmapDatabase::pixmap(const QString &zoneName) const
{
QPixmap *result = m_errorPixmap;
if (!m_pixmapMap.contains(zoneName))
nlwarning("QPixmap %s not found", zoneName.toStdString().c_str());
else
result = m_pixmapMap.value(zoneName);
return result;
}
int PixmapDatabase::textureSize() const
{
return m_textureSize;
}
} /* namespace LandscapeEditor */

120
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/project_settings_dialog.cpp
View file

@ -1,60 +1,60 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "project_settings_dialog.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QFileDialog>
namespace LandscapeEditor
{
ProjectSettingsDialog::ProjectSettingsDialog(const QString &dataPath, QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
m_ui.pathLineEdit->setText(dataPath);
setFixedHeight(sizeHint().height());
connect(m_ui.selectPathButton, SIGNAL(clicked()), this, SLOT(selectPath()));
}
ProjectSettingsDialog::~ProjectSettingsDialog()
{
}
QString ProjectSettingsDialog::dataPath() const
{
return m_ui.pathLineEdit->text();
}
void ProjectSettingsDialog::selectPath()
{
QString dataPath = QFileDialog::getExistingDirectory(this, tr("Select data path"), m_ui.pathLineEdit->text());
if (!dataPath.isEmpty())
m_ui.pathLineEdit->setText(dataPath);
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "project_settings_dialog.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QFileDialog>
namespace LandscapeEditor
{
ProjectSettingsDialog::ProjectSettingsDialog(const QString &dataPath, QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
m_ui.pathLineEdit->setText(dataPath);
setFixedHeight(sizeHint().height());
connect(m_ui.selectPathButton, SIGNAL(clicked()), this, SLOT(selectPath()));
}
ProjectSettingsDialog::~ProjectSettingsDialog()
{
}
QString ProjectSettingsDialog::dataPath() const
{
return m_ui.pathLineEdit->text();
}
void ProjectSettingsDialog::selectPath()
{
QString dataPath = QFileDialog::getExistingDirectory(this, tr("Select data path"), m_ui.pathLineEdit->text());
if (!dataPath.isEmpty())
m_ui.pathLineEdit->setText(dataPath);
}
} /* namespace LandscapeEditor */

140
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/snapshot_dialog.cpp
View file

@ -1,70 +1,70 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "snapshot_dialog.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
namespace LandscapeEditor
{
SnapshotDialog::SnapshotDialog(QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
setFixedHeight(sizeHint().height());
}
SnapshotDialog::~SnapshotDialog()
{
}
bool SnapshotDialog::isCustomSize() const
{
return m_ui.customSizeRadioButton->isChecked();
}
bool SnapshotDialog::isKeepRatio() const
{
return m_ui.keepRatioCheckBox->isChecked();
}
int SnapshotDialog::resolutionZone() const
{
return m_ui.resSpinBox->value();
}
int SnapshotDialog::widthSnapshot() const
{
return m_ui.widthSpinBox->value();
}
int SnapshotDialog::heightSnapshot() const
{
return m_ui.heightSpinBox->value();
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "snapshot_dialog.h"
#include "landscape_editor_constants.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
namespace LandscapeEditor
{
SnapshotDialog::SnapshotDialog(QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
setFixedHeight(sizeHint().height());
}
SnapshotDialog::~SnapshotDialog()
{
}
bool SnapshotDialog::isCustomSize() const
{
return m_ui.customSizeRadioButton->isChecked();
}
bool SnapshotDialog::isKeepRatio() const
{
return m_ui.keepRatioCheckBox->isChecked();
}
int SnapshotDialog::resolutionZone() const
{
return m_ui.resSpinBox->value();
}
int SnapshotDialog::widthSnapshot() const
{
return m_ui.widthSpinBox->value();
}
int SnapshotDialog::heightSnapshot() const
{
return m_ui.heightSpinBox->value();
}
} /* namespace LandscapeEditor */

362
code/nel/tools/3d/object_viewer_qt/src/plugins/landscape_editor/zone_region_editor.cpp
View file

@ -1,181 +1,181 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "zone_region_editor.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/misc/file.h>
#include <nel/misc/i_xml.h>
#include <nel/misc/o_xml.h>
// Qt includes
#include <QtGui/QMessageBox>
namespace LandscapeEditor
{
ZoneRegionObject::ZoneRegionObject()
{
m_fileName = "";
}
ZoneRegionObject::~ZoneRegionObject()
{
}
bool ZoneRegionObject::load(const std::string &fileName)
{
bool result = true;
try
{
// Open it
NLMISC::CIFile fileIn;
if (fileIn.open(fileName))
{
NLMISC::CIXml xml(true);
xml.init(fileIn);
m_zoneRegion.serial(xml);
}
else
{
nlwarning("Can't open file %s for reading", fileName.c_str());
result = false;
}
}
catch (NLMISC::Exception &e)
{
nlwarning("Error reading file %s : %s", fileName.c_str(), e.what ());
result = false;
}
if (result)
m_fileName = fileName;
return result;
}
bool ZoneRegionObject::save()
{
if (m_fileName.empty())
return false;
bool result = true;
// Save the landscape
try
{
// Open file for writing
NLMISC::COFile fileOut;
if (fileOut.open(m_fileName, false, false, true))
{
// Be careful with the flushing of the COXml object
{
NLMISC::COXml xmlOut;
xmlOut.init(&fileOut);
m_zoneRegion.serial(xmlOut);
// Done
m_modified = false;
}
fileOut.close();
}
else
{
nlwarning("Can't open file %s for writing.", m_fileName.c_str());
result = false;
}
}
catch (NLMISC::Exception &e)
{
nlwarning("Error writing file %s : %s", m_fileName.c_str(), e.what());
result = false;
}
return result;
}
std::string ZoneRegionObject::fileName() const
{
return m_fileName;
}
void ZoneRegionObject::setFileName(const std::string &fileName)
{
m_fileName = fileName;
}
void ZoneRegionObject::ligoData(LigoData &data, const sint32 x, const sint32 y)
{
data.posX = m_zoneRegion.getPosX(x, y);
data.posY = m_zoneRegion.getPosY(x, y);
data.zoneName = m_zoneRegion.getName(x, y);
data.rot = m_zoneRegion.getRot(x, y);
data.flip = m_zoneRegion.getFlip(x, y);
data.sharingMatNames[0] = m_zoneRegion.getSharingMatNames(x, y, 0);
data.sharingMatNames[1] = m_zoneRegion.getSharingMatNames(x, y, 1);
data.sharingMatNames[2] = m_zoneRegion.getSharingMatNames(x, y, 2);
data.sharingMatNames[3] = m_zoneRegion.getSharingMatNames(x, y, 3);
data.sharingCutEdges[0] = m_zoneRegion.getSharingCutEdges(x, y, 0);
data.sharingCutEdges[1] = m_zoneRegion.getSharingCutEdges(x, y, 1);
data.sharingCutEdges[2] = m_zoneRegion.getSharingCutEdges(x, y, 2);
data.sharingCutEdges[3] = m_zoneRegion.getSharingCutEdges(x, y, 3);
}
void ZoneRegionObject::setLigoData(const LigoData &data, const sint32 x, const sint32 y)
{
m_zoneRegion.setPosX(x, y, data.posX);
m_zoneRegion.setPosY(x, y, data.posY);
m_zoneRegion.setName(x, y, data.zoneName);
m_zoneRegion.setRot(x, y, data.rot);
m_zoneRegion.setFlip(x, y, data.flip);
m_zoneRegion.setSharingMatNames(x, y, 0, data.sharingMatNames[0]);
m_zoneRegion.setSharingMatNames(x, y, 1, data.sharingMatNames[1]);
m_zoneRegion.setSharingMatNames(x, y, 2, data.sharingMatNames[2]);
m_zoneRegion.setSharingMatNames(x, y, 3, data.sharingMatNames[3]);
m_zoneRegion.setSharingCutEdges(x, y, 0, data.sharingCutEdges[0]);
m_zoneRegion.setSharingCutEdges(x, y, 1, data.sharingCutEdges[1]);
m_zoneRegion.setSharingCutEdges(x, y, 2, data.sharingCutEdges[2]);
m_zoneRegion.setSharingCutEdges(x, y, 3, data.sharingCutEdges[3]);
}
NLLIGO::CZoneRegion &ZoneRegionObject::ligoZoneRegion()
{
return m_zoneRegion;
}
void ZoneRegionObject::setLigoZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
m_zoneRegion = zoneRegion;
}
bool ZoneRegionObject::checkPos(const sint32 x, const sint32 y)
{
return ((x >= m_zoneRegion.getMinX()) &&
(x <= m_zoneRegion.getMaxX()) &&
(y >= m_zoneRegion.getMinY()) &&
(y <= m_zoneRegion.getMaxY()));
}
bool ZoneRegionObject::isModified() const
{
return m_modified;
}
void ZoneRegionObject::setModified(bool modified)
{
m_modified = modified;
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "zone_region_editor.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/misc/file.h>
#include <nel/misc/i_xml.h>
#include <nel/misc/o_xml.h>
// Qt includes
#include <QtGui/QMessageBox>
namespace LandscapeEditor
{
ZoneRegionObject::ZoneRegionObject()
{
m_fileName = "";
}
ZoneRegionObject::~ZoneRegionObject()
{
}
bool ZoneRegionObject::load(const std::string &fileName)
{
bool result = true;
try
{
// Open it
NLMISC::CIFile fileIn;
if (fileIn.open(fileName))
{
NLMISC::CIXml xml(true);
xml.init(fileIn);
m_zoneRegion.serial(xml);
}
else
{
nlwarning("Can't open file %s for reading", fileName.c_str());
result = false;
}
}
catch (NLMISC::Exception &e)
{
nlwarning("Error reading file %s : %s", fileName.c_str(), e.what ());
result = false;
}
if (result)
m_fileName = fileName;
return result;
}
bool ZoneRegionObject::save()
{
if (m_fileName.empty())
return false;
bool result = true;
// Save the landscape
try
{
// Open file for writing
NLMISC::COFile fileOut;
if (fileOut.open(m_fileName, false, false, true))
{
// Be careful with the flushing of the COXml object
{
NLMISC::COXml xmlOut;
xmlOut.init(&fileOut);
m_zoneRegion.serial(xmlOut);
// Done
m_modified = false;
}
fileOut.close();
}
else
{
nlwarning("Can't open file %s for writing.", m_fileName.c_str());
result = false;
}
}
catch (NLMISC::Exception &e)
{
nlwarning("Error writing file %s : %s", m_fileName.c_str(), e.what());
result = false;
}
return result;
}
std::string ZoneRegionObject::fileName() const
{
return m_fileName;
}
void ZoneRegionObject::setFileName(const std::string &fileName)
{
m_fileName = fileName;
}
void ZoneRegionObject::ligoData(LigoData &data, const sint32 x, const sint32 y)
{
data.posX = m_zoneRegion.getPosX(x, y);
data.posY = m_zoneRegion.getPosY(x, y);
data.zoneName = m_zoneRegion.getName(x, y);
data.rot = m_zoneRegion.getRot(x, y);
data.flip = m_zoneRegion.getFlip(x, y);
data.sharingMatNames[0] = m_zoneRegion.getSharingMatNames(x, y, 0);
data.sharingMatNames[1] = m_zoneRegion.getSharingMatNames(x, y, 1);
data.sharingMatNames[2] = m_zoneRegion.getSharingMatNames(x, y, 2);
data.sharingMatNames[3] = m_zoneRegion.getSharingMatNames(x, y, 3);
data.sharingCutEdges[0] = m_zoneRegion.getSharingCutEdges(x, y, 0);
data.sharingCutEdges[1] = m_zoneRegion.getSharingCutEdges(x, y, 1);
data.sharingCutEdges[2] = m_zoneRegion.getSharingCutEdges(x, y, 2);
data.sharingCutEdges[3] = m_zoneRegion.getSharingCutEdges(x, y, 3);
}
void ZoneRegionObject::setLigoData(const LigoData &data, const sint32 x, const sint32 y)
{
m_zoneRegion.setPosX(x, y, data.posX);
m_zoneRegion.setPosY(x, y, data.posY);
m_zoneRegion.setName(x, y, data.zoneName);
m_zoneRegion.setRot(x, y, data.rot);
m_zoneRegion.setFlip(x, y, data.flip);
m_zoneRegion.setSharingMatNames(x, y, 0, data.sharingMatNames[0]);
m_zoneRegion.setSharingMatNames(x, y, 1, data.sharingMatNames[1]);
m_zoneRegion.setSharingMatNames(x, y, 2, data.sharingMatNames[2]);
m_zoneRegion.setSharingMatNames(x, y, 3, data.sharingMatNames[3]);
m_zoneRegion.setSharingCutEdges(x, y, 0, data.sharingCutEdges[0]);
m_zoneRegion.setSharingCutEdges(x, y, 1, data.sharingCutEdges[1]);
m_zoneRegion.setSharingCutEdges(x, y, 2, data.sharingCutEdges[2]);
m_zoneRegion.setSharingCutEdges(x, y, 3, data.sharingCutEdges[3]);
}
NLLIGO::CZoneRegion &ZoneRegionObject::ligoZoneRegion()
{
return m_zoneRegion;
}
void ZoneRegionObject::setLigoZoneRegion(const NLLIGO::CZoneRegion &zoneRegion)
{
m_zoneRegion = zoneRegion;
}
bool ZoneRegionObject::checkPos(const sint32 x, const sint32 y)
{
return ((x >= m_zoneRegion.getMinX()) &&
(x <= m_zoneRegion.getMaxX()) &&
(y >= m_zoneRegion.getMinY()) &&
(y <= m_zoneRegion.getMaxY()));
}
bool ZoneRegionObject::isModified() const
{
return m_modified;
}
void ZoneRegionObject::setModified(bool modified)
{
m_modified = modified;
}
} /* namespace LandscapeEditor */

140
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/CMakeLists.txt
View file

@ -1,70 +1,70 @@
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES}
${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/qtpropertybrowser
)
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_PLUGIN_WORLD_EDITOR_HDR world_editor_plugin.h
world_editor_window.h
world_editor_scene.h
world_editor_scene_item.h
primitives_model.h
primitives_view.h
project_settings_dialog.h
property_editor_widget.h
world_editor_settings_page.h
)
SET(OVQT_PLUGIN_WORLD_EDITOR_UIS world_editor_window.ui
project_settings_dialog.ui
property_editor_widget.ui
world_editor_settings_page.ui
)
SET(OVQT_PLUGIN_WORLD_EDITOR_RCS world_editor.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS ${OVQT_PLUGIN_WORLD_EDITOR_RCS})
QT4_WRAP_CPP(OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC ${OVQT_PLUGIN_WORLD_EDITOR_HDR})
QT4_WRAP_UI(OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS ${OVQT_PLUGIN_WORLD_EDITOR_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_PLUGIN_WORLD_EDITOR_UIS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocQrcSrc FILES ${OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC} OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS)
SOURCE_GROUP("World Editor Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_world_editor MODULE ${SRC}
${OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC}
${OVQT_EXT_SYS_SRC}
${OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS}
${OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS})
TARGET_LINK_LIBRARIES( ovqt_plugin_world_editor
ovqt_plugin_core
ovqt_plugin_landscape_editor
nelmisc
nel3d
qt_property_browser
${QT_LIBRARIES}
${QT_QTOPENGL_LIBRARY}
)
NL_DEFAULT_PROPS(ovqt_plugin_world_editor "NeL, Tools, 3D: Object Viewer Qt Plugin: World Editor")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_world_editor)
NL_ADD_LIB_SUFFIX(ovqt_plugin_world_editor)
ADD_DEFINITIONS(-DWORLD_EDITOR_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
INSTALL(TARGETS ovqt_plugin_world_editor LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${NL_BIN_PREFIX} ARCHIVE DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_world_editor.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${LIBXML2_INCLUDE_DIR}
${QT_INCLUDES}
${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/qtpropertybrowser
)
FILE(GLOB SRC *.cpp *.h)
SET(OVQT_EXT_SYS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/../../extension_system/iplugin_spec.h)
SET(OVQT_PLUGIN_WORLD_EDITOR_HDR world_editor_plugin.h
world_editor_window.h
world_editor_scene.h
world_editor_scene_item.h
primitives_model.h
primitives_view.h
project_settings_dialog.h
property_editor_widget.h
world_editor_settings_page.h
)
SET(OVQT_PLUGIN_WORLD_EDITOR_UIS world_editor_window.ui
project_settings_dialog.ui
property_editor_widget.ui
world_editor_settings_page.ui
)
SET(OVQT_PLUGIN_WORLD_EDITOR_RCS world_editor.qrc)
SET(QT_USE_QTGUI TRUE)
SET(QT_USE_QTOPENGL TRUE)
QT4_ADD_RESOURCES(OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS ${OVQT_PLUGIN_WORLD_EDITOR_RCS})
QT4_WRAP_CPP(OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC ${OVQT_PLUGIN_WORLD_EDITOR_HDR})
QT4_WRAP_UI(OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS ${OVQT_PLUGIN_WORLD_EDITOR_UIS})
SOURCE_GROUP(QtResources FILES ${OVQT_PLUGIN_WORLD_EDITOR_UIS})
SOURCE_GROUP(QtGeneratedUiHdr FILES ${OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS})
SOURCE_GROUP(QtGeneratedMocQrcSrc FILES ${OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC} OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS)
SOURCE_GROUP("World Editor Plugin" FILES ${SRC})
SOURCE_GROUP("OVQT Extension System" FILES ${OVQT_EXT_SYS_SRC})
ADD_LIBRARY(ovqt_plugin_world_editor MODULE ${SRC}
${OVQT_PLUGIN_WORLD_EDITOR_MOC_SRC}
${OVQT_EXT_SYS_SRC}
${OVQT_PLUGIN_WORLD_EDITOR_UI_HDRS}
${OVQT_PLUGIN_WORLD_EDITOR_RC_SRCS})
TARGET_LINK_LIBRARIES( ovqt_plugin_world_editor
ovqt_plugin_core
ovqt_plugin_landscape_editor
nelmisc
nel3d
qt_property_browser
${QT_LIBRARIES}
${QT_QTOPENGL_LIBRARY}
)
NL_DEFAULT_PROPS(ovqt_plugin_world_editor "NeL, Tools, 3D: Object Viewer Qt Plugin: World Editor")
NL_ADD_RUNTIME_FLAGS(ovqt_plugin_world_editor)
NL_ADD_LIB_SUFFIX(ovqt_plugin_world_editor)
ADD_DEFINITIONS(-DWORLD_EDITOR_LIBRARY ${LIBXML2_DEFINITIONS} -DQT_PLUGIN -DQT_SHARED ${QT_DEFINITIONS})
INSTALL(TARGETS ovqt_plugin_world_editor LIBRARY DESTINATION ${OVQT_PLUGIN_DIR} RUNTIME DESTINATION ${NL_BIN_PREFIX} ARCHIVE DESTINATION ${OVQT_PLUGIN_DIR} COMPONENT tools3d)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/ovqt_plugin_world_editor.xml DESTINATION ${OVQT_PLUGIN_SPECS_DIR} COMPONENT tools3d)

20
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/ovqt_plugin_world_editor.xml
View file

@ -1,11 +1,11 @@
<plugin-spec>
<library-name>ovqt_plugin_world_editor</library-name>
<name>WorldEditor</name>
<version>0.6</version>
<vendor>GSoC2011_dnk-88</vendor>
<description>Landscape editor ovqt plugin.</description>
<dependencies>
<dependency plugin-name="Core" version="0.8"/>
<dependency plugin-name="LandscapeEditor" version="0.6"/>
</dependencies>
<plugin-spec>
<library-name>ovqt_plugin_world_editor</library-name>
<name>WorldEditor</name>
<version>0.6</version>
<vendor>GSoC2011_dnk-88</vendor>
<description>Landscape editor ovqt plugin.</description>
<dependencies>
<dependency plugin-name="Core" version="0.8"/>
<dependency plugin-name="LandscapeEditor" version="0.6"/>
</dependencies>
</plugin-spec>

624
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitive_item.cpp
View file

@ -1,312 +1,312 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitive_item.h"
#include "world_editor_misc.h"
#include "world_editor_constants.h"
#include "../landscape_editor/landscape_editor_constants.h"
// NeL includes
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QtCore/QStringList>
#include <QtCore/QFile>
namespace WorldEditor
{
Node::Node()
: m_parent(0)
{
setData(Constants::PRIMITIVE_IS_VISIBLE, true);
}
Node::~Node()
{
if (m_parent)
m_parent->removeChildNode(this);
qDeleteAll(m_children);
nlassert(m_children.isEmpty());
m_data.clear();
}
void Node::prependChildNode(Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.prepend(node);
node->m_parent = this;
}
void Node::appendChildNode(Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.append(node);
node->m_parent = this;
}
void Node::insertChildNodeBefore(Node *node, Node *before)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
int idx = before ? m_children.indexOf(before) : -1;
if (idx == -1)
m_children.append(node);
else
m_children.insert(idx, node);
node->m_parent = this;
}
void Node::insertChildNodeAfter(Node *node, Node *after)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
int idx = after ? m_children.indexOf(after) : -1;
if (idx == -1)
m_children.append(node);
else
m_children.insert(idx + 1, node);
node->m_parent = this;
}
void Node::insertChildNode(int pos, Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.insert(pos, node);
node->m_parent = this;
}
void Node::removeChildNode(Node *node)
{
nlassert(m_children.contains(node));
nlassert(node->parent() == this);
m_children.removeOne(node);
node->m_parent = 0;
}
Node *Node::child(int row)
{
return m_children.at(row);
}
int Node::childCount() const
{
return m_children.count();
}
QVariant Node::data(int key) const
{
return m_data[key];
}
void Node::setData(int key, const QVariant &data)
{
m_data[key] = data;
}
Node *Node::parent()
{
return m_parent;
}
int Node::row() const
{
if (m_parent)
return m_parent->m_children.indexOf(const_cast<Node *>(this));
return 0;
}
Node::NodeType Node::type() const
{
return BasicNodeType;
}
WorldEditNode::WorldEditNode(const QString &name)
{
setData(Qt::DisplayRole, name);
setData(Qt::DecorationRole, QIcon(Constants::ICON_WORLD_EDITOR));
}
WorldEditNode::~WorldEditNode()
{
}
void WorldEditNode::setContext(const QString &name)
{
m_context = name;
}
QString WorldEditNode::context() const
{
return m_context;
}
void WorldEditNode::setDataPath(const QString &path)
{
m_dataPath = path;
}
QString WorldEditNode::dataPath() const
{
return m_dataPath;
}
Node::NodeType WorldEditNode::type() const
{
return WorldEditNodeType;
}
LandscapeNode::LandscapeNode(const QString &name, int id)
: m_id(id),
m_fileName(name)
{
setData(Qt::DisplayRole, name);
setData(Qt::DecorationRole, QIcon(LandscapeEditor::Constants::ICON_ZONE_ITEM));
}
LandscapeNode::~LandscapeNode()
{
}
QString LandscapeNode::fileName() const
{
return m_fileName;
}
int LandscapeNode::id() const
{
return m_id;
}
Node::NodeType LandscapeNode::type() const
{
return LandscapeNodeType;
}
PrimitiveNode::PrimitiveNode(NLLIGO::IPrimitive *primitive)
: m_primitive(primitive)
{
setData(Qt::DisplayRole, QString(m_primitive->getName().c_str()));
setData(Qt::ToolTipRole, QString(m_primitive->getClassName().c_str()));
std::string className;
m_primitive->getPropertyByName("class", className);
// Set Icon
QString nameIcon = QString("%1/%2.ico").arg(Constants::PATH_TO_OLD_ICONS).arg(className.c_str());
QIcon icon(nameIcon);
if (!QFile::exists(nameIcon))
{
if (primitive->getParent() == NULL)
icon = QIcon(Constants::ICON_ROOT_PRIMITIVE);
else if (primitive->getNumChildren() == 0)
icon = QIcon(Constants::ICON_PROPERTY);
else
icon = QIcon(Constants::ICON_FOLDER);
}
setData(Qt::DecorationRole, icon);
}
PrimitiveNode::~PrimitiveNode()
{
}
NLLIGO::IPrimitive *PrimitiveNode::primitive() const
{
return m_primitive;
}
const NLLIGO::CPrimitiveClass *PrimitiveNode::primitiveClass() const
{
return Utils::ligoConfig()->getPrimitiveClass(*m_primitive);
}
RootPrimitiveNode *PrimitiveNode::rootPrimitiveNode()
{
Node *node = this;
while (node && (node->type() != Node::RootPrimitiveNodeType))
node = node->parent();
return static_cast<RootPrimitiveNode *>(node);
}
Node::NodeType PrimitiveNode::type() const
{
return PrimitiveNodeType;
}
RootPrimitiveNode::RootPrimitiveNode(const QString &name, NLLIGO::CPrimitives *primitives)
: PrimitiveNode(primitives->RootNode),
m_fileName(name),
m_primitives(primitives)
{
setData(Qt::DisplayRole, name);
}
RootPrimitiveNode::~RootPrimitiveNode()
{
}
NLLIGO::CPrimitives *RootPrimitiveNode::primitives() const
{
return m_primitives;
}
void RootPrimitiveNode::setFileName(const QString &fileName)
{
setData(Qt::DisplayRole, fileName);
m_fileName = fileName;
}
QString RootPrimitiveNode::fileName() const
{
return m_fileName;
}
Node::NodeType RootPrimitiveNode::type() const
{
return RootPrimitiveNodeType;
}
} /* namespace WorldEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitive_item.h"
#include "world_editor_misc.h"
#include "world_editor_constants.h"
#include "../landscape_editor/landscape_editor_constants.h"
// NeL includes
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QtCore/QStringList>
#include <QtCore/QFile>
namespace WorldEditor
{
Node::Node()
: m_parent(0)
{
setData(Constants::PRIMITIVE_IS_VISIBLE, true);
}
Node::~Node()
{
if (m_parent)
m_parent->removeChildNode(this);
qDeleteAll(m_children);
nlassert(m_children.isEmpty());
m_data.clear();
}
void Node::prependChildNode(Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.prepend(node);
node->m_parent = this;
}
void Node::appendChildNode(Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.append(node);
node->m_parent = this;
}
void Node::insertChildNodeBefore(Node *node, Node *before)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
int idx = before ? m_children.indexOf(before) : -1;
if (idx == -1)
m_children.append(node);
else
m_children.insert(idx, node);
node->m_parent = this;
}
void Node::insertChildNodeAfter(Node *node, Node *after)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
int idx = after ? m_children.indexOf(after) : -1;
if (idx == -1)
m_children.append(node);
else
m_children.insert(idx + 1, node);
node->m_parent = this;
}
void Node::insertChildNode(int pos, Node *node)
{
// Node is already a child
nlassert(!m_children.contains(node));
// Node already has a parent
nlassert(!m_children.contains(node));
m_children.insert(pos, node);
node->m_parent = this;
}
void Node::removeChildNode(Node *node)
{
nlassert(m_children.contains(node));
nlassert(node->parent() == this);
m_children.removeOne(node);
node->m_parent = 0;
}
Node *Node::child(int row)
{
return m_children.at(row);
}
int Node::childCount() const
{
return m_children.count();
}
QVariant Node::data(int key) const
{
return m_data[key];
}
void Node::setData(int key, const QVariant &data)
{
m_data[key] = data;
}
Node *Node::parent()
{
return m_parent;
}
int Node::row() const
{
if (m_parent)
return m_parent->m_children.indexOf(const_cast<Node *>(this));
return 0;
}
Node::NodeType Node::type() const
{
return BasicNodeType;
}
WorldEditNode::WorldEditNode(const QString &name)
{
setData(Qt::DisplayRole, name);
setData(Qt::DecorationRole, QIcon(Constants::ICON_WORLD_EDITOR));
}
WorldEditNode::~WorldEditNode()
{
}
void WorldEditNode::setContext(const QString &name)
{
m_context = name;
}
QString WorldEditNode::context() const
{
return m_context;
}
void WorldEditNode::setDataPath(const QString &path)
{
m_dataPath = path;
}
QString WorldEditNode::dataPath() const
{
return m_dataPath;
}
Node::NodeType WorldEditNode::type() const
{
return WorldEditNodeType;
}
LandscapeNode::LandscapeNode(const QString &name, int id)
: m_id(id),
m_fileName(name)
{
setData(Qt::DisplayRole, name);
setData(Qt::DecorationRole, QIcon(LandscapeEditor::Constants::ICON_ZONE_ITEM));
}
LandscapeNode::~LandscapeNode()
{
}
QString LandscapeNode::fileName() const
{
return m_fileName;
}
int LandscapeNode::id() const
{
return m_id;
}
Node::NodeType LandscapeNode::type() const
{
return LandscapeNodeType;
}
PrimitiveNode::PrimitiveNode(NLLIGO::IPrimitive *primitive)
: m_primitive(primitive)
{
setData(Qt::DisplayRole, QString(m_primitive->getName().c_str()));
setData(Qt::ToolTipRole, QString(m_primitive->getClassName().c_str()));
std::string className;
m_primitive->getPropertyByName("class", className);
// Set Icon
QString nameIcon = QString("%1/%2.ico").arg(Constants::PATH_TO_OLD_ICONS).arg(className.c_str());
QIcon icon(nameIcon);
if (!QFile::exists(nameIcon))
{
if (primitive->getParent() == NULL)
icon = QIcon(Constants::ICON_ROOT_PRIMITIVE);
else if (primitive->getNumChildren() == 0)
icon = QIcon(Constants::ICON_PROPERTY);
else
icon = QIcon(Constants::ICON_FOLDER);
}
setData(Qt::DecorationRole, icon);
}
PrimitiveNode::~PrimitiveNode()
{
}
NLLIGO::IPrimitive *PrimitiveNode::primitive() const
{
return m_primitive;
}
const NLLIGO::CPrimitiveClass *PrimitiveNode::primitiveClass() const
{
return Utils::ligoConfig()->getPrimitiveClass(*m_primitive);
}
RootPrimitiveNode *PrimitiveNode::rootPrimitiveNode()
{
Node *node = this;
while (node && (node->type() != Node::RootPrimitiveNodeType))
node = node->parent();
return static_cast<RootPrimitiveNode *>(node);
}
Node::NodeType PrimitiveNode::type() const
{
return PrimitiveNodeType;
}
RootPrimitiveNode::RootPrimitiveNode(const QString &name, NLLIGO::CPrimitives *primitives)
: PrimitiveNode(primitives->RootNode),
m_fileName(name),
m_primitives(primitives)
{
setData(Qt::DisplayRole, name);
}
RootPrimitiveNode::~RootPrimitiveNode()
{
}
NLLIGO::CPrimitives *RootPrimitiveNode::primitives() const
{
return m_primitives;
}
void RootPrimitiveNode::setFileName(const QString &fileName)
{
setData(Qt::DisplayRole, fileName);
m_fileName = fileName;
}
QString RootPrimitiveNode::fileName() const
{
return m_fileName;
}
Node::NodeType RootPrimitiveNode::type() const
{
return RootPrimitiveNodeType;
}
} /* namespace WorldEditor */

400
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitive_item.h
View file

@ -1,200 +1,200 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVE_ITEM_H
#define PRIMITIVE_ITEM_H
// Project includes
// NeL includes
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_class.h>
// Qt includes
#include <QList>
#include <QIcon>
#include <QVariant>
namespace WorldEditor
{
class RootPrimitiveNode;
/*
@class Node
@brief
@details
*/
class Node
{
public:
enum NodeType
{
BasicNodeType,
WorldEditNodeType,
RootPrimitiveNodeType,
LandscapeNodeType,
PrimitiveNodeType,
UserNodeType = 1024
};
Node();
virtual ~Node();
/// Remove child node from the child list.
void removeChildNode(Node *node);
/// Insert node at the beginning of the list.
void prependChildNode(Node *node);
/// Insert node at the end of the list.
void appendChildNode(Node *node);
/// Insert node in front of the node pointed to by the pointer before.
void insertChildNodeBefore(Node *node, Node *before);
/// Insert node in back of the node pointed to by the pointer after.
void insertChildNodeAfter(Node *node, Node *after);
/// Insert node in pos
void insertChildNode(int pos, Node *node);
/// Return the node at index position row in the child list.
Node *child(int row);
/// Return the number of nodes in the list.
int childCount() const;
/// Return a row index this node.
int row() const;
/// Return a pointer to this node's parent item. If this node does not have a parent, 0 is returned.
Node *parent();
/// Set this node's custom data for the key key to value.
void setData(int key, const QVariant &data);
/// Return this node's custom data for the key key as a QVariant.
QVariant data(int key) const;
/// Return a type this node.
virtual NodeType type() const;
private:
Q_DISABLE_COPY(Node)
Node *m_parent;
QList<Node *> m_children;
QHash<int, QVariant> m_data;
};
/*
@class WorldEditNode
@brief
@details
*/
class WorldEditNode: public Node
{
public:
WorldEditNode(const QString &name);
virtual ~WorldEditNode();
void setContext(const QString &name);
QString context() const;
void setDataPath(const QString &path);
QString dataPath() const;
virtual NodeType type() const;
private:
QString m_context;
QString m_dataPath;
};
/*
@class LandscapeNode
@brief
@details
*/
class LandscapeNode: public Node
{
public:
LandscapeNode(const QString &name, int id);
virtual ~LandscapeNode();
int id() const;
QString fileName() const;
virtual NodeType type() const;
private:
QString m_fileName;
int m_id;
};
/*
@class PrimitiveNode
@brief
@details
*/
class PrimitiveNode: public Node
{
public:
explicit PrimitiveNode(NLLIGO::IPrimitive *primitive);
virtual ~PrimitiveNode();
NLLIGO::IPrimitive *primitive() const;
const NLLIGO::CPrimitiveClass *primitiveClass() const;
RootPrimitiveNode *rootPrimitiveNode();
virtual NodeType type() const;
private:
NLLIGO::IPrimitive *m_primitive;
};
/*
@class RootPrimitiveNode
@brief
@details
*/
class RootPrimitiveNode: public PrimitiveNode
{
public:
RootPrimitiveNode(const QString &name, NLLIGO::CPrimitives *primitives);
virtual ~RootPrimitiveNode();
NLLIGO::CPrimitives *primitives() const;
void setFileName(const QString &fileName);
QString fileName() const;
virtual NodeType type() const;
private:
QString m_fileName;
NLLIGO::CPrimitives *m_primitives;
};
typedef QList<Node *> NodeList;
} /* namespace WorldEditor */
// Enable the use of QVariant with this class.
Q_DECLARE_METATYPE(WorldEditor::Node *)
#endif // PRIMITIVE_ITEM_H
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVE_ITEM_H
#define PRIMITIVE_ITEM_H
// Project includes
// NeL includes
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_class.h>
// Qt includes
#include <QList>
#include <QIcon>
#include <QVariant>
namespace WorldEditor
{
class RootPrimitiveNode;
/*
@class Node
@brief
@details
*/
class Node
{
public:
enum NodeType
{
BasicNodeType,
WorldEditNodeType,
RootPrimitiveNodeType,
LandscapeNodeType,
PrimitiveNodeType,
UserNodeType = 1024
};
Node();
virtual ~Node();
/// Remove child node from the child list.
void removeChildNode(Node *node);
/// Insert node at the beginning of the list.
void prependChildNode(Node *node);
/// Insert node at the end of the list.
void appendChildNode(Node *node);
/// Insert node in front of the node pointed to by the pointer before.
void insertChildNodeBefore(Node *node, Node *before);
/// Insert node in back of the node pointed to by the pointer after.
void insertChildNodeAfter(Node *node, Node *after);
/// Insert node in pos
void insertChildNode(int pos, Node *node);
/// Return the node at index position row in the child list.
Node *child(int row);
/// Return the number of nodes in the list.
int childCount() const;
/// Return a row index this node.
int row() const;
/// Return a pointer to this node's parent item. If this node does not have a parent, 0 is returned.
Node *parent();
/// Set this node's custom data for the key key to value.
void setData(int key, const QVariant &data);
/// Return this node's custom data for the key key as a QVariant.
QVariant data(int key) const;
/// Return a type this node.
virtual NodeType type() const;
private:
Q_DISABLE_COPY(Node)
Node *m_parent;
QList<Node *> m_children;
QHash<int, QVariant> m_data;
};
/*
@class WorldEditNode
@brief
@details
*/
class WorldEditNode: public Node
{
public:
WorldEditNode(const QString &name);
virtual ~WorldEditNode();
void setContext(const QString &name);
QString context() const;
void setDataPath(const QString &path);
QString dataPath() const;
virtual NodeType type() const;
private:
QString m_context;
QString m_dataPath;
};
/*
@class LandscapeNode
@brief
@details
*/
class LandscapeNode: public Node
{
public:
LandscapeNode(const QString &name, int id);
virtual ~LandscapeNode();
int id() const;
QString fileName() const;
virtual NodeType type() const;
private:
QString m_fileName;
int m_id;
};
/*
@class PrimitiveNode
@brief
@details
*/
class PrimitiveNode: public Node
{
public:
explicit PrimitiveNode(NLLIGO::IPrimitive *primitive);
virtual ~PrimitiveNode();
NLLIGO::IPrimitive *primitive() const;
const NLLIGO::CPrimitiveClass *primitiveClass() const;
RootPrimitiveNode *rootPrimitiveNode();
virtual NodeType type() const;
private:
NLLIGO::IPrimitive *m_primitive;
};
/*
@class RootPrimitiveNode
@brief
@details
*/
class RootPrimitiveNode: public PrimitiveNode
{
public:
RootPrimitiveNode(const QString &name, NLLIGO::CPrimitives *primitives);
virtual ~RootPrimitiveNode();
NLLIGO::CPrimitives *primitives() const;
void setFileName(const QString &fileName);
QString fileName() const;
virtual NodeType type() const;
private:
QString m_fileName;
NLLIGO::CPrimitives *m_primitives;
};
typedef QList<Node *> NodeList;
} /* namespace WorldEditor */
// Enable the use of QVariant with this class.
Q_DECLARE_METATYPE(WorldEditor::Node *)
#endif // PRIMITIVE_ITEM_H

654
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitives_model.cpp
View file

@ -1,328 +1,328 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitive_item.h"
#include "primitives_model.h"
#include "world_editor_misc.h"
#include "world_editor_constants.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_utils.h>
// Qt includes
#include <QtGui>
namespace WorldEditor
{
PrimitivesTreeModel::PrimitivesTreeModel(QObject *parent)
: QAbstractItemModel(parent),
m_worldEditNode(0)
{
m_rootNode = new Node();
m_rootNode->setData(Qt::DisplayRole, "Name");
}
PrimitivesTreeModel::~PrimitivesTreeModel()
{
delete m_rootNode;
}
int PrimitivesTreeModel::columnCount(const QModelIndex &parent) const
{
/* if (parent.isValid())
return static_cast<BaseTreeItem *>(parent.internalPointer())->columnCount();
else
return m_rootItem->columnCount();
*/
return 1;
}
QVariant PrimitivesTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
Node *item = static_cast<Node *>(index.internalPointer());
switch (role)
{
// case Qt::TextAlignmentRole:
// return int(Qt::AlignLeft | Qt::AlignVCenter);
case Qt::DisplayRole:
return item->data(Qt::DisplayRole);
case Qt::DecorationRole:
return item->data(Qt::DecorationRole);
default:
return QVariant();
}
}
Qt::ItemFlags PrimitivesTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return 0;
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
QVariant PrimitivesTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
// return m_rootNode->data(section);
return m_rootNode->data(Qt::DisplayRole);
return QVariant();
}
QModelIndex PrimitivesTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent))
return QModelIndex();
Node *parentNode;
if (!parent.isValid())
parentNode = m_rootNode;
else
parentNode = static_cast<Node *>(parent.internalPointer());
Node *childNode = parentNode->child(row);
if (childNode)
return createIndex(row, column, childNode);
else
return QModelIndex();
}
QModelIndex PrimitivesTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
Node *childNode = static_cast<Node *>(index.internalPointer());
Node *parentNode = childNode->parent();
if (parentNode == m_rootNode)
return QModelIndex();
return createIndex(parentNode->row(), 0, parentNode);
}
int PrimitivesTreeModel::rowCount(const QModelIndex &parent) const
{
Node *parentNode;
if (parent.column() > 0)
return 0;
if (!parent.isValid())
parentNode = m_rootNode;
else
parentNode = static_cast<Node *>(parent.internalPointer());
return parentNode->childCount();
}
Path PrimitivesTreeModel::pathFromIndex(const QModelIndex &index)
{
QModelIndex iter = index;
Path path;
while(iter.isValid())
{
path.prepend(PathItem(iter.row(), iter.column()));
iter = iter.parent();
}
return path;
}
Path PrimitivesTreeModel::pathFromNode(Node *node)
{
Node *iter = node;
Path path;
while(iter != 0)
{
path.prepend(PathItem(iter->row(), 0));
iter = iter->parent();
}
return path;
}
QModelIndex PrimitivesTreeModel::pathToIndex(const Path &path)
{
QModelIndex iter;
for(int i = 0; i < path.size(); i++)
{
iter = index(path[i].first, path[i].second, iter);
}
return iter;
}
Node *PrimitivesTreeModel::pathToNode(const Path &path)
{
Node *node = m_rootNode;
for(int i = 1; i < path.size(); i++)
{
node = node->child(path[i].first);
}
return node;
}
void PrimitivesTreeModel::createWorldEditNode(const QString &fileName)
{
// World edit node already is created, if yes is showing error message box
if (m_worldEditNode != 0)
nlerror("World edit node already is created.");
beginResetModel();
m_worldEditNode = new WorldEditNode(fileName);
m_rootNode->appendChildNode(m_worldEditNode);
endResetModel();
}
void PrimitivesTreeModel::deleteWorldEditNode()
{
beginResetModel();
if (m_worldEditNode != 0)
{
delete m_worldEditNode;
m_worldEditNode = 0;
}
endResetModel();
}
bool PrimitivesTreeModel::isWorldEditNodeLoaded() const
{
if (m_worldEditNode == 0)
return false;
else
return true;
}
Path PrimitivesTreeModel::createLandscapeNode(const QString &fileName, int id, int pos)
{
if (m_worldEditNode == 0)
createWorldEditNode("NewWorldEdit");
QModelIndex parentIndex = index(0, 0, QModelIndex());
int insPos = pos;
if (pos == -1)
insPos = 0;
beginInsertRows(parentIndex, insPos, insPos);
LandscapeNode *newNode = new LandscapeNode(fileName, id);
m_worldEditNode->insertChildNode(insPos, newNode);
endInsertRows();
return pathFromIndex(index(0, 0, index(insPos, 0, QModelIndex())));
}
Path PrimitivesTreeModel::createRootPrimitiveNode(const QString &fileName, NLLIGO::CPrimitives *primitives, int pos)
{
if (m_worldEditNode == 0)
createWorldEditNode("NewWorldEdit");
QString name = "NewPrimitive";
if (!fileName.isEmpty())
name = fileName;
int insPos = pos;
// Get position
if (pos == AtTheEnd)
insPos = m_worldEditNode->childCount();
QModelIndex parentIndex = index(0, 0, QModelIndex());
// Add root node in tree model
beginInsertRows(parentIndex, insPos, insPos);
RootPrimitiveNode *newNode = new RootPrimitiveNode(name, primitives);
m_worldEditNode->insertChildNode(insPos, newNode);
endInsertRows();
newNode->setData(Constants::PRIMITIVE_FILE_IS_CREATED, !fileName.isEmpty());
newNode->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
QModelIndex rootPrimIndex = index(insPos, 0, parentIndex);
// Scan childs items and add in the tree model
for (uint i = 0; i < primitives->RootNode->getNumChildren(); ++i)
{
NLLIGO::IPrimitive *childPrim;
primitives->RootNode->getChild(childPrim, i);
createChildNodes(childPrim, i, rootPrimIndex);
}
return pathFromIndex(rootPrimIndex);
}
Path PrimitivesTreeModel::createPrimitiveNode(NLLIGO::IPrimitive *primitive, const Path &parent, int pos)
{
QModelIndex parentIndex = pathToIndex(parent);
Node *parentNode = static_cast<Node *>(parentIndex.internalPointer());
int insPos = pos;
if (pos == AtTheEnd)
insPos = parentNode->childCount();
createChildNodes(primitive, insPos, parentIndex);
return pathFromIndex(index(insPos, 0, parentIndex));
}
void PrimitivesTreeModel::deleteNode(const Path &path)
{
QModelIndex nodeIndex = pathToIndex(path);
QModelIndex parentIndex = nodeIndex.parent();
Node *node = static_cast<Node *>(nodeIndex.internalPointer());
// Scan childs items and delete from the tree model
removeChildNodes(node, parentIndex);
}
void PrimitivesTreeModel::createChildNodes(NLLIGO::IPrimitive *primitive, int pos, const QModelIndex &parent)
{
Node *parentNode = static_cast<Node *>(parent.internalPointer());
// Add node in the tree model
beginInsertRows(parent, pos, pos);
PrimitiveNode *newNode = new PrimitiveNode(primitive);
parentNode->insertChildNode(pos, newNode);
endInsertRows();
// Scan childs items and add in the tree model
QModelIndex childIndex = index(pos, 0, parent);
for (uint i = 0; i < primitive->getNumChildren(); ++i)
{
NLLIGO::IPrimitive *childPrim;
primitive->getChild(childPrim, i);
createChildNodes(childPrim, i, childIndex);
}
}
void PrimitivesTreeModel::removeChildNodes(Node *node, const QModelIndex &parent)
{
// Delete all child nodes from the tree model
while (node->childCount() != 0)
removeChildNodes(node->child(node->childCount() - 1), parent.child(node->row(), 0));
// Delete node from the tree model
beginRemoveRows(parent, node->row(), node->row());
delete node;
endRemoveRows();
}
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitive_item.h"
#include "primitives_model.h"
#include "world_editor_misc.h"
#include "world_editor_constants.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_utils.h>
// Qt includes
#include <QtGui>
namespace WorldEditor
{
PrimitivesTreeModel::PrimitivesTreeModel(QObject *parent)
: QAbstractItemModel(parent),
m_worldEditNode(0)
{
m_rootNode = new Node();
m_rootNode->setData(Qt::DisplayRole, "Name");
}
PrimitivesTreeModel::~PrimitivesTreeModel()
{
delete m_rootNode;
}
int PrimitivesTreeModel::columnCount(const QModelIndex &parent) const
{
/* if (parent.isValid())
return static_cast<BaseTreeItem *>(parent.internalPointer())->columnCount();
else
return m_rootItem->columnCount();
*/
return 1;
}
QVariant PrimitivesTreeModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
Node *item = static_cast<Node *>(index.internalPointer());
switch (role)
{
// case Qt::TextAlignmentRole:
// return int(Qt::AlignLeft | Qt::AlignVCenter);
case Qt::DisplayRole:
return item->data(Qt::DisplayRole);
case Qt::DecorationRole:
return item->data(Qt::DecorationRole);
default:
return QVariant();
}
}
Qt::ItemFlags PrimitivesTreeModel::flags(const QModelIndex &index) const
{
if (!index.isValid())
return 0;
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
QVariant PrimitivesTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
// return m_rootNode->data(section);
return m_rootNode->data(Qt::DisplayRole);
return QVariant();
}
QModelIndex PrimitivesTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!hasIndex(row, column, parent))
return QModelIndex();
Node *parentNode;
if (!parent.isValid())
parentNode = m_rootNode;
else
parentNode = static_cast<Node *>(parent.internalPointer());
Node *childNode = parentNode->child(row);
if (childNode)
return createIndex(row, column, childNode);
else
return QModelIndex();
}
QModelIndex PrimitivesTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return QModelIndex();
Node *childNode = static_cast<Node *>(index.internalPointer());
Node *parentNode = childNode->parent();
if (parentNode == m_rootNode)
return QModelIndex();
return createIndex(parentNode->row(), 0, parentNode);
}
int PrimitivesTreeModel::rowCount(const QModelIndex &parent) const
{
Node *parentNode;
if (parent.column() > 0)
return 0;
if (!parent.isValid())
parentNode = m_rootNode;
else
parentNode = static_cast<Node *>(parent.internalPointer());
return parentNode->childCount();
}
Path PrimitivesTreeModel::pathFromIndex(const QModelIndex &index)
{
QModelIndex iter = index;
Path path;
while(iter.isValid())
{
path.prepend(PathItem(iter.row(), iter.column()));
iter = iter.parent();
}
return path;
}
Path PrimitivesTreeModel::pathFromNode(Node *node)
{
Node *iter = node;
Path path;
while(iter != 0)
{
path.prepend(PathItem(iter->row(), 0));
iter = iter->parent();
}
return path;
}
QModelIndex PrimitivesTreeModel::pathToIndex(const Path &path)
{
QModelIndex iter;
for(int i = 0; i < path.size(); i++)
{
iter = index(path[i].first, path[i].second, iter);
}
return iter;
}
Node *PrimitivesTreeModel::pathToNode(const Path &path)
{
Node *node = m_rootNode;
for(int i = 1; i < path.size(); i++)
{
node = node->child(path[i].first);
}
return node;
}
void PrimitivesTreeModel::createWorldEditNode(const QString &fileName)
{
// World edit node already is created, if yes is showing error message box
if (m_worldEditNode != 0)
nlerror("World edit node already is created.");
beginResetModel();
m_worldEditNode = new WorldEditNode(fileName);
m_rootNode->appendChildNode(m_worldEditNode);
endResetModel();
}
void PrimitivesTreeModel::deleteWorldEditNode()
{
beginResetModel();
if (m_worldEditNode != 0)
{
delete m_worldEditNode;
m_worldEditNode = 0;
}
endResetModel();
}
bool PrimitivesTreeModel::isWorldEditNodeLoaded() const
{
if (m_worldEditNode == 0)
return false;
else
return true;
}
Path PrimitivesTreeModel::createLandscapeNode(const QString &fileName, int id, int pos)
{
if (m_worldEditNode == 0)
createWorldEditNode("NewWorldEdit");
QModelIndex parentIndex = index(0, 0, QModelIndex());
int insPos = pos;
if (pos == -1)
insPos = 0;
beginInsertRows(parentIndex, insPos, insPos);
LandscapeNode *newNode = new LandscapeNode(fileName, id);
m_worldEditNode->insertChildNode(insPos, newNode);
endInsertRows();
return pathFromIndex(index(0, 0, index(insPos, 0, QModelIndex())));
}
Path PrimitivesTreeModel::createRootPrimitiveNode(const QString &fileName, NLLIGO::CPrimitives *primitives, int pos)
{
if (m_worldEditNode == 0)
createWorldEditNode("NewWorldEdit");
QString name = "NewPrimitive";
if (!fileName.isEmpty())
name = fileName;
int insPos = pos;
// Get position
if (pos == AtTheEnd)
insPos = m_worldEditNode->childCount();
QModelIndex parentIndex = index(0, 0, QModelIndex());
// Add root node in tree model
beginInsertRows(parentIndex, insPos, insPos);
RootPrimitiveNode *newNode = new RootPrimitiveNode(name, primitives);
m_worldEditNode->insertChildNode(insPos, newNode);
endInsertRows();
newNode->setData(Constants::PRIMITIVE_FILE_IS_CREATED, !fileName.isEmpty());
newNode->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
QModelIndex rootPrimIndex = index(insPos, 0, parentIndex);
// Scan childs items and add in the tree model
for (uint i = 0; i < primitives->RootNode->getNumChildren(); ++i)
{
NLLIGO::IPrimitive *childPrim;
primitives->RootNode->getChild(childPrim, i);
createChildNodes(childPrim, i, rootPrimIndex);
}
return pathFromIndex(rootPrimIndex);
}
Path PrimitivesTreeModel::createPrimitiveNode(NLLIGO::IPrimitive *primitive, const Path &parent, int pos)
{
QModelIndex parentIndex = pathToIndex(parent);
Node *parentNode = static_cast<Node *>(parentIndex.internalPointer());
int insPos = pos;
if (pos == AtTheEnd)
insPos = parentNode->childCount();
createChildNodes(primitive, insPos, parentIndex);
return pathFromIndex(index(insPos, 0, parentIndex));
}
void PrimitivesTreeModel::deleteNode(const Path &path)
{
QModelIndex nodeIndex = pathToIndex(path);
QModelIndex parentIndex = nodeIndex.parent();
Node *node = static_cast<Node *>(nodeIndex.internalPointer());
// Scan childs items and delete from the tree model
removeChildNodes(node, parentIndex);
}
void PrimitivesTreeModel::createChildNodes(NLLIGO::IPrimitive *primitive, int pos, const QModelIndex &parent)
{
Node *parentNode = static_cast<Node *>(parent.internalPointer());
// Add node in the tree model
beginInsertRows(parent, pos, pos);
PrimitiveNode *newNode = new PrimitiveNode(primitive);
parentNode->insertChildNode(pos, newNode);
endInsertRows();
// Scan childs items and add in the tree model
QModelIndex childIndex = index(pos, 0, parent);
for (uint i = 0; i < primitive->getNumChildren(); ++i)
{
NLLIGO::IPrimitive *childPrim;
primitive->getChild(childPrim, i);
createChildNodes(childPrim, i, childIndex);
}
}
void PrimitivesTreeModel::removeChildNodes(Node *node, const QModelIndex &parent)
{
// Delete all child nodes from the tree model
while (node->childCount() != 0)
removeChildNodes(node->child(node->childCount() - 1), parent.child(node->row(), 0));
// Delete node from the tree model
beginRemoveRows(parent, node->row(), node->row());
delete node;
endRemoveRows();
}
} /* namespace WorldEditor */

208
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitives_model.h
View file

@ -1,104 +1,104 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVES_MODEL_H
#define PRIMITIVES_MODEL_H
// NeL includes
#include <nel/misc/vector.h>
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_class.h>
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QVariant>
namespace WorldEditor
{
class Node;
class WorldEditNode;
const int AtTheEnd = -1;
typedef QPair<int, int> PathItem;
/*
@typedef Path
@brief It store a list of row and column numbers which have to walk through from the root index of the model to reach the need item.
It is used for undo/redo commands.
*/
typedef QList<PathItem> Path;
/**
@class PrimitivesTreeModel
@brief
@details
*/
class PrimitivesTreeModel : public QAbstractItemModel
{
Q_OBJECT
public:
explicit PrimitivesTreeModel(QObject *parent = 0);
~PrimitivesTreeModel();
QVariant data(const QModelIndex &index, int role) const;
Qt::ItemFlags flags(const QModelIndex &index) const;
QVariant headerData(int section, Qt::Orientation orientation,
int role = Qt::DisplayRole) const;
QModelIndex index(int row, int column,
const QModelIndex &parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex &index) const;
int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent = QModelIndex()) const;
/// Convert QModelIndex to the persistent index - @Path.
/// @Path is a list of [row,column] pairs showing us the way through the model.
Path pathFromIndex(const QModelIndex &index);
QModelIndex pathToIndex(const Path &path);
Path pathFromNode(Node *node);
Node *pathToNode(const Path &path);
void createWorldEditNode(const QString &fileName);
void deleteWorldEditNode();
bool isWorldEditNodeLoaded() const;
/// Add new landscape node in tree model.
Path createLandscapeNode(const QString &fileName, int id, int pos = AtTheEnd);
/// Add new root primitive node and all sub-primitives in the tree model.
Path createRootPrimitiveNode(const QString &fileName, NLLIGO::CPrimitives *primitives, int pos = AtTheEnd);
/// Add new primitive node and all sub-primitives in the tree model.
Path createPrimitiveNode(NLLIGO::IPrimitive *primitive, const Path &parent, int pos = AtTheEnd);
/// Delete node and all child nodes from the tree model
void deleteNode(const Path &path);
private:
void createChildNodes(NLLIGO::IPrimitive *primitive, int pos, const QModelIndex &parent);
void removeChildNodes(Node *node, const QModelIndex &parent);
Node *m_rootNode;
WorldEditNode *m_worldEditNode;
};
} /* namespace WorldEditor */
#endif // PRIMITIVES_MODEL_H
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVES_MODEL_H
#define PRIMITIVES_MODEL_H
// NeL includes
#include <nel/misc/vector.h>
#include <nel/ligo/primitive.h>
#include <nel/ligo/primitive_class.h>
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QVariant>
namespace WorldEditor
{
class Node;
class WorldEditNode;
const int AtTheEnd = -1;
typedef QPair<int, int> PathItem;
/*
@typedef Path
@brief It store a list of row and column numbers which have to walk through from the root index of the model to reach the need item.
It is used for undo/redo commands.
*/
typedef QList<PathItem> Path;
/**
@class PrimitivesTreeModel
@brief
@details
*/
class PrimitivesTreeModel : public QAbstractItemModel
{
Q_OBJECT
public:
explicit PrimitivesTreeModel(QObject *parent = 0);
~PrimitivesTreeModel();
QVariant data(const QModelIndex &index, int role) const;
Qt::ItemFlags flags(const QModelIndex &index) const;
QVariant headerData(int section, Qt::Orientation orientation,
int role = Qt::DisplayRole) const;
QModelIndex index(int row, int column,
const QModelIndex &parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex &index) const;
int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent = QModelIndex()) const;
/// Convert QModelIndex to the persistent index - @Path.
/// @Path is a list of [row,column] pairs showing us the way through the model.
Path pathFromIndex(const QModelIndex &index);
QModelIndex pathToIndex(const Path &path);
Path pathFromNode(Node *node);
Node *pathToNode(const Path &path);
void createWorldEditNode(const QString &fileName);
void deleteWorldEditNode();
bool isWorldEditNodeLoaded() const;
/// Add new landscape node in tree model.
Path createLandscapeNode(const QString &fileName, int id, int pos = AtTheEnd);
/// Add new root primitive node and all sub-primitives in the tree model.
Path createRootPrimitiveNode(const QString &fileName, NLLIGO::CPrimitives *primitives, int pos = AtTheEnd);
/// Add new primitive node and all sub-primitives in the tree model.
Path createPrimitiveNode(NLLIGO::IPrimitive *primitive, const Path &parent, int pos = AtTheEnd);
/// Delete node and all child nodes from the tree model
void deleteNode(const Path &path);
private:
void createChildNodes(NLLIGO::IPrimitive *primitive, int pos, const QModelIndex &parent);
void removeChildNodes(Node *node, const QModelIndex &parent);
Node *m_rootNode;
WorldEditNode *m_worldEditNode;
};
} /* namespace WorldEditor */
#endif // PRIMITIVES_MODEL_H

914
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitives_view.cpp
View file

@ -1,458 +1,458 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitives_view.h"
#include "primitives_model.h"
#include "world_editor_actions.h"
#include "world_editor_constants.h"
#include "../core/core_constants.h"
#include "../landscape_editor/landscape_editor_constants.h"
#include "../landscape_editor/builder_zone_base.h"
// NeL includes
#include <nel/ligo/primitive.h>
#include <nel/ligo/ligo_config.h>
#include <nel/ligo/primitive_class.h>
#include <nel/ligo/primitive_utils.h>
// Qt includes
#include <QContextMenuEvent>
#include <QMessageBox>
#include <QApplication>
#include <QtGui/QMenu>
#include <QtGui/QFileDialog>
namespace WorldEditor
{
PrimitivesView::PrimitivesView(QWidget *parent)
: QTreeView(parent),
m_undoStack(0),
m_worldEditorScene(0),
m_zoneBuilder(0),
m_primitivesTreeModel(0)
{
setContextMenuPolicy(Qt::DefaultContextMenu);
m_unloadAction = new QAction("Unload", this);
m_saveAction = new QAction("Save", this);
m_saveAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_saveAsAction = new QAction("Save As...", this);
m_saveAsAction->setIcon(QIcon(Core::Constants::ICON_SAVE_AS));
m_loadLandAction = new QAction("Load landscape file", this);
m_loadLandAction->setIcon(QIcon(LandscapeEditor::Constants::ICON_ZONE_ITEM));
m_loadPrimitiveAction = new QAction("Load primitive file", this);
m_loadPrimitiveAction->setIcon(QIcon(Constants::ICON_ROOT_PRIMITIVE));
m_newPrimitiveAction = new QAction("New primitive", this);
m_deleteAction = new QAction("Delete", this);
m_selectChildrenAction = new QAction("Select children", this);
m_helpAction = new QAction("Help", this);
m_helpAction->setEnabled(false);
m_showAction = new QAction("Show", this);
m_showAction->setEnabled(false);
m_hideAction = new QAction("Hide", this);
m_hideAction->setEnabled(false);
connect(m_loadLandAction, SIGNAL(triggered()), this, SLOT(loadLandscape()));
connect(m_loadPrimitiveAction, SIGNAL(triggered()), this, SLOT(loadRootPrimitive()));
connect(m_newPrimitiveAction, SIGNAL(triggered()), this, SLOT(createRootPrimitive()));
connect(m_selectChildrenAction, SIGNAL(triggered()), this, SLOT(selectChildren()));
connect(m_deleteAction, SIGNAL(triggered()), this, SLOT(deletePrimitives()));
connect(m_saveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(m_saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs()));
connect(m_unloadAction, SIGNAL(triggered()), this, SLOT(unload()));
connect(m_showAction, SIGNAL(triggered()), this, SLOT(showPrimitive()));
connect(m_hideAction, SIGNAL(triggered()), this, SLOT(hidePrimitive()));
#ifdef Q_OS_DARWIN
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
#endif
}
PrimitivesView::~PrimitivesView()
{
}
void PrimitivesView::setUndoStack(QUndoStack *undoStack)
{
m_undoStack = undoStack;
}
void PrimitivesView::setZoneBuilder(LandscapeEditor::ZoneBuilderBase *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
void PrimitivesView::setWorldScene(WorldEditorScene *worldEditorScene)
{
m_worldEditorScene = worldEditorScene;
}
void PrimitivesView::setModel(PrimitivesTreeModel *model)
{
QTreeView::setModel(model);
m_primitivesTreeModel = model;
}
void PrimitivesView::loadRootPrimitive()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo primitive file"), m_lastDir,
tr("All NeL Ligo primitive files (*.primitive)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
if (fileNames.count() > 1)
m_undoStack->beginMacro(tr("Load primitive files"));
Q_FOREACH(QString fileName, fileNames)
{
m_lastDir = QFileInfo(fileName).absolutePath();
m_undoStack->push(new LoadRootPrimitiveCommand(fileName, m_worldEditorScene, m_primitivesTreeModel, this));
}
if (fileNames.count() > 1)
m_undoStack->endMacro();
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::loadLandscape()
{
nlassert(m_undoStack);
nlassert(m_zoneBuilder);
nlassert(m_primitivesTreeModel);
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo land file"), m_lastDir,
tr("All NeL Ligo land files (*.land)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
if (fileNames.count() > 1)
m_undoStack->beginMacro(tr("Load land files"));
Q_FOREACH(QString fileName, fileNames)
{
m_lastDir = QFileInfo(fileName).absolutePath();
m_undoStack->push(new LoadLandscapeCommand(fileName, m_primitivesTreeModel, m_zoneBuilder));
}
if (fileNames.count() > 1)
m_undoStack->endMacro();
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::createRootPrimitive()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
m_undoStack->push(new CreateRootPrimitiveCommand("NewPrimitive", m_primitivesTreeModel));
}
void PrimitivesView::selectChildren()
{
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex parentIndex = indexList.first();
selectionModel()->clearSelection();
QItemSelection itemSelection;
selectChildren(parentIndex, itemSelection);
selectionModel()->select(itemSelection, QItemSelectionModel::Select);
}
void PrimitivesView::save()
{
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
RootPrimitiveNode *node = static_cast<RootPrimitiveNode *>(index.internalPointer());
if (node->data(Constants::PRIMITIVE_FILE_IS_CREATED).toBool())
{
if (!NLLIGO::saveXmlPrimitiveFile(*node->primitives(), node->fileName().toStdString()))
QMessageBox::warning(this, "World Editor Qt", tr("Error writing output file: %1").arg(node->fileName()));
else
node->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
}
else
saveAs();
}
void PrimitivesView::saveAs()
{
nlassert(m_primitivesTreeModel);
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save NeL Ligo primitive file"), m_lastDir,
tr("NeL Ligo primitive file (*.primitive)"));
setCursor(Qt::WaitCursor);
if (!fileName.isEmpty())
{
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
RootPrimitiveNode *node = static_cast<RootPrimitiveNode *>(index.internalPointer());
if (!NLLIGO::saveXmlPrimitiveFile(*node->primitives(), fileName.toStdString()))
QMessageBox::warning(this, "World Editor Qt", tr("Error writing output file: %1").arg(fileName));
else
{
node->setFileName(fileName);
node->setData(Constants::PRIMITIVE_FILE_IS_CREATED, true);
node->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
}
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::deletePrimitives()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
PrimitiveNode *node = static_cast<PrimitiveNode *>(index.internalPointer());
if (node->primitiveClass()->Deletable)
m_undoStack->push(new DeletePrimitiveCommand(index, m_primitivesTreeModel, m_worldEditorScene, this));
}
void PrimitivesView::unload()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
Node *node = static_cast<Node *>(index.internalPointer());
switch (node->type())
{
case Node::WorldEditNodeType:
{
break;
}
case Node::LandscapeNodeType:
{
m_undoStack->push(new UnloadLandscapeCommand(index, m_primitivesTreeModel, m_zoneBuilder));
break;
}
case Node::RootPrimitiveNodeType:
{
m_undoStack->push(new UnloadRootPrimitiveCommand(index, m_worldEditorScene, m_primitivesTreeModel, this));
break;
}
}
}
void PrimitivesView::showPrimitive()
{
}
void PrimitivesView::hidePrimitive()
{
}
void PrimitivesView::addNewPrimitiveByClass(int value)
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
PrimitiveNode *node = static_cast<PrimitiveNode *>(indexList.first().internalPointer());
// Get class name
QString className = node->primitiveClass()->DynamicChildren[value].ClassName.c_str();
m_undoStack->push(new AddPrimitiveByClassCommand(className, m_primitivesTreeModel->pathFromIndex(indexList.first()),
m_worldEditorScene, m_primitivesTreeModel, this));
}
void PrimitivesView::generatePrimitives(int value)
{
}
void PrimitivesView::openItem(int value)
{
}
void PrimitivesView::contextMenuEvent(QContextMenuEvent *event)
{
QWidget::contextMenuEvent(event);
QModelIndexList indexList = selectionModel()->selectedRows();
if (indexList.size() == 0)
return;
QMenu *popurMenu = new QMenu(this);
if (indexList.size() == 1)
{
Node *node = static_cast<Node *>(indexList.first().internalPointer());
switch (node->type())
{
case Node::WorldEditNodeType:
fillMenu_WorldEdit(popurMenu);
break;
case Node::RootPrimitiveNodeType:
fillMenu_RootPrimitive(popurMenu, indexList.first());
break;
case Node::LandscapeNodeType:
fillMenu_Landscape(popurMenu);
break;
case Node::PrimitiveNodeType:
fillMenu_Primitive(popurMenu, indexList.first());
break;
};
}
popurMenu->exec(event->globalPos());
delete popurMenu;
event->accept();
}
void PrimitivesView::selectChildren(const QModelIndex &parent, QItemSelection &itemSelection)
{
const int rowCount = model()->rowCount(parent);
QItemSelection mergeItemSelection(parent.child(0, 0), parent.child(rowCount - 1, 0));
itemSelection.merge(mergeItemSelection, QItemSelectionModel::Select);
for (int i = 0; i < rowCount; ++i)
{
QModelIndex childIndex = parent.child(i, 0);
if (model()->rowCount(childIndex) != 0)
selectChildren(childIndex, itemSelection);
}
}
void PrimitivesView::fillMenu_WorldEdit(QMenu *menu)
{
//menu->addAction(m_unloadAction);
//menu->addAction(m_saveAction);
//menu->addAction(m_saveAsAction);
menu->addSeparator();
menu->addAction(m_loadLandAction);
menu->addAction(m_loadPrimitiveAction);
menu->addAction(m_newPrimitiveAction);
menu->addSeparator();
menu->addAction(m_helpAction);
}
void PrimitivesView::fillMenu_Landscape(QMenu *menu)
{
menu->addAction(m_unloadAction);
menu->addSeparator();
menu->addAction(m_showAction);
menu->addAction(m_hideAction);
}
void PrimitivesView::fillMenu_RootPrimitive(QMenu *menu, const QModelIndex &index)
{
menu->addAction(m_saveAction);
menu->addAction(m_saveAsAction);
menu->addAction(m_unloadAction);
fillMenu_Primitive(menu, index);
menu->removeAction(m_deleteAction);
}
void PrimitivesView::fillMenu_Primitive(QMenu *menu, const QModelIndex &index)
{
menu->addAction(m_deleteAction);
menu->addAction(m_selectChildrenAction);
menu->addAction(m_helpAction);
menu->addSeparator();
menu->addAction(m_showAction);
menu->addAction(m_hideAction);
QSignalMapper *addSignalMapper = new QSignalMapper(menu);
QSignalMapper *generateSignalMapper = new QSignalMapper(menu);
//QSignalMapper *openSignalMapper = new QSignalMapper(menu);
connect(addSignalMapper, SIGNAL(mapped(int)), this, SLOT(addNewPrimitiveByClass(int)));
connect(generateSignalMapper, SIGNAL(mapped(int)), this, SLOT(generatePrimitives(int)));
//connect(openSignalMapper, SIGNAL(mapped(int)), this, SLOT(openItem(int)));
PrimitiveNode *node = static_cast<PrimitiveNode *>(index.internalPointer());
const NLLIGO::CPrimitiveClass *primClass = node->primitiveClass();
// What class is it ?
if (primClass && primClass->DynamicChildren.size())
{
menu->addSeparator();
// For each child, add a create method
for (size_t i = 0; i < primClass->DynamicChildren.size(); i++)
{
// Get class name
QString className = primClass->DynamicChildren[i].ClassName.c_str();
// Get icon
QIcon icon(QString("%1/%2.ico").arg(Constants::PATH_TO_OLD_ICONS).arg(className));
// Create and add action in popur menu
QAction *action = menu->addAction(icon, tr("Add %1").arg(className));
addSignalMapper->setMapping(action, i);
connect(action, SIGNAL(triggered()), addSignalMapper, SLOT(map()));
}
}
// What class is it ?
if (primClass && primClass->GeneratedChildren.size())
{
menu->addSeparator();
// For each child, add a create method
for (size_t i = 0; i < primClass->GeneratedChildren.size(); i++)
{
// Get class name
QString childName = primClass->GeneratedChildren[i].ClassName.c_str();
// Create and add action in popur menu
QAction *action = menu->addAction(tr("Generate %1").arg(childName));
generateSignalMapper->setMapping(action, i);
connect(action, SIGNAL(triggered()), generateSignalMapper, SLOT(map()));
}
}
}
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "primitives_view.h"
#include "primitives_model.h"
#include "world_editor_actions.h"
#include "world_editor_constants.h"
#include "../core/core_constants.h"
#include "../landscape_editor/landscape_editor_constants.h"
#include "../landscape_editor/builder_zone_base.h"
// NeL includes
#include <nel/ligo/primitive.h>
#include <nel/ligo/ligo_config.h>
#include <nel/ligo/primitive_class.h>
#include <nel/ligo/primitive_utils.h>
// Qt includes
#include <QContextMenuEvent>
#include <QMessageBox>
#include <QApplication>
#include <QtGui/QMenu>
#include <QtGui/QFileDialog>
namespace WorldEditor
{
PrimitivesView::PrimitivesView(QWidget *parent)
: QTreeView(parent),
m_undoStack(0),
m_worldEditorScene(0),
m_zoneBuilder(0),
m_primitivesTreeModel(0)
{
setContextMenuPolicy(Qt::DefaultContextMenu);
m_unloadAction = new QAction("Unload", this);
m_saveAction = new QAction("Save", this);
m_saveAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
m_saveAsAction = new QAction("Save As...", this);
m_saveAsAction->setIcon(QIcon(Core::Constants::ICON_SAVE_AS));
m_loadLandAction = new QAction("Load landscape file", this);
m_loadLandAction->setIcon(QIcon(LandscapeEditor::Constants::ICON_ZONE_ITEM));
m_loadPrimitiveAction = new QAction("Load primitive file", this);
m_loadPrimitiveAction->setIcon(QIcon(Constants::ICON_ROOT_PRIMITIVE));
m_newPrimitiveAction = new QAction("New primitive", this);
m_deleteAction = new QAction("Delete", this);
m_selectChildrenAction = new QAction("Select children", this);
m_helpAction = new QAction("Help", this);
m_helpAction->setEnabled(false);
m_showAction = new QAction("Show", this);
m_showAction->setEnabled(false);
m_hideAction = new QAction("Hide", this);
m_hideAction->setEnabled(false);
connect(m_loadLandAction, SIGNAL(triggered()), this, SLOT(loadLandscape()));
connect(m_loadPrimitiveAction, SIGNAL(triggered()), this, SLOT(loadRootPrimitive()));
connect(m_newPrimitiveAction, SIGNAL(triggered()), this, SLOT(createRootPrimitive()));
connect(m_selectChildrenAction, SIGNAL(triggered()), this, SLOT(selectChildren()));
connect(m_deleteAction, SIGNAL(triggered()), this, SLOT(deletePrimitives()));
connect(m_saveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(m_saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs()));
connect(m_unloadAction, SIGNAL(triggered()), this, SLOT(unload()));
connect(m_showAction, SIGNAL(triggered()), this, SLOT(showPrimitive()));
connect(m_hideAction, SIGNAL(triggered()), this, SLOT(hidePrimitive()));
#ifdef Q_OS_DARWIN
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
#endif
}
PrimitivesView::~PrimitivesView()
{
}
void PrimitivesView::setUndoStack(QUndoStack *undoStack)
{
m_undoStack = undoStack;
}
void PrimitivesView::setZoneBuilder(LandscapeEditor::ZoneBuilderBase *zoneBuilder)
{
m_zoneBuilder = zoneBuilder;
}
void PrimitivesView::setWorldScene(WorldEditorScene *worldEditorScene)
{
m_worldEditorScene = worldEditorScene;
}
void PrimitivesView::setModel(PrimitivesTreeModel *model)
{
QTreeView::setModel(model);
m_primitivesTreeModel = model;
}
void PrimitivesView::loadRootPrimitive()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo primitive file"), m_lastDir,
tr("All NeL Ligo primitive files (*.primitive)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
if (fileNames.count() > 1)
m_undoStack->beginMacro(tr("Load primitive files"));
Q_FOREACH(QString fileName, fileNames)
{
m_lastDir = QFileInfo(fileName).absolutePath();
m_undoStack->push(new LoadRootPrimitiveCommand(fileName, m_worldEditorScene, m_primitivesTreeModel, this));
}
if (fileNames.count() > 1)
m_undoStack->endMacro();
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::loadLandscape()
{
nlassert(m_undoStack);
nlassert(m_zoneBuilder);
nlassert(m_primitivesTreeModel);
QStringList fileNames = QFileDialog::getOpenFileNames(this,
tr("Open NeL Ligo land file"), m_lastDir,
tr("All NeL Ligo land files (*.land)"));
setCursor(Qt::WaitCursor);
if (!fileNames.isEmpty())
{
if (fileNames.count() > 1)
m_undoStack->beginMacro(tr("Load land files"));
Q_FOREACH(QString fileName, fileNames)
{
m_lastDir = QFileInfo(fileName).absolutePath();
m_undoStack->push(new LoadLandscapeCommand(fileName, m_primitivesTreeModel, m_zoneBuilder));
}
if (fileNames.count() > 1)
m_undoStack->endMacro();
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::createRootPrimitive()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
m_undoStack->push(new CreateRootPrimitiveCommand("NewPrimitive", m_primitivesTreeModel));
}
void PrimitivesView::selectChildren()
{
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex parentIndex = indexList.first();
selectionModel()->clearSelection();
QItemSelection itemSelection;
selectChildren(parentIndex, itemSelection);
selectionModel()->select(itemSelection, QItemSelectionModel::Select);
}
void PrimitivesView::save()
{
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
RootPrimitiveNode *node = static_cast<RootPrimitiveNode *>(index.internalPointer());
if (node->data(Constants::PRIMITIVE_FILE_IS_CREATED).toBool())
{
if (!NLLIGO::saveXmlPrimitiveFile(*node->primitives(), node->fileName().toStdString()))
QMessageBox::warning(this, "World Editor Qt", tr("Error writing output file: %1").arg(node->fileName()));
else
node->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
}
else
saveAs();
}
void PrimitivesView::saveAs()
{
nlassert(m_primitivesTreeModel);
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save NeL Ligo primitive file"), m_lastDir,
tr("NeL Ligo primitive file (*.primitive)"));
setCursor(Qt::WaitCursor);
if (!fileName.isEmpty())
{
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
RootPrimitiveNode *node = static_cast<RootPrimitiveNode *>(index.internalPointer());
if (!NLLIGO::saveXmlPrimitiveFile(*node->primitives(), fileName.toStdString()))
QMessageBox::warning(this, "World Editor Qt", tr("Error writing output file: %1").arg(fileName));
else
{
node->setFileName(fileName);
node->setData(Constants::PRIMITIVE_FILE_IS_CREATED, true);
node->setData(Constants::PRIMITIVE_IS_MODIFIED, false);
}
}
setCursor(Qt::ArrowCursor);
}
void PrimitivesView::deletePrimitives()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
PrimitiveNode *node = static_cast<PrimitiveNode *>(index.internalPointer());
if (node->primitiveClass()->Deletable)
m_undoStack->push(new DeletePrimitiveCommand(index, m_primitivesTreeModel, m_worldEditorScene, this));
}
void PrimitivesView::unload()
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
QModelIndex index = indexList.first();
Node *node = static_cast<Node *>(index.internalPointer());
switch (node->type())
{
case Node::WorldEditNodeType:
{
break;
}
case Node::LandscapeNodeType:
{
m_undoStack->push(new UnloadLandscapeCommand(index, m_primitivesTreeModel, m_zoneBuilder));
break;
}
case Node::RootPrimitiveNodeType:
{
m_undoStack->push(new UnloadRootPrimitiveCommand(index, m_worldEditorScene, m_primitivesTreeModel, this));
break;
}
}
}
void PrimitivesView::showPrimitive()
{
}
void PrimitivesView::hidePrimitive()
{
}
void PrimitivesView::addNewPrimitiveByClass(int value)
{
nlassert(m_undoStack);
nlassert(m_primitivesTreeModel);
QModelIndexList indexList = selectionModel()->selectedRows();
PrimitiveNode *node = static_cast<PrimitiveNode *>(indexList.first().internalPointer());
// Get class name
QString className = node->primitiveClass()->DynamicChildren[value].ClassName.c_str();
m_undoStack->push(new AddPrimitiveByClassCommand(className, m_primitivesTreeModel->pathFromIndex(indexList.first()),
m_worldEditorScene, m_primitivesTreeModel, this));
}
void PrimitivesView::generatePrimitives(int value)
{
}
void PrimitivesView::openItem(int value)
{
}
void PrimitivesView::contextMenuEvent(QContextMenuEvent *event)
{
QWidget::contextMenuEvent(event);
QModelIndexList indexList = selectionModel()->selectedRows();
if (indexList.size() == 0)
return;
QMenu *popurMenu = new QMenu(this);
if (indexList.size() == 1)
{
Node *node = static_cast<Node *>(indexList.first().internalPointer());
switch (node->type())
{
case Node::WorldEditNodeType:
fillMenu_WorldEdit(popurMenu);
break;
case Node::RootPrimitiveNodeType:
fillMenu_RootPrimitive(popurMenu, indexList.first());
break;
case Node::LandscapeNodeType:
fillMenu_Landscape(popurMenu);
break;
case Node::PrimitiveNodeType:
fillMenu_Primitive(popurMenu, indexList.first());
break;
};
}
popurMenu->exec(event->globalPos());
delete popurMenu;
event->accept();
}
void PrimitivesView::selectChildren(const QModelIndex &parent, QItemSelection &itemSelection)
{
const int rowCount = model()->rowCount(parent);
QItemSelection mergeItemSelection(parent.child(0, 0), parent.child(rowCount - 1, 0));
itemSelection.merge(mergeItemSelection, QItemSelectionModel::Select);
for (int i = 0; i < rowCount; ++i)
{
QModelIndex childIndex = parent.child(i, 0);
if (model()->rowCount(childIndex) != 0)
selectChildren(childIndex, itemSelection);
}
}
void PrimitivesView::fillMenu_WorldEdit(QMenu *menu)
{
//menu->addAction(m_unloadAction);
//menu->addAction(m_saveAction);
//menu->addAction(m_saveAsAction);
menu->addSeparator();
menu->addAction(m_loadLandAction);
menu->addAction(m_loadPrimitiveAction);
menu->addAction(m_newPrimitiveAction);
menu->addSeparator();
menu->addAction(m_helpAction);
}
void PrimitivesView::fillMenu_Landscape(QMenu *menu)
{
menu->addAction(m_unloadAction);
menu->addSeparator();
menu->addAction(m_showAction);
menu->addAction(m_hideAction);
}
void PrimitivesView::fillMenu_RootPrimitive(QMenu *menu, const QModelIndex &index)
{
menu->addAction(m_saveAction);
menu->addAction(m_saveAsAction);
menu->addAction(m_unloadAction);
fillMenu_Primitive(menu, index);
menu->removeAction(m_deleteAction);
}
void PrimitivesView::fillMenu_Primitive(QMenu *menu, const QModelIndex &index)
{
menu->addAction(m_deleteAction);
menu->addAction(m_selectChildrenAction);
menu->addAction(m_helpAction);
menu->addSeparator();
menu->addAction(m_showAction);
menu->addAction(m_hideAction);
QSignalMapper *addSignalMapper = new QSignalMapper(menu);
QSignalMapper *generateSignalMapper = new QSignalMapper(menu);
//QSignalMapper *openSignalMapper = new QSignalMapper(menu);
connect(addSignalMapper, SIGNAL(mapped(int)), this, SLOT(addNewPrimitiveByClass(int)));
connect(generateSignalMapper, SIGNAL(mapped(int)), this, SLOT(generatePrimitives(int)));
//connect(openSignalMapper, SIGNAL(mapped(int)), this, SLOT(openItem(int)));
PrimitiveNode *node = static_cast<PrimitiveNode *>(index.internalPointer());
const NLLIGO::CPrimitiveClass *primClass = node->primitiveClass();
// What class is it ?
if (primClass && primClass->DynamicChildren.size())
{
menu->addSeparator();
// For each child, add a create method
for (size_t i = 0; i < primClass->DynamicChildren.size(); i++)
{
// Get class name
QString className = primClass->DynamicChildren[i].ClassName.c_str();
// Get icon
QIcon icon(QString("%1/%2.ico").arg(Constants::PATH_TO_OLD_ICONS).arg(className));
// Create and add action in popur menu
QAction *action = menu->addAction(icon, tr("Add %1").arg(className));
addSignalMapper->setMapping(action, i);
connect(action, SIGNAL(triggered()), addSignalMapper, SLOT(map()));
}
}
// What class is it ?
if (primClass && primClass->GeneratedChildren.size())
{
menu->addSeparator();
// For each child, add a create method
for (size_t i = 0; i < primClass->GeneratedChildren.size(); i++)
{
// Get class name
QString childName = primClass->GeneratedChildren[i].ClassName.c_str();
// Create and add action in popur menu
QAction *action = menu->addAction(tr("Generate %1").arg(childName));
generateSignalMapper->setMapping(action, i);
connect(action, SIGNAL(triggered()), generateSignalMapper, SLOT(map()));
}
}
}
} /* namespace WorldEditor */

224
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/primitives_view.h
View file

@ -1,112 +1,112 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVES_VIEW_H
#define PRIMITIVES_VIEW_H
// Project includes
#include "primitive_item.h"
// NeL includes
#include <nel/ligo/primitive.h>
// Qt includes
#include <QtGui/QAction>
#include <QtGui/QTreeView>
#include <QtCore/QModelIndex>
#include <QtCore/QVariant>
#include <QtCore/QSignalMapper>
#include <QtGui/QUndoStack>
#include <QtGui/QItemSelection>
namespace LandscapeEditor
{
class ZoneBuilderBase;
}
namespace WorldEditor
{
class PrimitivesTreeModel;
class WorldEditorScene;
/**
@class PrimitivesView
@brief
@details
*/
class PrimitivesView : public QTreeView
{
Q_OBJECT
public:
explicit PrimitivesView(QWidget *parent = 0);
~PrimitivesView();
void setUndoStack(QUndoStack *undoStack);
void setZoneBuilder(LandscapeEditor::ZoneBuilderBase *zoneBuilder);
void setWorldScene(WorldEditorScene *worldEditorScene);
virtual void setModel(PrimitivesTreeModel *model);
private Q_SLOTS:
void loadLandscape();
void loadRootPrimitive();
void createRootPrimitive();
void selectChildren();
void save();
void saveAs();
void deletePrimitives();
void unload();
void showPrimitive();
void hidePrimitive();
void addNewPrimitiveByClass(int value);
void generatePrimitives(int value);
void openItem(int value);
protected:
void contextMenuEvent(QContextMenuEvent *event);
private:
void selectChildren(const QModelIndex &parent, QItemSelection &itemSelection);
void fillMenu_WorldEdit(QMenu *menu);
void fillMenu_Landscape(QMenu *menu);
void fillMenu_RootPrimitive(QMenu *menu, const QModelIndex &index);
void fillMenu_Primitive(QMenu *menu, const QModelIndex &index);
QString m_lastDir;
QAction *m_unloadAction;
QAction *m_saveAction;
QAction *m_saveAsAction;
QAction *m_loadLandAction;
QAction *m_loadPrimitiveAction;
QAction *m_newPrimitiveAction;
QAction *m_deleteAction;
QAction *m_selectChildrenAction;
QAction *m_helpAction;
QAction *m_showAction;
QAction *m_hideAction;
QUndoStack *m_undoStack;
WorldEditorScene *m_worldEditorScene;
LandscapeEditor::ZoneBuilderBase *m_zoneBuilder;
PrimitivesTreeModel *m_primitivesTreeModel;
};
} /* namespace WorldEditor */
#endif // PRIMITIVES_VIEW_H
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef PRIMITIVES_VIEW_H
#define PRIMITIVES_VIEW_H
// Project includes
#include "primitive_item.h"
// NeL includes
#include <nel/ligo/primitive.h>
// Qt includes
#include <QtGui/QAction>
#include <QtGui/QTreeView>
#include <QtCore/QModelIndex>
#include <QtCore/QVariant>
#include <QtCore/QSignalMapper>
#include <QtGui/QUndoStack>
#include <QtGui/QItemSelection>
namespace LandscapeEditor
{
class ZoneBuilderBase;
}
namespace WorldEditor
{
class PrimitivesTreeModel;
class WorldEditorScene;
/**
@class PrimitivesView
@brief
@details
*/
class PrimitivesView : public QTreeView
{
Q_OBJECT
public:
explicit PrimitivesView(QWidget *parent = 0);
~PrimitivesView();
void setUndoStack(QUndoStack *undoStack);
void setZoneBuilder(LandscapeEditor::ZoneBuilderBase *zoneBuilder);
void setWorldScene(WorldEditorScene *worldEditorScene);
virtual void setModel(PrimitivesTreeModel *model);
private Q_SLOTS:
void loadLandscape();
void loadRootPrimitive();
void createRootPrimitive();
void selectChildren();
void save();
void saveAs();
void deletePrimitives();
void unload();
void showPrimitive();
void hidePrimitive();
void addNewPrimitiveByClass(int value);
void generatePrimitives(int value);
void openItem(int value);
protected:
void contextMenuEvent(QContextMenuEvent *event);
private:
void selectChildren(const QModelIndex &parent, QItemSelection &itemSelection);
void fillMenu_WorldEdit(QMenu *menu);
void fillMenu_Landscape(QMenu *menu);
void fillMenu_RootPrimitive(QMenu *menu, const QModelIndex &index);
void fillMenu_Primitive(QMenu *menu, const QModelIndex &index);
QString m_lastDir;
QAction *m_unloadAction;
QAction *m_saveAction;
QAction *m_saveAsAction;
QAction *m_loadLandAction;
QAction *m_loadPrimitiveAction;
QAction *m_newPrimitiveAction;
QAction *m_deleteAction;
QAction *m_selectChildrenAction;
QAction *m_helpAction;
QAction *m_showAction;
QAction *m_hideAction;
QUndoStack *m_undoStack;
WorldEditorScene *m_worldEditorScene;
LandscapeEditor::ZoneBuilderBase *m_zoneBuilder;
PrimitivesTreeModel *m_primitivesTreeModel;
};
} /* namespace WorldEditor */
#endif // PRIMITIVES_VIEW_H

136
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/project_settings_dialog.cpp
View file

@ -1,68 +1,68 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "project_settings_dialog.h"
#include "world_editor_misc.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QFileDialog>
namespace WorldEditor
{
ProjectSettingsDialog::ProjectSettingsDialog(const QString &dataPath, QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
m_ui.pathLineEdit->setText(dataPath);
m_ui.contextComboBox->addItem("empty");
// Init the combo box
const std::vector<std::string> &contexts = Utils::ligoConfig()->getContextString();
for (uint i = 0; i < contexts.size(); i++)
m_ui.contextComboBox->addItem(QString(contexts[i].c_str()));
setFixedHeight(sizeHint().height());
connect(m_ui.selectPathButton, SIGNAL(clicked()), this, SLOT(selectPath()));
}
ProjectSettingsDialog::~ProjectSettingsDialog()
{
}
QString ProjectSettingsDialog::dataPath() const
{
return m_ui.pathLineEdit->text();
}
void ProjectSettingsDialog::selectPath()
{
QString dataPath = QFileDialog::getExistingDirectory(this, tr("Select data path"), m_ui.pathLineEdit->text());
if (!dataPath.isEmpty())
m_ui.pathLineEdit->setText(dataPath);
}
} /* namespace WorldEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "project_settings_dialog.h"
#include "world_editor_misc.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include <nel/misc/debug.h>
#include <nel/ligo/ligo_config.h>
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QFileDialog>
namespace WorldEditor
{
ProjectSettingsDialog::ProjectSettingsDialog(const QString &dataPath, QWidget *parent)
: QDialog(parent)
{
m_ui.setupUi(this);
m_ui.pathLineEdit->setText(dataPath);
m_ui.contextComboBox->addItem("empty");
// Init the combo box
const std::vector<std::string> &contexts = Utils::ligoConfig()->getContextString();
for (uint i = 0; i < contexts.size(); i++)
m_ui.contextComboBox->addItem(QString(contexts[i].c_str()));
setFixedHeight(sizeHint().height());
connect(m_ui.selectPathButton, SIGNAL(clicked()), this, SLOT(selectPath()));
}
ProjectSettingsDialog::~ProjectSettingsDialog()
{
}
QString ProjectSettingsDialog::dataPath() const
{
return m_ui.pathLineEdit->text();
}
void ProjectSettingsDialog::selectPath()
{
QString dataPath = QFileDialog::getExistingDirectory(this, tr("Select data path"), m_ui.pathLineEdit->text());
if (!dataPath.isEmpty())
m_ui.pathLineEdit->setText(dataPath);
}
} /* namespace WorldEditor */

1582
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_actions.cpp
View file

File diff suppressed because it is too large Load diff

1332
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_misc.cpp
View file

File diff suppressed because it is too large Load diff

270
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_plugin.cpp
View file

@ -1,136 +1,136 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_plugin.h"
#include "world_editor_window.h"
#include "world_editor_settings_page.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include "nel/misc/debug.h"
#include <nel/misc/path.h>
#include <nel/ligo/primitive_utils.h>
#include <nel/ligo/primitive.h>
// Qt includes
#include <QtCore/QObject>
namespace WorldEditor
{
WorldEditorPlugin::~WorldEditorPlugin()
{
Q_FOREACH(QObject *obj, m_autoReleaseObjects)
{
m_plugMan->removeObject(obj);
}
qDeleteAll(m_autoReleaseObjects);
m_autoReleaseObjects.clear();
}
bool WorldEditorPlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString)
{
m_plugMan = pluginManager;
WorldEditorSettingsPage *weSettings = new WorldEditorSettingsPage(this);
addAutoReleasedObject(weSettings);
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
m_ligoConfig.CellSize = settings->value(Constants::WORLD_EDITOR_CELL_SIZE, "160").toFloat();
m_ligoConfig.Snap = settings->value(Constants::WORLD_EDITOR_SNAP, "1").toFloat();
m_ligoConfig.ZoneSnapShotRes = settings->value(Constants::ZONE_SNAPSHOT_RES, "128").toUInt();
QString fileName = settings->value(Constants::PRIMITIVE_CLASS_FILENAME, "world_editor_classes.xml").toString();
settings->endGroup();
try
{
// Search path of file world_editor_classes.xml
std::string ligoPath = NLMISC::CPath::lookup(fileName.toStdString());
// Init LIGO
m_ligoConfig.readPrimitiveClass(ligoPath.c_str(), true);
NLLIGO::Register();
NLLIGO::CPrimitiveContext::instance().CurrentLigoConfig = &m_ligoConfig;
}
catch (NLMISC::Exception &e)
{
*errorString = tr("(%1)").arg(e.what());
return false;
}
// Reset
m_ligoConfig.resetPrimitiveConfiguration ();
// TODO: get file names! from settings
m_ligoConfig.readPrimitiveClass("world_editor_primitive_configuration.xml", true);
addAutoReleasedObject(new WorldEditorContext(this));
return true;
}
void WorldEditorPlugin::extensionsInitialized()
{
}
void WorldEditorPlugin::shutdown()
{
}
void WorldEditorPlugin::setNelContext(NLMISC::INelContext *nelContext)
{
#ifdef NL_OS_WINDOWS
// Ensure that a context doesn't exist yet.
// This only applies to platforms without PIC, e.g. Windows.
nlassert(!NLMISC::INelContext::isContextInitialised());
#endif // NL_OS_WINDOWS
m_libContext = new NLMISC::CLibraryContext(*nelContext);
}
void WorldEditorPlugin::addAutoReleasedObject(QObject *obj)
{
m_plugMan->addObject(obj);
m_autoReleaseObjects.prepend(obj);
}
WorldEditorContext::WorldEditorContext(QObject *parent)
: IContext(parent),
m_worldEditorWindow(0)
{
m_worldEditorWindow = new WorldEditorWindow();
}
QUndoStack *WorldEditorContext::undoStack()
{
return m_worldEditorWindow->undoStack();
}
void WorldEditorContext::open()
{
m_worldEditorWindow->open();
}
QWidget *WorldEditorContext::widget()
{
return m_worldEditorWindow;
}
}
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_plugin.h"
#include "world_editor_window.h"
#include "world_editor_settings_page.h"
#include "../core/icore.h"
#include "../core/core_constants.h"
// NeL includes
#include "nel/misc/debug.h"
#include <nel/misc/path.h>
#include <nel/ligo/primitive_utils.h>
#include <nel/ligo/primitive.h>
// Qt includes
#include <QtCore/QObject>
namespace WorldEditor
{
WorldEditorPlugin::~WorldEditorPlugin()
{
Q_FOREACH(QObject *obj, m_autoReleaseObjects)
{
m_plugMan->removeObject(obj);
}
qDeleteAll(m_autoReleaseObjects);
m_autoReleaseObjects.clear();
}
bool WorldEditorPlugin::initialize(ExtensionSystem::IPluginManager *pluginManager, QString *errorString)
{
m_plugMan = pluginManager;
WorldEditorSettingsPage *weSettings = new WorldEditorSettingsPage(this);
addAutoReleasedObject(weSettings);
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
m_ligoConfig.CellSize = settings->value(Constants::WORLD_EDITOR_CELL_SIZE, "160").toFloat();
m_ligoConfig.Snap = settings->value(Constants::WORLD_EDITOR_SNAP, "1").toFloat();
m_ligoConfig.ZoneSnapShotRes = settings->value(Constants::ZONE_SNAPSHOT_RES, "128").toUInt();
QString fileName = settings->value(Constants::PRIMITIVE_CLASS_FILENAME, "world_editor_classes.xml").toString();
settings->endGroup();
try
{
// Search path of file world_editor_classes.xml
std::string ligoPath = NLMISC::CPath::lookup(fileName.toStdString());
// Init LIGO
m_ligoConfig.readPrimitiveClass(ligoPath.c_str(), true);
NLLIGO::Register();
NLLIGO::CPrimitiveContext::instance().CurrentLigoConfig = &m_ligoConfig;
}
catch (NLMISC::Exception &e)
{
*errorString = tr("(%1)").arg(e.what());
return false;
}
// Reset
m_ligoConfig.resetPrimitiveConfiguration ();
// TODO: get file names! from settings
m_ligoConfig.readPrimitiveClass("world_editor_primitive_configuration.xml", true);
addAutoReleasedObject(new WorldEditorContext(this));
return true;
}
void WorldEditorPlugin::extensionsInitialized()
{
}
void WorldEditorPlugin::shutdown()
{
}
void WorldEditorPlugin::setNelContext(NLMISC::INelContext *nelContext)
{
#ifdef NL_OS_WINDOWS
// Ensure that a context doesn't exist yet.
// This only applies to platforms without PIC, e.g. Windows.
nlassert(!NLMISC::INelContext::isContextInitialised());
#endif // NL_OS_WINDOWS
m_libContext = new NLMISC::CLibraryContext(*nelContext);
}
void WorldEditorPlugin::addAutoReleasedObject(QObject *obj)
{
m_plugMan->addObject(obj);
m_autoReleaseObjects.prepend(obj);
}
WorldEditorContext::WorldEditorContext(QObject *parent)
: IContext(parent),
m_worldEditorWindow(0)
{
m_worldEditorWindow = new WorldEditorWindow();
}
QUndoStack *WorldEditorContext::undoStack()
{
return m_worldEditorWindow->undoStack();
}
void WorldEditorContext::open()
{
m_worldEditorWindow->open();
}
QWidget *WorldEditorContext::widget()
{
return m_worldEditorWindow;
}
}
Q_EXPORT_PLUGIN(WorldEditor::WorldEditorPlugin)

1208
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_scene.cpp
View file

File diff suppressed because it is too large Load diff

1480
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_scene_item.cpp
View file

File diff suppressed because it is too large Load diff

140
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_settings_page.cpp
View file

@ -1,71 +1,71 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_settings_page.h"
#include "world_editor_constants.h"
// Qt includes
#include <QtGui/QWidget>
// NeL includes
namespace WorldEditor
{
WorldEditorSettingsPage::WorldEditorSettingsPage(QObject *parent)
: IOptionsPage(parent),
m_currentPage(NULL)
{
}
QString WorldEditorSettingsPage::id() const
{
return QLatin1String(Constants::WORLD_EDITOR_PLUGIN);
}
QString WorldEditorSettingsPage::trName() const
{
return tr("General");
}
QString WorldEditorSettingsPage::category() const
{
return QLatin1String(Constants::WORLD_EDITOR_PLUGIN);
}
QString WorldEditorSettingsPage::trCategory() const
{
return tr("World Editor");
}
QIcon WorldEditorSettingsPage::categoryIcon() const
{
return QIcon();
}
QWidget *WorldEditorSettingsPage::createPage(QWidget *parent)
{
m_currentPage = new QWidget(parent);
m_ui.setupUi(m_currentPage);
return m_currentPage;
}
void WorldEditorSettingsPage::apply()
{
}
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_settings_page.h"
#include "world_editor_constants.h"
// Qt includes
#include <QtGui/QWidget>
// NeL includes
namespace WorldEditor
{
WorldEditorSettingsPage::WorldEditorSettingsPage(QObject *parent)
: IOptionsPage(parent),
m_currentPage(NULL)
{
}
QString WorldEditorSettingsPage::id() const
{
return QLatin1String(Constants::WORLD_EDITOR_PLUGIN);
}
QString WorldEditorSettingsPage::trName() const
{
return tr("General");
}
QString WorldEditorSettingsPage::category() const
{
return QLatin1String(Constants::WORLD_EDITOR_PLUGIN);
}
QString WorldEditorSettingsPage::trCategory() const
{
return tr("World Editor");
}
QIcon WorldEditorSettingsPage::categoryIcon() const
{
return QIcon();
}
QWidget *WorldEditorSettingsPage::createPage(QWidget *parent)
{
m_currentPage = new QWidget(parent);
m_ui.setupUi(m_currentPage);
return m_currentPage;
}
void WorldEditorSettingsPage::apply()
{
}
} /* namespace WorldEditor */

844
code/nel/tools/3d/object_viewer_qt/src/plugins/world_editor/world_editor_window.cpp
View file

@ -1,422 +1,422 @@
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_window.h"
#include "world_editor_constants.h"
#include "primitives_model.h"
#include "world_editor_scene.h"
#include "world_editor_misc.h"
#include "world_editor_actions.h"
#include "world_editor_scene_item.h"
#include "project_settings_dialog.h"
// Core
#include "../core/icore.h"
#include "../core/menu_manager.h"
#include "../core/core_constants.h"
// Lanscape Editor plugin
#include "../landscape_editor/builder_zone_base.h"
// NeL includes
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QStatusBar>
#include <QtGui/QMessageBox>
#include <QPersistentModelIndex>
namespace WorldEditor
{
WorldEditorWindow::WorldEditorWindow(QWidget *parent)
: QMainWindow(parent),
m_primitivesModel(0),
m_undoStack(0),
m_oglWidget(0)
{
m_ui.setupUi(this);
m_undoStack = new QUndoStack(this);
m_primitivesModel = new PrimitivesTreeModel(this);
m_worldEditorScene = new WorldEditorScene(Utils::ligoConfig()->CellSize, m_primitivesModel, m_undoStack, this);
m_zoneBuilderBase = new LandscapeEditor::ZoneBuilderBase(m_worldEditorScene);
m_worldEditorScene->setZoneBuilder(m_zoneBuilderBase);
m_ui.graphicsView->setScene(m_worldEditorScene);
m_ui.graphicsView->setVisibleText(false);
m_ui.treePrimitivesView->setModel(m_primitivesModel);
m_ui.treePrimitivesView->setUndoStack(m_undoStack);
m_ui.treePrimitivesView->setZoneBuilder(m_zoneBuilderBase);
m_ui.treePrimitivesView->setWorldScene(m_worldEditorScene);
QActionGroup *sceneModeGroup = new QActionGroup(this);
sceneModeGroup->addAction(m_ui.selectAction);
sceneModeGroup->addAction(m_ui.moveAction);
sceneModeGroup->addAction(m_ui.rotateAction);
sceneModeGroup->addAction(m_ui.scaleAction);
sceneModeGroup->addAction(m_ui.turnAction);
m_ui.selectAction->setChecked(true);
m_ui.newWorldEditAction->setIcon(QIcon(Core::Constants::ICON_NEW));
m_ui.saveWorldEditAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
createMenus();
createToolBars();
readSettings();
QSignalMapper *m_modeMapper = new QSignalMapper(this);
connect(m_ui.selectAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.selectAction, 0);
connect(m_ui.moveAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.moveAction, 1);
connect(m_ui.rotateAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.rotateAction, 2);
connect(m_ui.scaleAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.scaleAction, 3);
connect(m_ui.turnAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.turnAction, 4);
connect(m_modeMapper, SIGNAL(mapped(int)), this, SLOT(setMode(int)));
connect(m_ui.pointsAction, SIGNAL(triggered(bool)), m_worldEditorScene, SLOT(setEnabledEditPoints(bool)));
connect(m_ui.settingsAction, SIGNAL(triggered()), this, SLOT(openProjectSettings()));
connect(m_ui.newWorldEditAction, SIGNAL(triggered()), this, SLOT(newWorldEditFile()));
connect(m_ui.saveWorldEditAction, SIGNAL(triggered()), this, SLOT(saveWorldEditFile()));
connect(m_ui.visibleGridAction, SIGNAL(toggled(bool)), m_ui.graphicsView, SLOT(setVisibleGrid(bool)));
connect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
connect(m_worldEditorScene, SIGNAL(updateSelectedItems(QList<QGraphicsItem *>)),
this, SLOT(selectedItemsInScene(QList<QGraphicsItem *>)));
m_statusBarTimer = new QTimer(this);
connect(m_statusBarTimer, SIGNAL(timeout()), this, SLOT(updateStatusBar()));
m_statusInfo = new QLabel(this);
m_statusInfo->hide();
Core::ICore::instance()->mainWindow()->statusBar()->addPermanentWidget(m_statusInfo);
}
WorldEditorWindow::~WorldEditorWindow()
{
writeSettings();
delete m_zoneBuilderBase;
}
QUndoStack *WorldEditorWindow::undoStack() const
{
return m_undoStack;
}
void WorldEditorWindow::maybeSave()
{
QMessageBox *messageBox = new QMessageBox(tr("World Editor"),
tr("The data has been modified.\n"
"Do you want to save your changes?"),
QMessageBox::Warning,
QMessageBox::Yes | QMessageBox::Default,
QMessageBox::No,
QMessageBox::Cancel | QMessageBox::Escape,
this, Qt::Sheet);
messageBox->setButtonText(QMessageBox::Yes,
tr("Save"));
messageBox->setButtonText(QMessageBox::No, tr("Don't Save"));
messageBox->show();
}
void WorldEditorWindow::open()
{
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open NeL World Edit file"), m_lastDir,
tr("All NeL World Editor file (*.worldedit)"));
setCursor(Qt::WaitCursor);
if (!fileName.isEmpty())
{
m_lastDir = QFileInfo(fileName).absolutePath();
loadWorldEditFile(fileName);
}
setCursor(Qt::ArrowCursor);
}
void WorldEditorWindow::loadWorldEditFile(const QString &fileName)
{
if (m_primitivesModel->isWorldEditNodeLoaded())
return;
Utils::WorldEditList worldEditList;
if (!Utils::loadWorldEditFile(fileName.toStdString(), worldEditList))
{
// TODO: add the message box
return;
}
m_undoStack->beginMacro(tr("Load %1").arg(fileName));
checkCurrentWorld();
m_undoStack->push(new CreateWorldCommand(fileName, m_primitivesModel));
for (size_t i = 0; i < worldEditList.size(); ++i)
{
switch (worldEditList[i].first)
{
case Utils::DataDirectoryType:
m_zoneBuilderBase->init(QString(worldEditList[i].second.c_str()), true);
break;
case Utils::ContextType:
break;
case Utils::LandscapeType:
m_undoStack->push(new LoadLandscapeCommand(QString(worldEditList[i].second.c_str()), m_primitivesModel, m_zoneBuilderBase));
break;
case Utils::PrimitiveType:
m_undoStack->push(new LoadRootPrimitiveCommand(QString(worldEditList[i].second.c_str()),
m_worldEditorScene, m_primitivesModel, m_ui.treePrimitivesView));
break;
};
}
m_undoStack->endMacro();
}
void WorldEditorWindow::checkCurrentWorld()
{
}
void WorldEditorWindow::newWorldEditFile()
{
checkCurrentWorld();
m_undoStack->push(new CreateWorldCommand("NewWorldEdit", m_primitivesModel));
}
void WorldEditorWindow::saveWorldEditFile()
{
}
void WorldEditorWindow::openProjectSettings()
{
ProjectSettingsDialog *dialog = new ProjectSettingsDialog(m_zoneBuilderBase->dataPath(), this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
m_zoneBuilderBase->init(dialog->dataPath(), true);
}
delete dialog;
}
void WorldEditorWindow::setMode(int value)
{
switch (value)
{
case 0:
m_worldEditorScene->setModeEdit(WorldEditorScene::SelectMode);
break;
case 1:
m_worldEditorScene->setModeEdit(WorldEditorScene::MoveMode);
break;
case 2:
m_worldEditorScene->setModeEdit(WorldEditorScene::RotateMode);
break;
case 3:
m_worldEditorScene->setModeEdit(WorldEditorScene::ScaleMode);
break;
case 4:
m_worldEditorScene->setModeEdit(WorldEditorScene::TurnMode);
break;
case 5:
m_worldEditorScene->setModeEdit(WorldEditorScene::RadiusMode);
break;
}
}
void WorldEditorWindow::updateStatusBar()
{
m_statusInfo->setText(m_worldEditorScene->zoneNameFromMousePos());
}
void WorldEditorWindow::updateSelection(const QItemSelection &selected, const QItemSelection &deselected)
{
m_ui.pointsAction->setChecked(false);
m_worldEditorScene->setEnabledEditPoints(false);
NodeList nodesSelected;
Q_FOREACH(QModelIndex modelIndex, selected.indexes())
{
Node *node = static_cast<Node *>(modelIndex.internalPointer());
nodesSelected.push_back(node);
}
NodeList nodesDeselected;
Q_FOREACH(QModelIndex modelIndex, deselected.indexes())
{
Node *node = static_cast<Node *>(modelIndex.internalPointer());
nodesDeselected.push_back(node);
}
// update property editor
if (nodesSelected.size() > 0)
{
// only single selection
m_ui.propertyEditWidget->updateSelection(nodesSelected.at(0));
}
else
{
m_ui.propertyEditWidget->clearProperties();
}
QList<QGraphicsItem *> itemSelected;
Q_FOREACH(Node *node, nodesSelected)
{
QGraphicsItem *item = getGraphicsItem(node);
if (item != 0)
itemSelected.push_back(item);
}
QList<QGraphicsItem *> itemDeselected;
Q_FOREACH(Node *node, nodesDeselected)
{
QGraphicsItem *item = getGraphicsItem(node);
if (item != 0)
itemDeselected.push_back(item);
}
// Update world editor scene
m_worldEditorScene->updateSelection(itemSelected, itemDeselected);
}
void WorldEditorWindow::selectedItemsInScene(const QList<QGraphicsItem *> &selected)
{
QItemSelectionModel *selectionModel = m_ui.treePrimitivesView->selectionModel();
disconnect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
selectionModel->clear();
QItemSelection itemSelection;
Q_FOREACH(QGraphicsItem *item, selected)
{
QPersistentModelIndex *index = qvariant_cast<QPersistentModelIndex *>(item->data(Constants::NODE_PERISTENT_INDEX));
if (index->isValid())
{
QModelIndex modelIndex = index->operator const QModelIndex &();
QItemSelection mergeItemSelection(modelIndex, modelIndex);
itemSelection.merge(mergeItemSelection, QItemSelectionModel::Select);
}
QApplication::processEvents();
}
selectionModel->select(itemSelection, QItemSelectionModel::Select);
// update property editor
if (!selected.isEmpty())
{
// only single selection
Node *node = qvariant_cast<Node *>(selected.at(0)->data(Constants::WORLD_EDITOR_NODE));
m_ui.propertyEditWidget->updateSelection(node);
}
else
{
m_ui.propertyEditWidget->clearProperties();
}
connect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
}
void WorldEditorWindow::showEvent(QShowEvent *showEvent)
{
QMainWindow::showEvent(showEvent);
if (m_oglWidget != 0)
m_oglWidget->makeCurrent();
m_statusInfo->show();
m_statusBarTimer->start(100);
}
void WorldEditorWindow::hideEvent(QHideEvent *hideEvent)
{
QMainWindow::hideEvent(hideEvent);
m_statusInfo->hide();
m_statusBarTimer->stop();
}
void WorldEditorWindow::createMenus()
{
//Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
}
void WorldEditorWindow::createToolBars()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
//QAction *action = menuManager->action(Core::Constants::NEW);
//m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.newWorldEditAction);
QAction *action = menuManager->action(Core::Constants::OPEN);
m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.saveWorldEditAction);
m_ui.fileToolBar->addSeparator();
action = menuManager->action(Core::Constants::UNDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
action = menuManager->action(Core::Constants::REDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE_AS);
//m_ui.fileToolBar->addAction(action);
}
void WorldEditorWindow::readSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
restoreState(settings->value(Constants::WORLD_WINDOW_STATE).toByteArray());
restoreGeometry(settings->value(Constants::WORLD_WINDOW_GEOMETRY).toByteArray());
// Use OpenGL graphics system instead raster graphics system
if (settings->value(Constants::WORLD_EDITOR_USE_OPENGL, true).toBool())
{
m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer));
//m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::SampleBuffers));
m_ui.graphicsView->setViewport(m_oglWidget);
}
settings->endGroup();
}
void WorldEditorWindow::writeSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
settings->setValue(Constants::WORLD_WINDOW_STATE, saveState());
settings->setValue(Constants::WORLD_WINDOW_GEOMETRY, saveGeometry());
settings->endGroup();
settings->sync();
}
} /* namespace LandscapeEditor */
// Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2011 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 Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// Project includes
#include "world_editor_window.h"
#include "world_editor_constants.h"
#include "primitives_model.h"
#include "world_editor_scene.h"
#include "world_editor_misc.h"
#include "world_editor_actions.h"
#include "world_editor_scene_item.h"
#include "project_settings_dialog.h"
// Core
#include "../core/icore.h"
#include "../core/menu_manager.h"
#include "../core/core_constants.h"
// Lanscape Editor plugin
#include "../landscape_editor/builder_zone_base.h"
// NeL includes
// Qt includes
#include <QtCore/QSettings>
#include <QtGui/QFileDialog>
#include <QtGui/QStatusBar>
#include <QtGui/QMessageBox>
#include <QPersistentModelIndex>
namespace WorldEditor
{
WorldEditorWindow::WorldEditorWindow(QWidget *parent)
: QMainWindow(parent),
m_primitivesModel(0),
m_undoStack(0),
m_oglWidget(0)
{
m_ui.setupUi(this);
m_undoStack = new QUndoStack(this);
m_primitivesModel = new PrimitivesTreeModel(this);
m_worldEditorScene = new WorldEditorScene(Utils::ligoConfig()->CellSize, m_primitivesModel, m_undoStack, this);
m_zoneBuilderBase = new LandscapeEditor::ZoneBuilderBase(m_worldEditorScene);
m_worldEditorScene->setZoneBuilder(m_zoneBuilderBase);
m_ui.graphicsView->setScene(m_worldEditorScene);
m_ui.graphicsView->setVisibleText(false);
m_ui.treePrimitivesView->setModel(m_primitivesModel);
m_ui.treePrimitivesView->setUndoStack(m_undoStack);
m_ui.treePrimitivesView->setZoneBuilder(m_zoneBuilderBase);
m_ui.treePrimitivesView->setWorldScene(m_worldEditorScene);
QActionGroup *sceneModeGroup = new QActionGroup(this);
sceneModeGroup->addAction(m_ui.selectAction);
sceneModeGroup->addAction(m_ui.moveAction);
sceneModeGroup->addAction(m_ui.rotateAction);
sceneModeGroup->addAction(m_ui.scaleAction);
sceneModeGroup->addAction(m_ui.turnAction);
m_ui.selectAction->setChecked(true);
m_ui.newWorldEditAction->setIcon(QIcon(Core::Constants::ICON_NEW));
m_ui.saveWorldEditAction->setIcon(QIcon(Core::Constants::ICON_SAVE));
createMenus();
createToolBars();
readSettings();
QSignalMapper *m_modeMapper = new QSignalMapper(this);
connect(m_ui.selectAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.selectAction, 0);
connect(m_ui.moveAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.moveAction, 1);
connect(m_ui.rotateAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.rotateAction, 2);
connect(m_ui.scaleAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.scaleAction, 3);
connect(m_ui.turnAction, SIGNAL(triggered()), m_modeMapper, SLOT(map()));
m_modeMapper->setMapping(m_ui.turnAction, 4);
connect(m_modeMapper, SIGNAL(mapped(int)), this, SLOT(setMode(int)));
connect(m_ui.pointsAction, SIGNAL(triggered(bool)), m_worldEditorScene, SLOT(setEnabledEditPoints(bool)));
connect(m_ui.settingsAction, SIGNAL(triggered()), this, SLOT(openProjectSettings()));
connect(m_ui.newWorldEditAction, SIGNAL(triggered()), this, SLOT(newWorldEditFile()));
connect(m_ui.saveWorldEditAction, SIGNAL(triggered()), this, SLOT(saveWorldEditFile()));
connect(m_ui.visibleGridAction, SIGNAL(toggled(bool)), m_ui.graphicsView, SLOT(setVisibleGrid(bool)));
connect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
connect(m_worldEditorScene, SIGNAL(updateSelectedItems(QList<QGraphicsItem *>)),
this, SLOT(selectedItemsInScene(QList<QGraphicsItem *>)));
m_statusBarTimer = new QTimer(this);
connect(m_statusBarTimer, SIGNAL(timeout()), this, SLOT(updateStatusBar()));
m_statusInfo = new QLabel(this);
m_statusInfo->hide();
Core::ICore::instance()->mainWindow()->statusBar()->addPermanentWidget(m_statusInfo);
}
WorldEditorWindow::~WorldEditorWindow()
{
writeSettings();
delete m_zoneBuilderBase;
}
QUndoStack *WorldEditorWindow::undoStack() const
{
return m_undoStack;
}
void WorldEditorWindow::maybeSave()
{
QMessageBox *messageBox = new QMessageBox(tr("World Editor"),
tr("The data has been modified.\n"
"Do you want to save your changes?"),
QMessageBox::Warning,
QMessageBox::Yes | QMessageBox::Default,
QMessageBox::No,
QMessageBox::Cancel | QMessageBox::Escape,
this, Qt::Sheet);
messageBox->setButtonText(QMessageBox::Yes,
tr("Save"));
messageBox->setButtonText(QMessageBox::No, tr("Don't Save"));
messageBox->show();
}
void WorldEditorWindow::open()
{
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open NeL World Edit file"), m_lastDir,
tr("All NeL World Editor file (*.worldedit)"));
setCursor(Qt::WaitCursor);
if (!fileName.isEmpty())
{
m_lastDir = QFileInfo(fileName).absolutePath();
loadWorldEditFile(fileName);
}
setCursor(Qt::ArrowCursor);
}
void WorldEditorWindow::loadWorldEditFile(const QString &fileName)
{
if (m_primitivesModel->isWorldEditNodeLoaded())
return;
Utils::WorldEditList worldEditList;
if (!Utils::loadWorldEditFile(fileName.toStdString(), worldEditList))
{
// TODO: add the message box
return;
}
m_undoStack->beginMacro(tr("Load %1").arg(fileName));
checkCurrentWorld();
m_undoStack->push(new CreateWorldCommand(fileName, m_primitivesModel));
for (size_t i = 0; i < worldEditList.size(); ++i)
{
switch (worldEditList[i].first)
{
case Utils::DataDirectoryType:
m_zoneBuilderBase->init(QString(worldEditList[i].second.c_str()), true);
break;
case Utils::ContextType:
break;
case Utils::LandscapeType:
m_undoStack->push(new LoadLandscapeCommand(QString(worldEditList[i].second.c_str()), m_primitivesModel, m_zoneBuilderBase));
break;
case Utils::PrimitiveType:
m_undoStack->push(new LoadRootPrimitiveCommand(QString(worldEditList[i].second.c_str()),
m_worldEditorScene, m_primitivesModel, m_ui.treePrimitivesView));
break;
};
}
m_undoStack->endMacro();
}
void WorldEditorWindow::checkCurrentWorld()
{
}
void WorldEditorWindow::newWorldEditFile()
{
checkCurrentWorld();
m_undoStack->push(new CreateWorldCommand("NewWorldEdit", m_primitivesModel));
}
void WorldEditorWindow::saveWorldEditFile()
{
}
void WorldEditorWindow::openProjectSettings()
{
ProjectSettingsDialog *dialog = new ProjectSettingsDialog(m_zoneBuilderBase->dataPath(), this);
dialog->show();
int ok = dialog->exec();
if (ok == QDialog::Accepted)
{
m_zoneBuilderBase->init(dialog->dataPath(), true);
}
delete dialog;
}
void WorldEditorWindow::setMode(int value)
{
switch (value)
{
case 0:
m_worldEditorScene->setModeEdit(WorldEditorScene::SelectMode);
break;
case 1:
m_worldEditorScene->setModeEdit(WorldEditorScene::MoveMode);
break;
case 2:
m_worldEditorScene->setModeEdit(WorldEditorScene::RotateMode);
break;
case 3:
m_worldEditorScene->setModeEdit(WorldEditorScene::ScaleMode);
break;
case 4:
m_worldEditorScene->setModeEdit(WorldEditorScene::TurnMode);
break;
case 5:
m_worldEditorScene->setModeEdit(WorldEditorScene::RadiusMode);
break;
}
}
void WorldEditorWindow::updateStatusBar()
{
m_statusInfo->setText(m_worldEditorScene->zoneNameFromMousePos());
}
void WorldEditorWindow::updateSelection(const QItemSelection &selected, const QItemSelection &deselected)
{
m_ui.pointsAction->setChecked(false);
m_worldEditorScene->setEnabledEditPoints(false);
NodeList nodesSelected;
Q_FOREACH(QModelIndex modelIndex, selected.indexes())
{
Node *node = static_cast<Node *>(modelIndex.internalPointer());
nodesSelected.push_back(node);
}
NodeList nodesDeselected;
Q_FOREACH(QModelIndex modelIndex, deselected.indexes())
{
Node *node = static_cast<Node *>(modelIndex.internalPointer());
nodesDeselected.push_back(node);
}
// update property editor
if (nodesSelected.size() > 0)
{
// only single selection
m_ui.propertyEditWidget->updateSelection(nodesSelected.at(0));
}
else
{
m_ui.propertyEditWidget->clearProperties();
}
QList<QGraphicsItem *> itemSelected;
Q_FOREACH(Node *node, nodesSelected)
{
QGraphicsItem *item = getGraphicsItem(node);
if (item != 0)
itemSelected.push_back(item);
}
QList<QGraphicsItem *> itemDeselected;
Q_FOREACH(Node *node, nodesDeselected)
{
QGraphicsItem *item = getGraphicsItem(node);
if (item != 0)
itemDeselected.push_back(item);
}
// Update world editor scene
m_worldEditorScene->updateSelection(itemSelected, itemDeselected);
}
void WorldEditorWindow::selectedItemsInScene(const QList<QGraphicsItem *> &selected)
{
QItemSelectionModel *selectionModel = m_ui.treePrimitivesView->selectionModel();
disconnect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
selectionModel->clear();
QItemSelection itemSelection;
Q_FOREACH(QGraphicsItem *item, selected)
{
QPersistentModelIndex *index = qvariant_cast<QPersistentModelIndex *>(item->data(Constants::NODE_PERISTENT_INDEX));
if (index->isValid())
{
QModelIndex modelIndex = index->operator const QModelIndex &();
QItemSelection mergeItemSelection(modelIndex, modelIndex);
itemSelection.merge(mergeItemSelection, QItemSelectionModel::Select);
}
QApplication::processEvents();
}
selectionModel->select(itemSelection, QItemSelectionModel::Select);
// update property editor
if (!selected.isEmpty())
{
// only single selection
Node *node = qvariant_cast<Node *>(selected.at(0)->data(Constants::WORLD_EDITOR_NODE));
m_ui.propertyEditWidget->updateSelection(node);
}
else
{
m_ui.propertyEditWidget->clearProperties();
}
connect(m_ui.treePrimitivesView->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
this, SLOT(updateSelection(QItemSelection, QItemSelection)));
}
void WorldEditorWindow::showEvent(QShowEvent *showEvent)
{
QMainWindow::showEvent(showEvent);
if (m_oglWidget != 0)
m_oglWidget->makeCurrent();
m_statusInfo->show();
m_statusBarTimer->start(100);
}
void WorldEditorWindow::hideEvent(QHideEvent *hideEvent)
{
QMainWindow::hideEvent(hideEvent);
m_statusInfo->hide();
m_statusBarTimer->stop();
}
void WorldEditorWindow::createMenus()
{
//Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
}
void WorldEditorWindow::createToolBars()
{
Core::MenuManager *menuManager = Core::ICore::instance()->menuManager();
//QAction *action = menuManager->action(Core::Constants::NEW);
//m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.newWorldEditAction);
QAction *action = menuManager->action(Core::Constants::OPEN);
m_ui.fileToolBar->addAction(action);
m_ui.fileToolBar->addAction(m_ui.saveWorldEditAction);
m_ui.fileToolBar->addSeparator();
action = menuManager->action(Core::Constants::UNDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
action = menuManager->action(Core::Constants::REDO);
if (action != 0)
m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE);
//m_ui.fileToolBar->addAction(action);
//action = menuManager->action(Core::Constants::SAVE_AS);
//m_ui.fileToolBar->addAction(action);
}
void WorldEditorWindow::readSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
restoreState(settings->value(Constants::WORLD_WINDOW_STATE).toByteArray());
restoreGeometry(settings->value(Constants::WORLD_WINDOW_GEOMETRY).toByteArray());
// Use OpenGL graphics system instead raster graphics system
if (settings->value(Constants::WORLD_EDITOR_USE_OPENGL, true).toBool())
{
m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer));
//m_oglWidget = new QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::SampleBuffers));
m_ui.graphicsView->setViewport(m_oglWidget);
}
settings->endGroup();
}
void WorldEditorWindow::writeSettings()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(Constants::WORLD_EDITOR_SECTION);
settings->setValue(Constants::WORLD_WINDOW_STATE, saveState());
settings->setValue(Constants::WORLD_WINDOW_GEOMETRY, saveGeometry());
settings->endGroup();
settings->sync();
}
} /* namespace LandscapeEditor */