|
|
/*
|
|
|
* Author: Jun0x01@github.com
|
|
|
* Date: 2019.06.06
|
|
|
*/
|
|
|
#include "SceneControl.h"
|
|
|
#include "Log.h"
|
|
|
#include <QDebug>
|
|
|
#include <QtMath>
|
|
|
#include "translator.h"
|
|
|
#include "Base/OgdcPoint3D.h"
|
|
|
#include "Base3D/UGMathEngine.h"
|
|
|
#include "geofeatureoperator.h"
|
|
|
#include "Geometry3D/UGGeoModelPro.h"
|
|
|
|
|
|
//using namespace SuperMap;
|
|
|
|
|
|
SceneControl::SceneControl(void* pWndHandle, int dpiX, int dpiY)
|
|
|
{
|
|
|
m_pUGSceneWnd = NULL;
|
|
|
//m_pRoot3D = NULL;
|
|
|
m_pCameraWorld = NULL;
|
|
|
m_IsMinSized = false;
|
|
|
|
|
|
Initialize(pWndHandle, dpiX, dpiY);
|
|
|
// setCallBackFunc();
|
|
|
|
|
|
// m_pInnerWorkspace = new Workspace();
|
|
|
m_pWorkspace = NULL;
|
|
|
// SetWorkspace(m_pInnerWorkspace);
|
|
|
|
|
|
mIsInWorkspace = false;
|
|
|
}
|
|
|
SceneControl::~SceneControl()
|
|
|
{
|
|
|
if (m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
// close the scene
|
|
|
m_pUGSceneWnd->m_SceneWindow.Reset();
|
|
|
}
|
|
|
|
|
|
delete m_pUGSceneWnd;
|
|
|
m_pUGSceneWnd = NULL;
|
|
|
|
|
|
// delete m_pInnerWorkspace;
|
|
|
// m_pInnerWorkspace = NULL;
|
|
|
m_pWorkspace = NULL;
|
|
|
m_pWnd = NULL;
|
|
|
}
|
|
|
|
|
|
//设置回调函数
|
|
|
void SceneControl::setCallBackFunc()
|
|
|
{
|
|
|
/*
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetAction3DChangedFunc(Action3DChangedCallBack,(UGlong)this);
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetTracking3DFunc(Tracking3DCallBack,(UGlong)this);
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetTracked3DFunc(Tracked3DCallBack,(UGlong)this);
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetPointInput3DFunc(PointInput3DCallBack,(UGlong)this);
|
|
|
|
|
|
m_pUGSceneWnd->GetScene3D()->SetAfterGeometryAdded3DFunc(AfterGeometryAdded3DCallBack,(UGlong)this);
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
UGRoot3D* SceneControl::m_pRoot3D = NULL;
|
|
|
bool SceneControl::mIsInitializeUGRoot3D = false;
|
|
|
void SceneControl::Initialize(void* pWndHandle, int dpiX, int dpiY)
|
|
|
{
|
|
|
// set graphics engine type
|
|
|
//#ifdef WIN32
|
|
|
// UGGraphicsManager::SetCurGraphicsType(UGC::UGGraphics::GT_Windows);
|
|
|
//#else
|
|
|
// UGGraphicsManager::SetCurGraphicsType(UGGraphics::GT_QT);
|
|
|
//#endif
|
|
|
// 1.
|
|
|
if (SceneControl::m_pRoot3D == NULL) {
|
|
|
SceneControl::m_pRoot3D = new UGC::UGRoot3D();
|
|
|
|
|
|
SceneControl::m_pRoot3D->Initialize(NULL);
|
|
|
SceneControl::m_pRoot3D->SetGraphics3DType(UGC::RST_OGRE);
|
|
|
|
|
|
SceneControl::mIsInitializeUGRoot3D = true;
|
|
|
}
|
|
|
|
|
|
Window3D wnd = (Window3D)pWndHandle;
|
|
|
UGScene3D* pScene = m_pRoot3D->CreateScene(wnd);
|
|
|
pScene->SetType(ST_EARTH_ELLIPSOID_WGS84);
|
|
|
pScene->SetDrawMode(UGC::REAL_TIME_RASTER);
|
|
|
// pScene->SetDrawMode(UGC::DRAW_SCREEN);
|
|
|
|
|
|
m_pCameraWorld = pScene->CreateCamera(_U("Camera"));
|
|
|
UGCameraState ChinaState;
|
|
|
ChinaState.dLon= UGMathEngine::DegreesToRadians(105);
|
|
|
ChinaState.dLat= UGMathEngine::DegreesToRadians(33);
|
|
|
ChinaState.dHeading = 0;
|
|
|
ChinaState.dTilt=0;
|
|
|
ChinaState.dAltitude=11269.38*1000;
|
|
|
m_pCameraWorld->SetCamera(ChinaState);
|
|
|
pScene->GetRenderTarget()->AddViewport(m_pCameraWorld, 0);
|
|
|
m_pRoot3D->SetActiveScene(pScene);
|
|
|
|
|
|
m_pUGSceneWnd = new UGSceneEditorWnd(pScene);
|
|
|
m_pUGSceneWnd->SetOpenEditMode(true);
|
|
|
m_pUGSceneWnd->SetEditEnvironment();
|
|
|
|
|
|
// dpi info
|
|
|
pScene->InitializeScene(_U(""), dpiX, dpiY);
|
|
|
|
|
|
pScene->GetLatLongGrid()->SetVisible(false);//设置经纬网不可见
|
|
|
|
|
|
m_pRoot3D->Render();
|
|
|
}
|
|
|
|
|
|
UGuint SceneControl::getKeyUGFlags(unsigned int flag)
|
|
|
{
|
|
|
UGint flags = 0;
|
|
|
if(flag & UG_VK_MENU || flag & UG_VK_SHIFT || flag & UG_VK_CONTROL)
|
|
|
{
|
|
|
flags = flag; // TODO: change
|
|
|
}
|
|
|
|
|
|
return flags;
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnDraw(int rectLeft, int rectTop, int rectRight, int rectBottom, void* pHDC)
|
|
|
{
|
|
|
if (m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
m_pUGSceneWnd->GetScene3D()->Refresh();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnSizeChanged(int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGRect rect(0, 0, x, y);
|
|
|
bool isEmpty = rect.IsEmpty();
|
|
|
|
|
|
if(!isEmpty && m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
m_pUGSceneWnd->OnSize(x, y);
|
|
|
m_pUGSceneWnd->GetScene3D()->Refresh();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
m_IsMinSized = isEmpty;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnLMouseDown(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
// if(m_pUGSceneWnd->Get3DCursorShape()==38 || m_pUGSceneWnd->Get3DCursorShape()==39 || m_pUGSceneWnd->Get3DCursorShape()==40)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
qDebug()<<"****************LMouseDownFlag:"<<m_pUGSceneWnd->Get3DCursorShape();
|
|
|
// startTracking = true;
|
|
|
// UGVector3d p;
|
|
|
// m_pUGSceneWnd->m_SceneWindow.PixelToGlobal(p,pt,UGPixelToGlobalMode::Terrain);
|
|
|
// qDebug()<<"*******p.x:"<<p.x;
|
|
|
// qDebug()<<"*******p.y:"<<p.y;
|
|
|
// qDebug()<<"*******p.z:"<<p.z;
|
|
|
// qDebug()<<"*******Height:"<<m_pUGSceneWnd->GetScene3D()->GetHeight(p.x,p.y);
|
|
|
m_pUGSceneWnd->OnLButtonDown(flag, pt);
|
|
|
// m_pUGSceneWnd->m_SceneWindow.OnLButtonDown(flag, pt);
|
|
|
// qDebug()<<"****************LMouseDown:"<<m_pUGSceneWnd->Get3DCursorShape();
|
|
|
// m_pUGSceneWnd->Set3DCursorShape(15);
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnLMouseUp(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnLButtonUp(flag, pt);
|
|
|
// m_pUGSceneWnd->m_SceneWindow.OnLButtonUp(flag, pt);
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnLMouseDbClick(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
if(m_pUGSceneWnd->Get3DCursorShape()==39 || m_pUGSceneWnd->Get3DCursorShape()==40)
|
|
|
{
|
|
|
m_pUGSceneWnd->OnKeyDown(UG_VK_DELETE,0,UG_VK_SHIFT);//通过shift+delete组合键来实现节点删除
|
|
|
return;
|
|
|
};
|
|
|
// UGPoint pt(x, y);
|
|
|
// UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
// m_pUGSceneWnd->OnLButtonDblClk(flag, pt);
|
|
|
qDebug()<<"**********************OnLMouseDbClick1";
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnMouseMove(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnMouseMove(flag, pt);
|
|
|
if(this->m_EditStatus)
|
|
|
{
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnMouseWheel(unsigned int nFlags, short zDelta, int x, int y)
|
|
|
{
|
|
|
// the ratio is 1 after zooming in and zooming out, map scale will not be changed.
|
|
|
double ratio = 1;
|
|
|
if (zDelta > 0)
|
|
|
{
|
|
|
ratio = 5/4.0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ratio = 4/5.0;
|
|
|
}
|
|
|
|
|
|
UGPoint pt(x, y);
|
|
|
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnMouseWheel(flag, zDelta, pt);
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnRMouseDown(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnRButtonDown(flag, pt);
|
|
|
// m_pUGSceneWnd->m_SceneWindow.OnRButtonDown(flag, pt);
|
|
|
|
|
|
// qDebug()<<"******************EidtUserAction:"<<m_pUGSceneWnd->GetUserAction();
|
|
|
// qDebug()<<"******************RButtonDown:";
|
|
|
// qDebug()<<"******************SubAction:"<<m_pUGSceneWnd->GetSubAction();
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnRMouseUp(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnRButtonUp(flag, pt);
|
|
|
// m_pUGSceneWnd->m_SceneWindow.OnRButtonUp(flag, pt);
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnMidMouseDown(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnMButtonUp(flag, pt);
|
|
|
}
|
|
|
|
|
|
void SceneControl::OnMidMouseUp(unsigned int nFlags, int x, int y, void* pHDC)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
UGC::UGuint flag = getKeyUGFlags(nFlags);
|
|
|
m_pUGSceneWnd->OnMButtonDown(flag, pt);
|
|
|
}
|
|
|
|
|
|
UGPoint3D SceneControl::PixelToSceneGlobal(int x, int y)
|
|
|
{
|
|
|
UGPoint pt(x, y);
|
|
|
return PixelToSceneGlobal(pt);
|
|
|
}
|
|
|
|
|
|
UGPoint3D SceneControl::PixelToSceneGlobal(UGPoint pt)
|
|
|
{
|
|
|
UGPoint2D pntlp;
|
|
|
UGPoint3D pnt2D(0.0, 0.0, 0.0);
|
|
|
|
|
|
// TODO:
|
|
|
return pnt2D;
|
|
|
}
|
|
|
|
|
|
UGPoint SceneControl::SceneGlobalToPixel(double x, double y, double z)
|
|
|
{
|
|
|
UGPoint3D pnt(x, y, z);
|
|
|
return SceneGlobalToPixel(pnt);
|
|
|
|
|
|
}
|
|
|
|
|
|
UGPoint SceneControl::SceneGlobalToPixel(UGPoint3D pnt)
|
|
|
{
|
|
|
UGPoint2D pntlp;
|
|
|
UGPoint pt(0, 0);
|
|
|
// TODO:
|
|
|
return pt;
|
|
|
}
|
|
|
|
|
|
void SceneControl::Refresh()
|
|
|
{
|
|
|
////m_pUGSceneWnd->Refresh();
|
|
|
/*if (m_pUGSceneWnd != NULL) {
|
|
|
m_pUGSceneWnd->GetScene3D()->GetCamera(_U("Camera"))->Refresh();
|
|
|
}*/
|
|
|
|
|
|
UGLayer3Ds* pLayers = GetUGLayer3Ds();
|
|
|
for (int i = 0; i < pLayers->GetInnerCount(); i++)
|
|
|
{
|
|
|
UGLayer3D* pLayer = pLayers->GetLayerInnerAt(i);
|
|
|
|
|
|
pLayer->SetInitialized(false);
|
|
|
pLayers->RefreshRasterLayer(pLayer);
|
|
|
}
|
|
|
pLayers = NULL;
|
|
|
}
|
|
|
|
|
|
void SceneControl::Refresh(UGLayer3D *pLayer)
|
|
|
{
|
|
|
UGLayer3Ds* pLayers = GetUGLayer3Ds();
|
|
|
pLayer->SetInitialized(false);
|
|
|
pLayers->RefreshRasterLayer(pLayer);
|
|
|
|
|
|
pLayers = NULL;
|
|
|
}
|
|
|
|
|
|
void SceneControl::RenderInTimer() {
|
|
|
m_pRoot3D->Render();
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
UGSceneEditorWnd* SceneControl::GetSceneEditWnd()
|
|
|
{
|
|
|
return m_pUGSceneWnd;
|
|
|
}
|
|
|
|
|
|
UGLayer3Ds* SceneControl::GetUGLayer3Ds()
|
|
|
{
|
|
|
return &(m_pUGSceneWnd->GetScene3D()->m_Layers);
|
|
|
}
|
|
|
|
|
|
UGTrackingLayer3D *SceneControl::GetTrackingLayer3D()
|
|
|
{
|
|
|
return &(m_pUGSceneWnd->GetScene3D()->m_TrackingLayer3D);
|
|
|
}
|
|
|
|
|
|
UGScene3D *SceneControl::GetScene3D()
|
|
|
{
|
|
|
return m_pUGSceneWnd->GetScene3D();
|
|
|
}
|
|
|
|
|
|
UGCameraWorld *SceneControl::GetCameraWorld()
|
|
|
{
|
|
|
return m_pCameraWorld;
|
|
|
}
|
|
|
|
|
|
void SceneControl::SetEditableLayer(UGLayer3D* pLayer, bool isEditable)
|
|
|
{
|
|
|
// TODO:
|
|
|
GetUGLayer3Ds()->SetEditableLayer(pLayer,isEditable);
|
|
|
// this->m_EditStatus = isEditable;
|
|
|
}
|
|
|
|
|
|
void SceneControl::SetSelectionLayerEditable(bool isEditable)
|
|
|
{
|
|
|
UGLayer3D* editLayer3D = GetSelectionLayer();
|
|
|
if(!editLayer3D->GetEditable())
|
|
|
this->SetEditableLayer(editLayer3D,isEditable);
|
|
|
|
|
|
editLayer3D = NULL;
|
|
|
}
|
|
|
|
|
|
bool SceneControl::GetEditStatus()
|
|
|
{
|
|
|
return this->m_EditStatus;
|
|
|
}
|
|
|
|
|
|
void SceneControl::SetEditStatus(bool isEditable)
|
|
|
{
|
|
|
this->m_EditStatus = isEditable;
|
|
|
}
|
|
|
|
|
|
void SceneControl::SetWorkspace(Workspace* workspace)
|
|
|
{
|
|
|
if (workspace == m_pWorkspace)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
m_pWorkspace = workspace;
|
|
|
if (m_pWorkspace != NULL && m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
UGWorkspace* pUGWorkspace = m_pWorkspace->GetUGWorkspace();
|
|
|
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetWorkspace(pUGWorkspace);
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetDataSources(&(pUGWorkspace->m_DataSources));
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetWorkspaceName(pUGWorkspace->m_WorkspaceConnection.m_strWorkspaceName);
|
|
|
|
|
|
m_pUGSceneWnd->GetScene3D()->m_TerrainLayer3Ds.SetDataSources(&(pUGWorkspace->m_DataSources));
|
|
|
|
|
|
pUGWorkspace->m_SceneStorages.AttachWorkspace(m_pWorkspace->GetUGWorkspace());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SceneControl::SetWorkspace(UGWorkspace *pWorkspace)
|
|
|
{
|
|
|
if(pWorkspace == NULL) return;
|
|
|
// qDebug()<<"******************:"<<(m_pWorkspace==NULL);
|
|
|
m_pWorkspace->setUGWorkspace(pWorkspace);
|
|
|
if (m_pWorkspace != NULL && m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
UGWorkspace* pUGWorkspace = m_pWorkspace->GetUGWorkspace();
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetWorkspace(pUGWorkspace);
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetDataSources(&(pUGWorkspace->m_DataSources));
|
|
|
m_pUGSceneWnd->GetScene3D()->m_Layers.SetWorkspaceName(pUGWorkspace->m_WorkspaceConnection.m_strWorkspaceName);
|
|
|
|
|
|
m_pUGSceneWnd->GetScene3D()->m_TerrainLayer3Ds.SetDataSources(&(pUGWorkspace->m_DataSources));
|
|
|
|
|
|
pUGWorkspace->m_SceneStorages.AttachWorkspace(m_pWorkspace->GetUGWorkspace());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
UGWorkspace *SceneControl::getUGWorkspace()
|
|
|
{
|
|
|
return m_pWorkspace->GetUGWorkspace();
|
|
|
}
|
|
|
|
|
|
bool SceneControl::OpenScene(string sceneName)
|
|
|
{
|
|
|
UGString ugSceneName;
|
|
|
ugSceneName.FromStd(sceneName);
|
|
|
UGString sceneXML = m_pWorkspace->GetUGWorkspace()->m_SceneStorages.Find(ugSceneName)->GetXML();
|
|
|
|
|
|
// The last parameter(strWorkspaceName) is neccessary, and it is the path of workspace.
|
|
|
UGbool isOpen = m_pUGSceneWnd->GetScene3D()->FromXML(sceneXML, false, 0, m_pWorkspace->GetUGWorkspace()->m_WorkspaceConnection.m_strServer);
|
|
|
m_pUGSceneWnd->Refresh();
|
|
|
|
|
|
mIsInWorkspace = isOpen;
|
|
|
return isOpen;
|
|
|
}
|
|
|
|
|
|
UGLayer3D* SceneControl::AddLayerFromDataset(string datasourceName, string datasetName)
|
|
|
{
|
|
|
UGString ugDatasetName, ugDatasourceName;
|
|
|
ugDatasourceName.FromStd(datasourceName);
|
|
|
ugDatasetName.FromStd(datasetName);
|
|
|
UGDataSource* pDatasource = m_pWorkspace->GetUGWorkspace()->GetDataSource(ugDatasourceName);
|
|
|
UGLayer3D* pLayer = NULL;
|
|
|
if (pDatasource != NULL)
|
|
|
{
|
|
|
UGDatasetPtr pDataset = pDatasource->GetDataset(ugDatasetName);
|
|
|
if (pDataset != NULL)
|
|
|
{
|
|
|
UGDataset::DatasetType datasetType = pDataset->GetType();
|
|
|
|
|
|
UGString ugLayerName = ugDatasetName + _U("@") + ugDatasourceName; // 数据集名@数据源名，图层默认命名格式，也是通过该格式的名称获得关联数据
|
|
|
|
|
|
// AddLayer()支持多种数据格式：
|
|
|
// 1. 数据集：datsetName@dataSourceName(当前工作空间中已经打开的数据)
|
|
|
// 2. 本地配置文件的路径( .sci, .scp, .kml等等，具体可参考后面的 AddLayerFromFile() 函数)
|
|
|
pLayer = m_pUGSceneWnd->GetScene3D()->m_Layers.AddLayer(ugLayerName); // 若同名图层已经存在，会自动修改图层名, 通常追加"#1"
|
|
|
// 或使用下面的方法，可自定义图层名称和图层别名
|
|
|
//pLayer = m_pUGSceneWnd->GetScene3D()->m_Layers.AddLayer(ugLayerName, ugLayerName, ugLayerName);
|
|
|
|
|
|
if (pLayer != NULL)
|
|
|
{
|
|
|
// 添加模型数据集图层后，设置一下该图层的三维风格，否则不能显示贴图
|
|
|
// 若有其他数据类型出现同类问题，可考虑添加到此处，设置三维风格
|
|
|
if (datasetType == UGDataset::/*DatasetType::*/Model || datasetType == UGDataset::/*DatasetType::*/CAD)
|
|
|
{
|
|
|
// 此处仅设置一个三维风格，以达到启用目的
|
|
|
// 其他风格可根据需要设置
|
|
|
UGStyle3D style3D;
|
|
|
style3D.SetFill3DMode(UGC::/*UGFill3DMode::*/FILL_FACE);
|
|
|
pLayer->SetStyle3D(style3D);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Failed to add a dataset on scene. Not found dataset " + datasetName + " in the datasource named " + datasourceName);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Failed to add a dataset on scene. Not found datasource " + datasourceName);
|
|
|
}
|
|
|
return pLayer;
|
|
|
|
|
|
}
|
|
|
|
|
|
UGLayer3D* SceneControl::AddLayerFromDataset( UGString ugDatasourceName,UGString ugDatasetName)
|
|
|
{
|
|
|
UGDataSource* pDatasource = m_pWorkspace->GetUGWorkspace()->GetDataSource(ugDatasourceName);
|
|
|
UGLayer3D* pLayer = NULL;
|
|
|
if (pDatasource != NULL)
|
|
|
{
|
|
|
UGDatasetPtr pDataset = pDatasource->GetDataset(ugDatasetName);
|
|
|
if (pDataset != NULL)
|
|
|
{
|
|
|
UGDataset::DatasetType datasetType = pDataset->GetType();
|
|
|
|
|
|
UGString ugLayerName = ugDatasetName + _U("@") + ugDatasourceName; // 数据集名@数据源名，图层默认命名格式，也是通过该格式的名称获得关联数据
|
|
|
|
|
|
// AddLayer()支持多种数据格式：
|
|
|
// 1. 数据集：datsetName@dataSourceName(当前工作空间中已经打开的数据)
|
|
|
// 2. 本地配置文件的路径( .sci, .scp, .kml等等，具体可参考后面的 AddLayerFromFile() 函数)
|
|
|
pLayer = m_pUGSceneWnd->GetScene3D()->m_Layers.AddLayer(ugLayerName); // 若同名图层已经存在，会自动修改图层名, 通常追加"#1"
|
|
|
// 或使用下面的方法，可自定义图层名称和图层别名
|
|
|
//pLayer = m_pUGSceneWnd->GetScene3D()->m_Layers.AddLayer(ugLayerName, ugLayerName, ugLayerName);
|
|
|
|
|
|
if (pLayer != NULL)
|
|
|
{
|
|
|
// 添加模型数据集图层后，设置一下该图层的三维风格，否则不能显示贴图
|
|
|
// 若有其他数据类型出现同类问题，可考虑添加到此处，设置三维风格
|
|
|
if (datasetType == UGDataset::/*DatasetType::*/Model || datasetType == UGDataset::/*DatasetType::*/CAD)
|
|
|
{
|
|
|
// 此处仅设置一个三维风格，以达到启用目的
|
|
|
// 其他风格可根据需要设置
|
|
|
UGStyle3D style3D;
|
|
|
style3D.SetFill3DMode(UGC::/*UGFill3DMode::*/FILL_FACE);
|
|
|
pLayer->SetStyle3D(style3D);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Failed to add a dataset on scene. Not found dataset " + UGStrConvertor::Tostring(ugDatasetName) + " in the datasource named " + UGStrConvertor::Tostring(ugDatasourceName));
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Failed to add a dataset on scene. Not found datasource " + UGStrConvertor::Tostring(ugDatasourceName));
|
|
|
}
|
|
|
return pLayer;
|
|
|
}
|
|
|
|
|
|
bool SceneControl::Save()
|
|
|
{
|
|
|
UGString sceneName = m_pUGSceneWnd->GetScene3D()->GetName();
|
|
|
bool isSaved = false;
|
|
|
if (mIsInWorkspace) {
|
|
|
|
|
|
UGSceneStorage* pSceneStorage = m_pWorkspace->GetUGWorkspace()->m_SceneStorages.Find(sceneName);
|
|
|
if(pSceneStorage != NULL)
|
|
|
{
|
|
|
pSceneStorage->SetXML(m_pUGSceneWnd->GetScene3D()->ToXML(), pSceneStorage->GetVersion());
|
|
|
|
|
|
isSaved = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
string strSceneName;
|
|
|
sceneName.ToStd(strSceneName);
|
|
|
isSaved = SaveAs(strSceneName);
|
|
|
mIsInWorkspace = isSaved;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
string strSceneName;
|
|
|
sceneName.ToStd(strSceneName);
|
|
|
isSaved = SaveAs(strSceneName);
|
|
|
mIsInWorkspace = isSaved;
|
|
|
}
|
|
|
|
|
|
return isSaved;
|
|
|
|
|
|
}
|
|
|
|
|
|
bool SceneControl::SaveAs(string sceneName)
|
|
|
{
|
|
|
UGString ugSceneName;
|
|
|
ugSceneName.FromStd(sceneName);
|
|
|
|
|
|
UGSceneStorages* pSStore = &(m_pWorkspace->GetUGWorkspace()->m_SceneStorages);
|
|
|
|
|
|
UGString validSceneName = pSStore->GetUnoccupiedSceneName(ugSceneName);
|
|
|
bool isAdd = pSStore->Add(validSceneName);
|
|
|
int count = pSStore->GetCount();
|
|
|
bool isSaved = false;
|
|
|
if (isAdd)
|
|
|
{
|
|
|
UGSceneStorage* pSceneStorage = pSStore->GetSceneAt(count - 1);
|
|
|
pSceneStorage->SetXML(m_pUGSceneWnd->GetScene3D()->ToXML(), pSceneStorage->GetVersion());
|
|
|
|
|
|
isSaved = true;
|
|
|
mIsInWorkspace = true;
|
|
|
}
|
|
|
return isSaved;
|
|
|
}
|
|
|
|
|
|
void SceneControl::ActivateScene() {
|
|
|
if (m_pRoot3D != NULL && m_pUGSceneWnd != NULL)
|
|
|
{
|
|
|
m_pRoot3D->SetActiveScene(m_pUGSceneWnd->GetScene3D());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
UGLayer3D* SceneControl::AddLayerFromFile(string filePath)
|
|
|
{
|
|
|
UGString ugFilePath;
|
|
|
ugFilePath.FromStd(filePath);
|
|
|
bool exist = UGFile::IsExist(ugFilePath);
|
|
|
UGLayer3D* pLayer = NULL;
|
|
|
if (exist)
|
|
|
{
|
|
|
// 本地配置文件的路径(.sci, .scm, .scp, .sct, .kml, .sit, .SCVO等等)
|
|
|
pLayer = m_pUGSceneWnd->GetScene3D()->m_Layers.AddLayer(ugFilePath);
|
|
|
|
|
|
if (pLayer == NULL)
|
|
|
{
|
|
|
Log::Error("Unsupported file: " + filePath);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Not found the file: " + filePath);
|
|
|
}
|
|
|
|
|
|
|
|
|
return pLayer;
|
|
|
}
|
|
|
|
|
|
UGTerrainAccessor* SceneControl::AddTerrainLayerFromFile(string filePath)
|
|
|
{
|
|
|
UGString ugFilePath;
|
|
|
ugFilePath.FromStd(filePath);
|
|
|
UGString suffix = UGFile::GetExt(ugFilePath);
|
|
|
UGString fileName = UGFile::GetName(ugFilePath);
|
|
|
|
|
|
UGTerrainAccessor* pTerrain = NULL;
|
|
|
UGString layerName = fileName.Left(fileName.GetLength() - suffix.GetLength());
|
|
|
|
|
|
// Terraint Layer
|
|
|
if (suffix.CompareNoCase(_U(".sct")) == 0)
|
|
|
{
|
|
|
pTerrain = m_pUGSceneWnd->GetScene3D()->m_TerrainLayer3Ds.AddTerrainLayer(ugFilePath, layerName);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Log::Error("Unsupported file ! " + filePath);
|
|
|
}
|
|
|
|
|
|
return pTerrain;
|
|
|
}
|
|
|
|
|
|
//获取第一个高亮对象所在图层
|
|
|
UGLayer3D *SceneControl::GetSelectionLayer()
|
|
|
{
|
|
|
UGLayer3Ds* pLayers = GetUGLayer3Ds();
|
|
|
int count = pLayers->GetInnerCount();
|
|
|
UGLayer3D* pLayer = NULL;
|
|
|
for (int i = 0; i < count; i++)
|
|
|
{
|
|
|
pLayer = pLayers->GetLayerInnerAt(i);
|
|
|
UGSelection3D* pSelection = pLayer->GetSelection3D();
|
|
|
if (NULL != pSelection && pSelection->GetSize() > 0)
|
|
|
{
|
|
|
return pLayer;
|
|
|
}
|
|
|
}
|
|
|
return pLayer;
|
|
|
}
|
|
|
|
|
|
UGArray<UGSelection3D*>* SceneControl::GetGeoSelections()
|
|
|
{
|
|
|
UGLayer3Ds* pLayers = GetUGLayer3Ds();
|
|
|
int count = pLayers->GetInnerCount();
|
|
|
UGArray<UGSelection3D*>* pSelectionArr = NULL;
|
|
|
for (int i = 0; i < count; i++)
|
|
|
{
|
|
|
UGLayer3D* pLayer = pLayers->GetLayerInnerAt(i);
|
|
|
UGSelection3D* pSelection = pLayer->GetSelection3D();
|
|
|
if (NULL != pSelection && pSelection->GetSize() > 0)
|
|
|
{
|
|
|
if (NULL == pSelectionArr)
|
|
|
{
|
|
|
pSelectionArr = new UGArray<UGSelection3D*>();
|
|
|
}
|
|
|
pSelectionArr->Add(pSelection);
|
|
|
}
|
|
|
pLayer = NULL;
|
|
|
pSelection = NULL;
|
|
|
}
|
|
|
pLayers = NULL;
|
|
|
return pSelectionArr;
|
|
|
}
|
|
|
|
|
|
UGRecordsetPtr SceneControl::ToRecordset(UGSelection3D* pSelection, bool isEditable /*= false*/)
|
|
|
{
|
|
|
UGRecordsetPtr pRecordset = NULL;
|
|
|
if (NULL != pSelection && pSelection->GetSize() > 0)
|
|
|
{
|
|
|
UGLayer3D* pLayer = pSelection->GetLayer3D();
|
|
|
// UGDatasetVector* pDataset = NULL;
|
|
|
UGDatasetPtr pDataset = NULL;
|
|
|
UGLayer::UGLayerType type = (UGLayer::UGLayerType)pLayer->GetType();
|
|
|
switch (type)
|
|
|
{
|
|
|
case UGC::/*UGLayer3DType::*/l3dDatasetVector:
|
|
|
{
|
|
|
UGLayer3DDatasetVector* pLayer3DDatasetVector = (UGLayer3DDatasetVector*)(pLayer);
|
|
|
pDataset = pLayer3DDatasetVector->GetDataset();
|
|
|
break;
|
|
|
}
|
|
|
case UGC::/*UGLayer3DType::*/l3dDatasetModelPro:
|
|
|
{
|
|
|
UGLayer3DDatasetModelPro* pLayer3DDatasetModel = (UGLayer3DDatasetModelPro*)(pLayer);
|
|
|
pDataset = pLayer3DDatasetModel->GetDataset();
|
|
|
break;
|
|
|
}
|
|
|
case UGC::/*UGLayer3DType::*/l3dDatasetVectorPoint:
|
|
|
{
|
|
|
UGLayer3DDatasetVectorPoint* pLayer3DDatasetPoint = (UGLayer3DDatasetVectorPoint*)(pLayer);
|
|
|
pDataset = pLayer3DDatasetPoint->GetDataset();
|
|
|
break;
|
|
|
}
|
|
|
case UGC::/*UGLayer3DType::*/l3dDatasetVectorLR:
|
|
|
{
|
|
|
UGLayer3DDatasetVectorLR* pLayer3DDatasetRegion = (UGLayer3DDatasetVectorLR*)(pLayer);
|
|
|
pDataset = pLayer3DDatasetRegion->GetDataset();
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if (NULL != pDataset)
|
|
|
{
|
|
|
pDataset->Open();
|
|
|
|
|
|
UGQueryDef queryDef;
|
|
|
|
|
|
// 获取所有选中对象的SmID, 作为查询条件
|
|
|
UGint count = pSelection->GetSize();
|
|
|
|
|
|
UGString filter = _U("(SmID in(");
|
|
|
for (int i = 0; i < count ; i++)
|
|
|
{//queryDef.m_IDs.Add((UGint)1); // 使用后，m_IDs释放有问题, 因此使用下面的方式构造查询条件
|
|
|
UGString temp;
|
|
|
if (i < count - 1)
|
|
|
{
|
|
|
temp.Format(_U("%d,"), pSelection->GetAt(i));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
temp.Format(_U("%d))"), pSelection->GetAt(i));
|
|
|
}
|
|
|
|
|
|
filter += temp;
|
|
|
}
|
|
|
// 设置查询类型
|
|
|
|
|
|
queryDef.m_strFilter = filter;
|
|
|
queryDef.m_nType = UGQueryDef::/*QueryType::*/General; // IDs为使用SmID查询，queryDef.m_IDs
|
|
|
|
|
|
if (pDataset->GetType() == UGDataset::Tabular)
|
|
|
{
|
|
|
queryDef.m_nOptions = UGQueryDef::Attribute;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
queryDef.m_nOptions = UGQueryDef::Both;
|
|
|
}
|
|
|
queryDef.m_nMode = UGQueryDef::GeneralQuery;
|
|
|
queryDef.m_nCursorType = UGQueryDef::OpenDynamic; // OpenStatic, 用于读取数据；OpenDynamic, 用于数据增删改
|
|
|
|
|
|
UGDatasetVector* dv = (UGDatasetVector*)pDataset.get();
|
|
|
UGFieldInfos fieldInfos;
|
|
|
dv->GetFieldInfos(fieldInfos); // 获取字段信息，可用来添加或删除非系统字段，只是用于查找字段值，也可通过UGRecordset获取
|
|
|
int countOld = dv->GetRecordsetCount();
|
|
|
|
|
|
pRecordset = dv->Query(queryDef);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return pRecordset;
|
|
|
}
|
|
|
|
|
|
void SceneControl::ViewToLayer(UGLayer3D* pLayer)
|
|
|
{
|
|
|
// UGRect2D bounds = pLayer->GetBounds();
|
|
|
// UGCameraState state;
|
|
|
// state.dLon = UGMathEngine::DegreesToRadians(bounds.CenterPoint().x);
|
|
|
// state.dLat = UGMathEngine::DegreesToRadians(bounds.CenterPoint().y);
|
|
|
// state.dAltitude = 0;
|
|
|
// state.dDistance = 5.4*1000;
|
|
|
// state.dHeading = 0;
|
|
|
// state.dTilt = UGMathEngine::DegreesToRadians(60); //UGMathEngine::DegreesToRadians(60)
|
|
|
// UGCameraState lookatstate = state;
|
|
|
// lookatstate.dTilt = 0;
|
|
|
if (pLayer != NULL)
|
|
|
{
|
|
|
m_pUGSceneWnd->GetScene3D()->GetCamera(_U("Camera"))->FlyToBounds(pLayer->GetBounds(), 6000);
|
|
|
// m_pUGSceneWnd->GetScene3D()->GetCamera(_U("Camera"))->FlyToCamera(state,7000);
|
|
|
// m_pUGSceneWnd->GetScene3D()->GetCamera(_U("Camera"))->FlyTo(lookatstate,7000);
|
|
|
// m_pCameraWorld->m_StateLookAt.dLon = state.dLon;
|
|
|
// m_pCameraWorld->m_StateLookAt.dLat = state.dLat;
|
|
|
// m_pUGSceneWnd->GetScene3D()->GetCamera(_U("Camera"))->SetLookAt(lookatstate);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//定位到模型图层
|
|
|
void SceneControl::ViewToModelLayer(UGLayer3D *pModelLayer,long nMillSec)
|
|
|
{
|
|
|
//获取模型位置
|
|
|
UGDatasetVector* dv = (UGDatasetVector*)pModelLayer->GetAttachData();
|
|
|
dv->Open();
|
|
|
UGQueryDef queryDef;
|
|
|
UGRecordsetPtr res = dv->Query(queryDef);
|
|
|
UGGeometry* geometry = NULL;
|
|
|
res->GetGeometry(geometry);
|
|
|
UGGeoModelPro* model = (UGGeoModelPro*)geometry;
|
|
|
UGPoint3D pt3D = model->GetPosition();
|
|
|
//设置相机LookAt
|
|
|
UGCameraState lookatstate;
|
|
|
lookatstate.dLon = UGMathEngine::DegreesToRadians(pt3D.x);
|
|
|
lookatstate.dLat = UGMathEngine::DegreesToRadians(pt3D.y);
|
|
|
lookatstate.dAltitude = pt3D.z;
|
|
|
lookatstate.dDistance = pt3D.z;
|
|
|
lookatstate.dHeading = 0;
|
|
|
lookatstate.dTilt = UGMathEngine::DegreesToRadians(85);
|
|
|
//飞行到模型位置
|
|
|
m_pCameraWorld->FlyTo(lookatstate,nMillSec);
|
|
|
|
|
|
geometry = NULL;
|
|
|
model = NULL;
|
|
|
}
|
|
|
|
|
|
void SceneControl::Close()
|
|
|
{
|
|
|
m_pUGSceneWnd->GetScene3D()->Reset();
|
|
|
m_pUGSceneWnd->GetScene3D()->SetDrawMode(REAL_TIME_RASTER);
|
|
|
m_pUGSceneWnd->GetScene3D()->Refresh();
|
|
|
}
|
|
|
|
|
|
void SceneControl::removeLayer3D(UGString layerName)
|
|
|
{
|
|
|
UGLayer3Ds* pLayer3Ds = GetUGLayer3Ds();
|
|
|
int layerIndex = pLayer3Ds->FindNameInner(layerName);
|
|
|
if(layerIndex>=0)
|
|
|
{//图层存在则删除
|
|
|
pLayer3Ds->TreeRemoveAt(layerIndex);
|
|
|
}
|
|
|
pLayer3Ds = NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SceneControl::MeasureDistance()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureDistance);
|
|
|
}
|
|
|
|
|
|
void SceneControl::MeasureTerrainDistance()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureTerrainDistance);
|
|
|
}
|
|
|
|
|
|
void SceneControl::MeasureHorizontalDistance()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureHorizontalDistance);
|
|
|
}
|
|
|
|
|
|
|
|
|
void SceneControl::CalcuHeight()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureHeight);
|
|
|
}
|
|
|
|
|
|
void SceneControl::MeasureArea()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureArea);
|
|
|
}
|
|
|
|
|
|
void SceneControl::MeasureTerrainArea()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaMeasureTerrainArea);
|
|
|
}
|
|
|
|
|
|
void SceneControl::CalcuAngle()
|
|
|
{
|
|
|
// m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::);
|
|
|
}
|
|
|
|
|
|
void SceneControl::Pan()
|
|
|
{
|
|
|
m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaPan);
|
|
|
}
|
|
|
|
|
|
void SceneControl::ZoomIn()
|
|
|
{
|
|
|
// m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaPan);
|
|
|
}
|
|
|
|
|
|
void SceneControl::ZoomOut()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void SceneControl::ZoomFree()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void SceneControl::Select()
|
|
|
{
|
|
|
// m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaPointSelect);
|
|
|
// m_pUGSceneWnd->m_SceneWindow.SetUserAction(UGSceneUserAction::suaRectSelect);
|
|
|
m_pUGSceneWnd->SetUserAction(UGSceneUserAction::suaPointSelect);
|
|
|
// qDebug()<<"*********************:"<<m_pUGSceneWnd->GetUserAction();
|
|
|
}
|
|
|
|
|
|
void SceneControl::ViewEntire()
|
|
|
{
|
|
|
|
|
|
}
|