//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
WorkbenchService::pFutureProjectExplorerModel_type
WorkbenchService::createProjectExplorerModel()
{
pFutureProjectExplorerModel_type pModel(new FutureProjectExplorerModel_type);
ProjectExplorerModel* pRawModel = new ProjectExplorerModel(*this);
m_pProjectExplorerModel = pProjectExplorerModel_type(pRawModel, &destroyModel);
pModel->setValue(m_pProjectExplorerModel);
// This will populate m_projectsToLoad by calling loadProject().
pRawModel->loadDataModel();
create(*pRawModel);
// TODO Probably shouldn't share a database connection with the
// data model because calling this next method might be done
// before loadDataModel() is complete, which might cause us
// to try to create a new transaction before the one that
// loadDataModel() creates is done.
// For now this is ok because the current database plugin
// implementation is single threaded.
loadProjects();
return pModel;
}
void xRungeKutta4 :: halfTest (void)
{
gpstk::Matrix<double> x0(2,1), truncError(2,1);
x0(0,0) = 0.001; // Initial angle in radians
x0(1,0) = 0.0; // Initial angular velocity in radians/second
PendulumIntegrator pModel(x0,0.);
double g = 9.81, L = 1.0;
pModel.setPhysics(g,L);
double deltaT = .00001; // Step size in seconds for integrator
double time = 0;
double Nper = 2.5; // number of periods
double addError = 0; //Total Error for angle
double addDotError = 0; //Total Error for rate of change in angle
long count = 0;
while (pModel.getTime() < Nper * (2*3.14159265/sqrt(g/L)))
{
pModel.integrateTo((count++)*deltaT,truncError);
addError += fabs(truncError(0,0));
addDotError += fabs(truncError(1,0));
}
CPPUNIT_ASSERT_DOUBLES_EQUAL(-x0(0,0),pModel.getState()(0,0),addError*2);
CPPUNIT_ASSERT_DOUBLES_EQUAL(x0(1,0),pModel.getState()(1,0),addDotError*2);
}
ezQtSkeletonPanel::ezQtSkeletonPanel(QWidget* pParent, ezSkeletonAssetDocument* pDocument)
: ezQtDocumentPanel(pParent)
{
m_pSkeletonDocument = pDocument;
setObjectName("SkeletonPanel");
setWindowTitle("Skeleton");
m_pMainWidget = new QWidget(this);
m_pMainWidget->setLayout(new QVBoxLayout());
m_pMainWidget->setContentsMargins(0, 0, 0, 0);
m_pMainWidget->layout()->setContentsMargins(0, 0, 0, 0);
m_pFilterWidget = new ezQtSearchWidget(this);
connect(m_pFilterWidget, &ezQtSearchWidget::textChanged, this,
[this](const QString& text) { m_pTreeWidget->GetProxyFilterModel()->SetFilterText(text); });
m_pMainWidget->layout()->addWidget(m_pFilterWidget);
std::unique_ptr<ezQtDocumentTreeModel> pModel(new ezQtDocumentTreeModel(pDocument->GetObjectManager()));
pModel->AddAdapter(new ezQtDummyAdapter(pDocument->GetObjectManager(), ezGetStaticRTTI<ezDocumentRoot>(), "Children"));
pModel->AddAdapter(new ezQtDummyAdapter(pDocument->GetObjectManager(), ezGetStaticRTTI<ezEditableSkeleton>(), "Children"));
pModel->AddAdapter(new ezQtJointAdapter(pDocument));
m_pTreeWidget = new ezQtDocumentTreeView(this, pDocument, std::move(pModel));
m_pTreeWidget->SetAllowDragDrop(true);
m_pTreeWidget->SetAllowDeleteObjects(false);
m_pMainWidget->layout()->addWidget(m_pTreeWidget);
setWidget(m_pMainWidget);
}
bool CFont::InitModel()
{
static CStrAny sPlain(ST_CONST, "Plain");
static CStrAny sg_mWorld(ST_CONST, "g_mWorld");
static CStrAny sg_mView(ST_CONST, "g_mView");
static CStrAny sg_mProj(ST_CONST, "g_mProj");
static CStrAny sg_mTexTransform(ST_CONST, "g_mTexTransform");
static CStrAny sg_cMaterialDiffuse(ST_CONST, "g_cMaterialDiffuse");
static CStrAny sg_txDiffuse(ST_CONST, "g_txDiffuse");
static CStrAny sg_sDiffuse(ST_CONST, "g_sDiffuse");
ASSERT(!m_pTextModel);
bool bRes;
CTechnique *pTech = CGraphics::Get()->GetTechnique(sPlain);
if (!pTech)
return false;
CSmartPtr<CGeometry> pGeom(new CGeometry());
bRes = pGeom->Init(pTech->m_pInputDesc, CGeometry::PT_TRIANGLELIST, INIT_BUFFER_CHARS * 4, INIT_BUFFER_CHARS * 6, 0, 0,
CResource::RF_DYNAMIC | CResource::RF_KEEPSYSTEMCOPY, CResource::RF_DYNAMIC | CResource::RF_KEEPSYSTEMCOPY);
if (!bRes)
return false;
CSmartPtr<CMaterial> pMaterial(new CMaterial());
bRes = pMaterial->Init(pTech, true, 0);
if (!bRes)
return false;
CSmartPtr<CModel> pModel(new CModel());
bRes = pModel->Init(pGeom, pMaterial, 0, false);
if (!bRes)
return false;
m_pTextModel = pModel;
CMatrix<4, 4> mIdentity;
mIdentity.SetDiagonal();
CMatrixVar vMat(4, 4, CMatrixVar::MVF_OWNVALUES, &mIdentity(0, 0));
m_pTextModel->SetVar(sg_mProj, vMat);
m_pTextModel->SetVar(sg_mView, vMat);
m_pTextModel->SetVar(sg_mWorld, vMat);
CMatrix<3, 2> mTexIdentity;
mTexIdentity.SetDiagonal();
CMatrixVar vTexMat(3, 2, CMatrixVar::MVF_OWNVALUES, &mTexIdentity(0, 0));
m_pTextModel->SetVar(sg_mTexTransform, vTexMat);
CVar<CVector<4> > vVec4;
vVec4.Val().Set(1, 1, 1, 1);
m_pTextModel->SetVar(sg_cMaterialDiffuse, vVec4);
CVar<CTexture *> vTexVar;
vTexVar.Val() = m_pTexture;
m_pTextModel->SetVar(sg_txDiffuse, vTexVar);
CVar<CSampler *> vSampVar;
vSampVar.Val() = CGraphics::Get()->GetSampler(CSampler::TDesc());
m_pTextModel->SetVar(sg_sDiffuse, vSampVar);
ResetModel();
return true;
}
void GGdiDrawTextMsgCommand::Execute() throw(GException)
{
LOG_LEVEL3("Execute()");
std::auto_ptr<GResponseMsgData> poResponse(CreateInitializedResponse(GGdiDrawTextMsgDataXML::CXMLTag, GMsgCmdDataFactory::CInterfaceVersion));
try
{
GGdiDrawTextMsgData *pRequestData(static_cast<GGdiDrawTextMsgData *>(m_pData));
if( pRequestData == NULL )
{
throw GEXCEPTION("Null pointer for GGdiDrawTextMsgData *pRequestData");
}
pRequestData->Validate();
GGDIText oText;
oText.SetBGColor(pRequestData->GetBGColor());
oText.SetFGColor(pRequestData->GetFGColor());
oText.SetText(pRequestData->GetText());
oText.SetXLoc(pRequestData->GetXLoc());
oText.SetYLoc(pRequestData->GetYLoc());
oText.SetFont(pRequestData->GetFont());
oText.SetAttr(pRequestData->GetAttr());
QSharedPointer<GGDIModel> pModel(GGDIModelSingleton::GetInstance()->GetModel());
{
QMutexLocker mtxScope(pModel->GetMutex());
pModel->DrawText(oText, pRequestData->GetSynchronousRequest());
}
poResponse->SetResponseCode(GResponseMsgData::eOk);
}
catch( GException& e )
{
LOG_LEVEL1(QString("Excepcion: ")+e.GetMessage());
poResponse->SetResponseCode(GResponseMsgData::eGDIError);
}
SetResponseNamespace(poResponse);
m_pResponse=poResponse.release();
}
void MyPinsFileIO::LoadPinModelsFromDisk(std::vector<std::pair<MyPinModel*, IMyPinBoundObject*> >& out_pinModelBindings, IMyPinsService& myPinService)
{
out_pinModelBindings.clear();
std::fstream stream;
size_t size;
if (m_fileIO.OpenFile(stream, size, MyPinsDataFilename))
{
std::string json((std::istreambuf_iterator<char>(stream)),
(std::istreambuf_iterator<char>()));
rapidjson::Document jsonDoc;
if (jsonDoc.Parse<0>(json.c_str()).HasParseError())
{
Eegeo_TTY("Parse error in MyPins JSON.\n");
return;
}
Eegeo_ASSERT(jsonDoc.IsObject(), "JSON document is not of object type");
const rapidjson::Value& myPinsArray = jsonDoc[MyPinsJsonArrayName.c_str()];
size_t numEntries = myPinsArray.Size();
for(int i = 0; i < numEntries; ++i)
{
const rapidjson::Value& entry = myPinsArray[i];
Eegeo_ASSERT(entry.HasMember("version"),
"Old MyPinModel version detected. Please delete and reinstall the application.\n");
const int version = entry["version"].GetInt();
const int earliestSupportedVersion = 1;
Eegeo_ASSERT(version >= earliestSupportedVersion, "Old MyPinModel version detected: tried to deserialize version %d but current version is %d. Please delete and reinstall the application.\n", version, MyPinModel::CurrentVersion);
MyPinModel::TPinIdType pinId = entry["id"].GetInt();
std::string title = entry["title"].GetString();
std::string description = entry["description"].GetString();
int sdkMapPinIconIndex = entry["icon"].GetInt();
double latitude = entry["latitude"].GetDouble();
double longitude = entry["longitude"].GetDouble();
MyPinsSemanticPinType semanticPinType = static_cast<MyPinsSemanticPinType>(entry["type"].GetInt());
std::string pinTypeMetadata = entry["metadata"].GetString();
std::string ratingsImage = "";
int reviewCount = 0;
if(version == 1)
{
// MB: Cannot infer review count therefore cannot show ratings by Yelp branding rules.
if(description.find("stars_") == 0)
{
description = "";
}
}
else if(version == MyPinModel::CurrentVersion)
{
ratingsImage = entry["ratingsImage"].GetString();
reviewCount = entry["reviewCount"].GetInt();
}
float heightAboveTerrainMetres = 0;
if(entry.HasMember("heightAboveTerrain"))
{
heightAboveTerrainMetres = entry["heightAboveTerrain"].GetDouble();
}
bool interior = false;
if(entry.HasMember("interior"))
{
interior = entry["interior"].GetBool();
}
std::string buildingId("");
if(entry.HasMember("building"))
{
buildingId = entry["building"].GetString();
}
int floor = 0;
if(entry.HasMember("floor"))
{
floor = entry["floor"].GetInt();
}
IMyPinBoundObject* pPinBoundObject(m_myPinBoundObjectFactory.CreatePinBoundObjectFromSerialized(*this,
pinId,
semanticPinType,
pinTypeMetadata,
myPinService));
MyPinModel* pModel(Eegeo_NEW(MyPinModel)(version,
pinId,
title,
description,
ratingsImage,
reviewCount,
sdkMapPinIconIndex,
Eegeo::Space::LatLong::FromDegrees(latitude, longitude),
heightAboveTerrainMetres,
interior,
buildingId,
floor));
out_pinModelBindings.push_back(std::make_pair(pModel, pPinBoundObject));
}
}
}
ezQtPropertyAnimAssetDocumentWindow::ezQtPropertyAnimAssetDocumentWindow(ezPropertyAnimAssetDocument* pDocument)
: ezQtGameObjectDocumentWindow(pDocument)
{
auto ViewFactory = [](ezQtEngineDocumentWindow* pWindow, ezEngineViewConfig* pConfig) -> ezQtEngineViewWidget* {
ezQtGameObjectViewWidget* pWidget =
new ezQtGameObjectViewWidget(nullptr, static_cast<ezQtPropertyAnimAssetDocumentWindow*>(pWindow), pConfig);
pWindow->AddViewWidget(pWidget);
return pWidget;
};
m_pQuadViewWidget = new ezQtQuadViewWidget(pDocument, this, ViewFactory, "PropertyAnimAssetViewToolBar");
pDocument->SetEditToolConfigDelegate(
[this](ezGameObjectEditTool* pTool) { pTool->ConfigureTool(static_cast<ezGameObjectDocument*>(GetDocument()), this, this); });
pDocument->m_PropertyAnimEvents.AddEventHandler(
ezMakeDelegate(&ezQtPropertyAnimAssetDocumentWindow::PropertyAnimAssetEventHandler, this));
setCentralWidget(m_pQuadViewWidget);
SetTargetFramerate(25);
// Menu Bar
{
ezQtMenuBarActionMapView* pMenuBar = static_cast<ezQtMenuBarActionMapView*>(menuBar());
ezActionContext context;
context.m_sMapping = "PropertyAnimAssetMenuBar";
context.m_pDocument = pDocument;
context.m_pWindow = this;
pMenuBar->SetActionContext(context);
}
// Tool Bar
{
ezQtToolBarActionMapView* pToolBar = new ezQtToolBarActionMapView("Toolbar", this);
ezActionContext context;
context.m_sMapping = "PropertyAnimAssetToolBar";
context.m_pDocument = pDocument;
context.m_pWindow = this;
pToolBar->SetActionContext(context);
pToolBar->setObjectName("PropertyAnimAssetWindowToolBar");
addToolBar(pToolBar);
}
// Game Object Graph
{
std::unique_ptr<ezQtDocumentTreeModel> pModel(new ezQtGameObjectModel(pDocument));
pModel->AddAdapter(new ezQtDummyAdapter(pDocument->GetObjectManager(), ezGetStaticRTTI<ezDocumentRoot>(), "TempObjects"));
pModel->AddAdapter(new ezQtGameObjectAdapter(pDocument));
ezQtDocumentPanel* pGameObjectPanel =
new ezQtGameObjectPanel(this, pDocument, "PropertyAnimAsset_ScenegraphContextMenu", std::move(pModel));
addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, pGameObjectPanel);
}
// Property Grid
{
ezQtDocumentPanel* pPanel = new ezQtDocumentPanel(this);
pPanel->setObjectName("PropertyAnimAssetDockWidget");
pPanel->setWindowTitle("Properties");
pPanel->show();
ezQtPropertyGridWidget* pPropertyGrid = new ezQtPropertyGridWidget(pPanel, pDocument);
pPanel->setWidget(pPropertyGrid);
addDockWidget(Qt::DockWidgetArea::RightDockWidgetArea, pPanel);
}
// Property Tree View
{
ezQtDocumentPanel* pPanel = new ezQtDocumentPanel(this);
pPanel->setObjectName("PropertyAnimPropertiesDockWidget");
pPanel->setWindowTitle("Properties");
pPanel->show();
m_pPropertyTreeView = new ezQtPropertyAnimAssetTreeView(pPanel);
m_pPropertyTreeView->setHeaderHidden(true);
m_pPropertyTreeView->setRootIsDecorated(true);
m_pPropertyTreeView->setUniformRowHeights(true);
m_pPropertyTreeView->setExpandsOnDoubleClick(false);
pPanel->setWidget(m_pPropertyTreeView);
connect(m_pPropertyTreeView, &ezQtPropertyAnimAssetTreeView::DeleteSelectedItemsEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onDeleteSelectedItems);
connect(m_pPropertyTreeView, &ezQtPropertyAnimAssetTreeView::RebindSelectedItemsEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onRebindSelectedItems);
connect(m_pPropertyTreeView, &QTreeView::doubleClicked, this, &ezQtPropertyAnimAssetDocumentWindow::onTreeItemDoubleClicked);
connect(m_pPropertyTreeView, &ezQtPropertyAnimAssetTreeView::FrameSelectedItemsEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onFrameSelectedTracks);
addDockWidget(Qt::DockWidgetArea::LeftDockWidgetArea, pPanel);
}
// Property Model
{
m_pPropertiesModel = new ezQtPropertyAnimModel(GetPropertyAnimDocument(), this);
m_pPropertyTreeView->setModel(m_pPropertiesModel);
m_pPropertyTreeView->expandToDepth(2);
m_pPropertyTreeView->initialize();
}
// Selection Model
{
m_pPropertyTreeView->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
m_pPropertyTreeView->setSelectionMode(QAbstractItemView::SelectionMode::ExtendedSelection);
m_pSelectionModel = new QItemSelectionModel(m_pPropertiesModel, this);
m_pPropertyTreeView->setSelectionModel(m_pSelectionModel);
connect(m_pSelectionModel, &QItemSelectionModel::selectionChanged, this, &ezQtPropertyAnimAssetDocumentWindow::onSelectionChanged);
}
// Float Curve Panel
{
m_pCurvePanel = new ezQtDocumentPanel(this);
m_pCurvePanel->setObjectName("PropertyAnimFloatCurveDockWidget");
m_pCurvePanel->setWindowTitle("Curves");
m_pCurvePanel->show();
m_pCurveEditor = new ezQtCurve1DEditorWidget(m_pCurvePanel);
m_pCurvePanel->setWidget(m_pCurveEditor);
addDockWidget(Qt::DockWidgetArea::BottomDockWidgetArea, m_pCurvePanel);
}
// Color Gradient Panel
{
m_pColorGradientPanel = new ezQtDocumentPanel(this);
m_pColorGradientPanel->setObjectName("PropertyAnimColorGradientDockWidget");
m_pColorGradientPanel->setWindowTitle("Color Gradient");
m_pColorGradientPanel->show();
m_pGradientEditor = new ezQtColorGradientEditorWidget(m_pColorGradientPanel);
m_pColorGradientPanel->setWidget(m_pGradientEditor);
addDockWidget(Qt::DockWidgetArea::BottomDockWidgetArea, m_pColorGradientPanel);
}
// Event Track Panel
{
m_pEventTrackPanel = new ezQtDocumentPanel(this);
m_pEventTrackPanel->setObjectName("PropertyAnimEventTrackDockWidget");
m_pEventTrackPanel->setWindowTitle("Event Track");
m_pEventTrackPanel->show();
m_pEventTrackEditor = new ezQtEventTrackEditorWidget(m_pEventTrackPanel);
m_pEventTrackPanel->setWidget(m_pEventTrackEditor);
addDockWidget(Qt::DockWidgetArea::BottomDockWidgetArea, m_pEventTrackPanel);
}
// Time Scrubber
{
m_pScrubberToolbar = new ezQtTimeScrubberToolbar(this);
connect(m_pScrubberToolbar, &ezQtTimeScrubberToolbar::ScrubberPosChangedEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onScrubberPosChanged);
connect(m_pScrubberToolbar, &ezQtTimeScrubberToolbar::PlayPauseEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onPlayPauseClicked);
connect(m_pScrubberToolbar, &ezQtTimeScrubberToolbar::RepeatEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onRepeatClicked);
connect(m_pScrubberToolbar, &ezQtTimeScrubberToolbar::DurationChangedEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onDurationChangedEvent);
connect(m_pScrubberToolbar, &ezQtTimeScrubberToolbar::AdjustDurationEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onAdjustDurationClicked);
addToolBar(Qt::ToolBarArea::BottomToolBarArea, m_pScrubberToolbar);
}
// this would show the document properties
// pDocument->GetSelectionManager()->SetSelection(pDocument->GetObjectManager()->GetRootObject()->GetChildren()[0]);
// Curve editor events
{
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::InsertCpEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveInsertCpAt);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::CpMovedEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveCpMoved);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::CpDeletedEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveCpDeleted);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::TangentMovedEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveTangentMoved);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::TangentLinkEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onLinkCurveTangents);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::CpTangentModeEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onCurveTangentModeChanged);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::BeginOperationEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onCurveBeginOperation);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::EndOperationEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveEndOperation);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::BeginCpChangesEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onCurveBeginCpChanges);
connect(m_pCurveEditor, &ezQtCurve1DEditorWidget::EndCpChangesEvent, this, &ezQtPropertyAnimAssetDocumentWindow::onCurveEndCpChanges);
}
// Gradient editor events
{
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::ColorCpAdded, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientColorCpAdded);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::ColorCpMoved, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientColorCpMoved);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::ColorCpDeleted, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientColorCpDeleted);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::ColorCpChanged, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientColorCpChanged);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::AlphaCpAdded, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientAlphaCpAdded);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::AlphaCpMoved, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientAlphaCpMoved);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::AlphaCpDeleted, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientAlphaCpDeleted);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::AlphaCpChanged, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientAlphaCpChanged);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::IntensityCpAdded, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientIntensityCpAdded);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::IntensityCpMoved, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientIntensityCpMoved);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::IntensityCpDeleted, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientIntensityCpDeleted);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::IntensityCpChanged, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientIntensityCpChanged);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::BeginOperation, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientBeginOperation);
connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::EndOperation, this,
&ezQtPropertyAnimAssetDocumentWindow::onGradientEndOperation);
// connect(m_pGradientEditor, &ezQtColorGradientEditorWidget::NormalizeRange, this,
// &ezQtPropertyAnimAssetDocumentWindow::onGradientNormalizeRange);
}
// Event track editor events
{
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::InsertCpEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackInsertCpAt);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::CpMovedEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackCpMoved);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::CpDeletedEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackCpDeleted);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::BeginOperationEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackBeginOperation);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::EndOperationEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackEndOperation);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::BeginCpChangesEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackBeginCpChanges);
connect(m_pEventTrackEditor, &ezQtEventTrackEditorWidget::EndCpChangesEvent, this,
&ezQtPropertyAnimAssetDocumentWindow::onEventTrackEndCpChanges);
}
// GetDocument()->GetObjectManager()->m_PropertyEvents.AddEventHandler(ezMakeDelegate(&ezQtPropertyAnimAssetDocumentWindow::PropertyEventHandler,
// this));
GetDocument()->GetObjectManager()->m_StructureEvents.AddEventHandler(
ezMakeDelegate(&ezQtPropertyAnimAssetDocumentWindow::StructureEventHandler, this));
GetDocument()->GetSelectionManager()->m_Events.AddEventHandler(
ezMakeDelegate(&ezQtPropertyAnimAssetDocumentWindow::SelectionEventHandler, this));
GetDocument()->GetCommandHistory()->m_Events.AddEventHandler(
ezMakeDelegate(&ezQtPropertyAnimAssetDocumentWindow::CommandHistoryEventHandler, this));
FinishWindowCreation();
{
const ezUInt64 uiDuration = GetPropertyAnimDocument()->GetAnimationDurationTicks();
m_pScrubberToolbar->SetDuration(uiDuration, GetPropertyAnimDocument()->GetProperties()->m_uiFramesPerSecond);
}
UpdateCurveEditor();
UpdateGradientEditor();
UpdateEventTrackEditor();
}
cWorldXMLReader::RESULT cWorldXMLReader::ReadFromFile(const string_t& sFilename, cWorldXMLData& data)
{
data.Clear();
// Make sure that we are loading a .world file
const string_t sExtension = spitfire::filesystem::GetExtension(sFilename);
ASSERT(sExtension == TEXT("world"));
xml::reader reader;
xml::document doc;
if (!reader.ReadFromFile(doc, sFilename)) {
LOG<<"cWorldXMLReader::ReadFromFile \""<<sFilename<<"\" not found"<<std::endl;
return RESULT_ERROR_FILE_NOT_FOUND;
}
breathe::xml::cNode::iterator iterWorld(doc);
if (!iterWorld.IsValid()) return RESULT_ERROR_FILE_NOT_FOUND;
iterWorld.FindChild("world");
if (!iterWorld.IsValid()) return RESULT_ERROR_WORLD_NODE_NOT_FOUND;
// Load models
{
breathe::xml::cNode::iterator iter(iterWorld);
iter.FindChild("models");
if (iter.IsValid()) {
iter.FindChild("model");
if (iter.IsValid()) {
while (iter.IsValid()) {
std::string sModel;
if (iter.GetAttribute("model", sModel)) {
LOG<<"Adding Model "<<sModel<<std::endl;
std::shared_ptr<cWorldModel> pModel(new cWorldModel);
pModel->model = spitfire::string::ToString_t(sModel);
iter.GetAttribute("position", pModel->position);
iter.GetAttribute("rotation", pModel->rotation);
data.models.push_back(pModel);
}
iter.Next("model");
};
}
}
}
// Load entities
{
breathe::xml::cNode::iterator iter(iterWorld);
iter.FindChild("entities");
if (iter.IsValid()) {
iter.FindChild("entity");
if (iter.IsValid()) {
while (iter.IsValid()) {
std::string sName;
if (iter.GetAttribute("name", sName)) {
LOG<<"Adding Entity "<<sName<<std::endl;
std::shared_ptr<cWorldEntity> pEntity(new cWorldEntity);
pEntity->name = spitfire::string::ToString_t(sName);
iter.GetAttribute("position", pEntity->position);
iter.GetAttribute("rotation", pEntity->rotation);
// Load properties
breathe::xml::cNode::iterator iterProperties(iter);
iterProperties.FindChild("properties");
if (iterProperties.IsValid()) {
iterProperties.FindChild("property");
if (iterProperties.IsValid()) {
while (iter.IsValid()) {
std::string sName;
std::string sValue;
iterProperties.GetAttribute("name", sName);
iterProperties.GetAttribute("value", sValue);
pEntity->properties[spitfire::string::ToString_t(sName)] = spitfire::string::ToString_t(sValue);
iterProperties.Next("property");
}
}
}
data.entities.push_back(pEntity);
}
iter.Next("entity");
};
}
}
}
// For testing saving of .world files
//SaveToFile(TEXT("/media/development/dev/sudoku/data/" ... ".world"));
return RESULT_SUCCESS;
}
