483 lines
17 KiB
C++
Executable File
483 lines
17 KiB
C++
Executable File
#pragma once
|
|
|
|
#include <dtEntity/entityid.h>
|
|
#include <osg/BoundingBox>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <osg/Vec3>
|
|
#include <osg/Vec4>
|
|
#include <osg/Matrix>
|
|
#include <osg/Geode>
|
|
#include <dtEntity/message.h>
|
|
|
|
#include <QMutex>
|
|
#include <QMutexLocker>
|
|
#include <QPolygonF>
|
|
|
|
#include <set>
|
|
#include <map>
|
|
#include <functional>
|
|
#include "viewerinterface.h"
|
|
#include "cameraviewposition.h"
|
|
#include "logger.h"
|
|
|
|
namespace dtEntity
|
|
{
|
|
class EntityManager;
|
|
}
|
|
|
|
namespace VCtrl
|
|
{
|
|
class IconComponent;
|
|
class TextComponent;
|
|
class ViewWidget;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct OBB
|
|
{
|
|
osg::Matrix mMatrix;
|
|
osg::Matrix mMatrixInverse;
|
|
osg::BoundingBox mBB;
|
|
QPolygonF mPoly;
|
|
dtEntity::StringId mBuilding = 0;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct BuildingData
|
|
{
|
|
std::string mDescription;
|
|
std::string mDisplayName;
|
|
std::string mFeatureId;
|
|
std::string mFileName;
|
|
std::string mBuildingXMLPath;
|
|
double mX = 0;
|
|
double mY = 0;
|
|
double mZ = 0;
|
|
double mOrientation = 0;
|
|
int mBuildingGroup = 0;
|
|
bool properlySpawned = false;
|
|
bool roomBBoxedLoaded = false;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct BuildingLevel
|
|
{
|
|
// entity id of visible entity in building view
|
|
dtEntity::EntityId mEntityId;
|
|
|
|
// floorId of xml file (-1 for floor_-1; 2 for floor_2...)
|
|
int mFloorId;
|
|
|
|
// height of lowest walkable area in level above building origin
|
|
float mHeightAboveGround;
|
|
|
|
// transforms from building local space to level local space
|
|
osg::Matrix mLocalToLevel;
|
|
|
|
// bounding box of level in world space (untransformed by view mode)
|
|
osg::BoundingBox mBounds;
|
|
|
|
BuildingLevel(dtEntity::EntityId eid, int floorId, float h, const osg::BoundingBox &bb)
|
|
: mEntityId(eid), mFloorId(floorId), mHeightAboveGround(h), mBounds(bb)
|
|
{
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct PlayerPosition
|
|
{
|
|
osg::Vec2d mPosition;
|
|
dtEntity::EntityId mWorldPlayerId = 0;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct PlayerDisplay
|
|
{
|
|
dtEntity::EntityId mWorldPlayerId = 0;
|
|
dtEntity::EntityId mLocalPlayerId = 0;
|
|
IconComponent *mIcon = nullptr;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct Device
|
|
{
|
|
dtEntity::EntityId mWorldPlayerId = 0;
|
|
std::string mPath;
|
|
osg::Vec3d mPosition;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct DeviceDisplay
|
|
{
|
|
Device *mDevice = nullptr;
|
|
dtEntity::EntityId mWorldPlayerId = 0;
|
|
dtEntity::EntityId mLocalPlayerId = 0;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct Name
|
|
{
|
|
dtEntity::EntityId mWorldPlayerId;
|
|
std::string mtext;
|
|
std::string mdistext;
|
|
std::string mbuilding;
|
|
osg::Vec3d mPosition;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct NameDisplay
|
|
{
|
|
Name* mName = nullptr;
|
|
dtEntity::EntityId mWorldPlayerId = 0;
|
|
dtEntity::EntityId mLocalPlayerId = 0;
|
|
bool visible = false;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
class Shot
|
|
{
|
|
public:
|
|
Shot(const int32_t id,
|
|
const osg::Vec3d& shooterPos,
|
|
const osg::Vec3d& targetPos,
|
|
int buildingIdSrc,
|
|
int rommNumberSrc,
|
|
int buildingIdDst,
|
|
int rommNumberDst,
|
|
int lineType,
|
|
const osg::Vec4& color,
|
|
unsigned int duration_s,
|
|
unsigned int durationMax_s,
|
|
double simTimeCreated) :
|
|
mId(id)
|
|
, mShooterPos(shooterPos)
|
|
, mTargetPos(targetPos)
|
|
, mBuildingIdSrc(buildingIdSrc)
|
|
, mRoomNumberSrc(rommNumberSrc)
|
|
, mBuildingIdDst(buildingIdDst)
|
|
, mRoomNumberDst(rommNumberDst)
|
|
, mLineType(lineType)
|
|
, mColor(color)
|
|
, mDuration_s(duration_s)
|
|
, m_DurationMax_s(durationMax_s)
|
|
, mSimTimeCreated(simTimeCreated) {
|
|
|
|
}
|
|
|
|
void setDisplayTime(unsigned int duration_s) {
|
|
if(duration_s > m_DurationMax_s)
|
|
m_DurationMax_s = duration_s;
|
|
mDuration_s = duration_s;
|
|
}
|
|
double simTimeCreated() const {
|
|
return mSimTimeCreated;
|
|
}
|
|
|
|
double displayTime() const {
|
|
return mSimTimeCreated + mDuration_s;
|
|
}
|
|
|
|
double lifeTime() const {
|
|
return mSimTimeCreated + (m_DurationMax_s*2);
|
|
}
|
|
|
|
const osg::Vec3d& getShooterPos() const { return mShooterPos; }
|
|
const osg::Vec3d& getTargetPos() const { return mTargetPos; }
|
|
int getBuildingIdSrc() const { return mBuildingIdSrc; }
|
|
double getSimeTimeCreated() const { return mSimTimeCreated; }
|
|
int getRoomNumberSrc() const { return mRoomNumberSrc; }
|
|
int getBuildingIdDst() const { return mBuildingIdDst; }
|
|
int getRoomNumberDst() const { return mRoomNumberDst; }
|
|
int getDuration() const { return mDuration_s; }
|
|
int getLineType() const { return mLineType; }
|
|
|
|
const osg::Vec4& getColor() const { return mColor; }
|
|
int32_t getId() const { return mId; }
|
|
|
|
private:
|
|
int32_t mId;
|
|
osg::Vec3d mShooterPos;
|
|
osg::Vec3d mTargetPos;
|
|
int mBuildingIdSrc;
|
|
int mRoomNumberSrc;
|
|
int mBuildingIdDst;
|
|
int mRoomNumberDst;
|
|
int mLineType;
|
|
osg::Vec4 mColor;
|
|
unsigned int mDuration_s, m_DurationMax_s;
|
|
double mSimTimeCreated;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct ShotDisplay
|
|
{
|
|
Shot *mShot = nullptr;
|
|
osg::ref_ptr<osg::Geode> mGeode;
|
|
};
|
|
|
|
// fwd decl
|
|
struct Building;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// \brief The BuildingDisplay struct
|
|
|
|
class OrthoMotionModelComponent;
|
|
|
|
struct BuildingDisplay
|
|
{
|
|
// context id of this display
|
|
unsigned int mContextId = 0;
|
|
|
|
// local entity holding building data
|
|
dtEntity::EntityId mAttachPointId = 0;
|
|
|
|
// all levels in building
|
|
std::vector<BuildingLevel> mLevels;
|
|
|
|
// combined bounding box of all levels of building without viewmode transformation
|
|
osg::BoundingBox mWorldBounds;
|
|
|
|
// combined bounding box of all levels of building with viewmode transformation
|
|
osg::BoundingBox mLocalBounds;
|
|
|
|
// entity id of camera entity
|
|
dtEntity::EntityId mCameraId = 0;
|
|
|
|
// entity id of orthomotionmodel entity
|
|
dtEntity::EntityId mMotionModelId = 0;
|
|
OrthoMotionModelComponent *pMotion = nullptr;
|
|
|
|
// entity id of light source entity
|
|
dtEntity::EntityId mLightId = 0;
|
|
|
|
// display players as dots or as icons?
|
|
PlayerDisplayMode mPlayerDisplayMode = PlayerDisplayMode::Icons;
|
|
|
|
// how are the buildings projected?
|
|
ViewMode mViewMode = ViewMode::ISOMETRIC;
|
|
|
|
// all players currently displayed in this building
|
|
std::vector<PlayerDisplay> mPlayers;
|
|
|
|
// shoot lines currently displayed
|
|
std::vector<ShotDisplay> mShotDisplays;
|
|
|
|
// all players currently displayed in this building
|
|
std::vector<DeviceDisplay> mDeviceDisplays;
|
|
|
|
// all names currently displayed in this building
|
|
std::vector<NameDisplay> mNameDisplays;
|
|
|
|
// should camera rotation be locked to global map rotation?
|
|
bool mLockRotation = false;
|
|
|
|
// are the roomNames shown?
|
|
bool mNameMode = false;
|
|
|
|
// how are the shoot Lines displayed?
|
|
bool mLineMode = false;
|
|
|
|
BuildingDisplay() = default;
|
|
|
|
BuildingDisplay(unsigned int contextid, ViewMode vm)
|
|
: mContextId(contextid)
|
|
, mViewMode(vm)
|
|
{
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
struct Building
|
|
{
|
|
// building entity in world space
|
|
dtEntity::EntityId mWorldBuildingId = 0;
|
|
|
|
// all currently open displays of this building
|
|
std::vector<BuildingDisplay> mDisplays;
|
|
|
|
// transformation of building in world space
|
|
osg::Matrix mWorldToLocal;
|
|
|
|
// transformation of building in world space
|
|
osg::Matrix mLocalToWorld;
|
|
|
|
// used for assigning walking entities to buildings
|
|
std::string mNavMeshGrpName;
|
|
|
|
// stores shot data
|
|
std::vector<Shot *> mShots;
|
|
|
|
// stores device data
|
|
std::vector<Device *> mDevices;
|
|
|
|
// Building Display Name
|
|
std::string mBuildingDisplayName;
|
|
|
|
// stores name data
|
|
std::vector<Name*> mNames;
|
|
|
|
// the corresponding feature id from the xml file
|
|
std::string mFeatureId;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
class BuildingManager
|
|
{
|
|
|
|
public:
|
|
|
|
explicit BuildingManager(dtEntity::EntityManager &em);
|
|
~BuildingManager();
|
|
|
|
void addBuilding(dtEntity::EntityId buildingid, const std::string &featureId);
|
|
void deleteAllBuildings();
|
|
|
|
BuildingDisplay *getBuildingDisplay(unsigned int contextid);
|
|
void applyViewModeToBuildingParts(const Building &bldg, BuildingDisplay &dspl) const;
|
|
|
|
bool displayBuilding(const std::string& featureId, unsigned int contextid, dtEntity::EntityId buildingid, const osg::Vec4 &bgcolor, ViewMode viewmode, bool exactPos);
|
|
bool displayBuilding(unsigned int contextid, dtEntity::EntityId buildingid, const osg::Vec4 &bgcolor, ViewMode viewmode, bool exactPos);
|
|
|
|
bool setCameraPosition(unsigned int contextid, const BuildingViewer::CameraViewPosition& pos);
|
|
bool getCameraPosition(unsigned int contextid, BuildingViewer::CameraViewPosition& pos);
|
|
bool setDefaultCameraPosition(unsigned int contextid);
|
|
|
|
void closeBuildingDisplay(unsigned int contextid);
|
|
void changeViewMode(unsigned int contextId, ViewMode viewmode, bool useOriginViewPos = true);
|
|
void changeLineMode(unsigned int contextId, bool line);
|
|
void changeNameMode(unsigned int contextId, bool name);
|
|
|
|
void applyMapRotation(const Building &bd, BuildingDisplay &dspl);
|
|
void lockViewRotationToMapRotation(unsigned int contextId, bool lock);
|
|
void setPlayerDisplayMode(unsigned int contextId, PlayerDisplayMode mode);
|
|
void setWallTransparency(unsigned int contextId, float value);
|
|
|
|
float getMapRotation() const;
|
|
void setMapRotation(float angle);
|
|
|
|
void openOverview(unsigned int contextid);
|
|
|
|
void addPlayerToBuildings(const std::string &navmeshgrpname, dtEntity::EntityId eid,
|
|
const osg::Vec4 &color, const std::string &symbol,
|
|
const osg::Vec3d &pos, bool visible);
|
|
void removePlayerFromBuilding(const std::string &navmeshgrpname, dtEntity::EntityId eid, const std::string &roomname);
|
|
void updatePlayerPosition(const std::string &navmeshgrpname, dtEntity::EntityId eid,
|
|
const osg::Vec3d &pos, int roomNumber);
|
|
|
|
osg::Vec3d remapPosition(const Building &bd, const BuildingDisplay &dspl, const osg::Vec3d &world, int roomNumber = -1);
|
|
|
|
void setPlayerColor(dtEntity::EntityId eid, const osg::Vec4 &color);
|
|
void setPlayerIcon(dtEntity::EntityId eid, const std::string &path);
|
|
void reloadPlayerIcons();
|
|
void updatePlayerPartyColor(dtEntity::EntityId eid, const VCtrl::Color& col);
|
|
void setShowPlayerSelection(dtEntity::EntityId eid, bool show);
|
|
void setShowDisplayNamesSelection(dtEntity::EntityId eid, bool show);
|
|
void setShowHidePlayer(dtEntity::EntityId eid, bool show);
|
|
void setShowHideDisplayNames(dtEntity::EntityId eid, unsigned int contextId, bool show);
|
|
void setRoomDestructionValue(dtEntity::EntityId eid, const std::string &roomname, float value);
|
|
void setBuildingDestructionValue(dtEntity::EntityId eid, float value);
|
|
void setBuildingDisplayName(const std::string& featureId, dtEntity::EntityId eid, const std::string& strDisplayName);
|
|
void setBuildingDisplayName(dtEntity::EntityId eid, const std::string& strDisplayName);
|
|
void setRoomDisplayName(const std::string& featureId, dtEntity::EntityId eid, const std::string& roomname, const std::string& strDisplayName);
|
|
void setRoomDisplayName(Building *building, const std::string &roomname, const std::string& strDisplayName);
|
|
|
|
void removeShoot(int32_t id);
|
|
void showShoot(int32_t id, dtEntity::EntityId shooter, dtEntity::EntityId target,
|
|
const dtEntity::Vec3d &shooterPos, const dtEntity::Vec3d &targetPos, int buildingIdSrc, int roomNumberSrc,
|
|
int buildingIdDst, int roomNumberDst, int lineType, float duration, double simTimeCreated);
|
|
|
|
dtEntity::EntityId getWorldPlayerIdFromLocalPlayer(dtEntity::EntityId local) const;
|
|
dtEntity::EntityId getWorldNameIdFromLocalName(dtEntity::EntityId local, std::string &buildingName, std::string &room) const;
|
|
|
|
void addDeviceToBuilding(dtEntity::EntityId iconmainid, dtEntity::EntityId buildingid,
|
|
const osg::Vec3d &pos, const std::string &iconpath);
|
|
void removeDeviceFromBuilding(dtEntity::EntityId iconmainid);
|
|
|
|
|
|
// Load building XML and add room OBBs to tree
|
|
bool AddRoomOBBs(const BuildingData &);
|
|
const std::map<std::string, VCtrl::OBB> &GetRoomOBBs() const { return mRooms; }
|
|
|
|
// Look up room OBB, return true if room exists
|
|
bool getRoomBounds(const std::string &bldgname, const std::string &roomname, VCtrl::OBB &obb) const;
|
|
|
|
|
|
bool LoadBuildings(const std::string &path, std::vector<BuildingData> &);
|
|
|
|
size_t getNumBuildings() const;
|
|
void getBuildingIds(std::vector<dtEntity::EntityId> &toFill) const;
|
|
dtEntity::EntityId getNextBuilding(const osg::Vec3d &pos, float &distance, std::string &featureId) const;
|
|
Building getBuildingFromFeatureId(const std::string &bldname) const;
|
|
|
|
// all players currently in this room
|
|
using RoomPlayers = std::vector<PlayerPosition>;
|
|
// add player to room
|
|
osg::Vec2d AddRoomUsages(const std::string& bldgname, const std::string& roomname, VCtrl::PlayerPosition& playPos);
|
|
const std::map<std::string, RoomPlayers> &GetRoomUsages() const { return mUsedRooms; }
|
|
// delete player in room
|
|
void deleteRoomUsagePlayer(const std::string& bldgname, const std::string& roomname, dtEntity::EntityId playerId);
|
|
void SetExactPos(bool exactPos) { mExactPos = exactPos; }
|
|
bool GetExactPos() const { return mExactPos; }
|
|
void updateShotDuration(unsigned int newDuration_s);
|
|
using CallbackCamPosChanged = std::function<void(unsigned int, const BuildingViewer::CameraViewPosition &)>;
|
|
void setCallbackCamPosChanged(const CallbackCamPosChanged &cb);
|
|
|
|
private:
|
|
void updateShots(const Building &bd, BuildingDisplay &dspl);
|
|
void updateDevices(const Building &bd, BuildingDisplay &dspl);
|
|
void createRoomNames(dtEntity::EntityId buildingid, Building& building);
|
|
void updateNames(const Building& bd, BuildingDisplay& dspl);
|
|
void repositionCamera(const Building &bd, const BuildingDisplay &dspl, bool useOriginViewPos = true);
|
|
void updatePlayerPositions(const Building &bd, BuildingDisplay &dspl);
|
|
void addPlayerToBuilding(const Building &bd, BuildingDisplay &dspl, dtEntity::EntityId eid,
|
|
const osg::Vec4 &color, const std::string &symbol, const osg::Vec3d &pos,
|
|
bool visible);
|
|
static osg::Vec2d shiftPosition(const VCtrl::OBB& obb, const osg::Vec2d& pos, double& shiftValue);
|
|
void cameraViewPositionChanged(unsigned int contextId, const BuildingViewer::CameraViewPosition &viewPos);
|
|
|
|
std::set<unsigned int> m_setInitialCameraPositionSet; // If an context ID of a building is included in this set the initial camera position had been set
|
|
|
|
std::map<std::string, std::map<std::string, std::string>> m_mapBuildingRoomNames; // Maps a building feature id (not the dtEntity::EntityId!) to the building's room names
|
|
std::map<std::string, std::string> m_mapBuildingDisplayNames; // key = feature id value = BuildingDisplayName
|
|
dtEntity::EntityManager *mEntityManager;
|
|
|
|
std::vector<Building *> mBuildings;
|
|
QMutex m_mutexShots;
|
|
|
|
bool mShotOverview;
|
|
bool mExactPos;
|
|
float mMapRotation;
|
|
dtEntity::MessageFunctor mTickFunctor;
|
|
|
|
void Tick(const dtEntity::Message &message);
|
|
|
|
std::map<std::string, VCtrl::OBB> mRooms;
|
|
std::map<std::string, RoomPlayers> mUsedRooms;
|
|
CallbackCamPosChanged mCbCamPosChanged;
|
|
|
|
// NLDEVCTRL-495
|
|
// Die Positionierung der a) TeilnehmerSymbole, b) RaumBezeichner und c) Trefferlinien der Kanalisation ist problembehaftet.
|
|
// Bei Raum 027 und 028 der Kanalisation wurde der RaumBezeichner nicht im unteren Level, sondern im darüberliegenden Level dargestellt.
|
|
// Level entspricht den floors/Ebenen in der Standard-Darstellung isometric, also in "gespreizter" Darstellung.
|
|
// Als Ursache hat sich Ansatz in BuildingManager::remapPosition() herausgestellt. Beim Remapping wird versucht, die aktuelle Position aufgrund des z-Wertes einem Floor/Level zuzuordnen. Wenn die Gebäude waagerechte Floors haben, funktioniert dies sehr gut.
|
|
// Die Kanalisation weist aber im linken Bereich (Raum 027 und 028) einen Anstieg auf. Betritt also ein Teilnehmer einen der Räume, so wird aufgrund seines z-Wertes die darüberliegenden Etage ermittelt und der Tln "zu hoch" angezeigt.
|
|
// Lösung:
|
|
// Beim Einlesen der Struktur-XML-Datei wird ein Lookup-Table erstellt. mRoomToFloorPerBldg stellt dann zu jedem Raum den Floor zur Verfügung.
|
|
// Bei Positionsmeldungen wird Bldg/Room durchgereicht, sodass es beim Remapping einbezogen werden kann.
|
|
// Bei der Darstellung der RaumBezeichner verhält es sich analog.
|
|
// Bei den Trefferlinien beinhaltet das DDS-Topic HitLineInfo den Information Bldg/Room nur für den Getroffenen. Daher wird die Peilspitze der Trefferlinien korrekt dargestellt.
|
|
// ToDo:
|
|
// Der Ursprung der Trefferlinien wird nach wie vor durch Analyse des z-Wertes vorgenommen -> Probleme bei Raum 027, 028.
|
|
// Wahrscheinlich müsst im SVC PPM (ParticipantHandlerForExercise::createHitlineInfo) nixcht nur die OriginatorPosition, sondern ggf. auch Bldg/Room in das DDS-Topic HitLineInfo eingetragen werden.
|
|
// Wahrscheinlich wegen dem Replay eine DB-Änderung notwendig.
|
|
bool getFloorOfRoom(const std::string &bdlgFeatureId, int roomNumber, int &floorOut) const;
|
|
// <bldg , <roomNumber, floor>
|
|
// <featureId, <roomNumber, floor>
|
|
std::map<std::string, std::map<int,int> > mRoomToFloorPerBldg;
|
|
|
|
NGL::INGLLogger &m_logger;
|
|
};
|
|
|
|
}
|