Remove more unused things from CryCommon and CrySystem. (#709)
Lots of unrelated removals, I basically tried to remove everything exposed via gEnv that isn't used anymore, and following the threads found a few other things to remove also.
This commit is contained in:
bosnichd
GitHub
@@ -1,629 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#include "EditorDefs.h"
|
||||
|
||||
#include "BackgroundScheduleManager.h"
|
||||
|
||||
namespace BackgroundScheduleManager
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CScheduleItem::CScheduleItem(const char* szName)
|
||||
: m_name(szName)
|
||||
, m_refCount(1)
|
||||
, m_state(eScheduleItemState_Pending)
|
||||
{
|
||||
}
|
||||
|
||||
CScheduleItem::~CScheduleItem()
|
||||
{
|
||||
CRY_ASSERT(m_refCount == 0);
|
||||
|
||||
for (TWorkItems::const_iterator it = m_workItems.begin();
|
||||
it != m_workItems.end(); ++it)
|
||||
{
|
||||
(*it)->Release();
|
||||
}
|
||||
}
|
||||
|
||||
const char* CScheduleItem::GetDescription() const
|
||||
{
|
||||
return m_name.c_str();
|
||||
}
|
||||
|
||||
EScheduleItemState CScheduleItem::GetState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
const float CScheduleItem::GetProgress() const
|
||||
{
|
||||
if (m_workItems.empty())
|
||||
{
|
||||
return 1.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
float totalProgress = 0.0f;
|
||||
|
||||
for (TWorkItems::const_iterator it = m_workItems.begin();
|
||||
it != m_workItems.end(); ++it)
|
||||
{
|
||||
totalProgress += (*it)->GetProgress();
|
||||
}
|
||||
|
||||
return totalProgress / (float)m_workItems.size();
|
||||
}
|
||||
}
|
||||
|
||||
const uint32 CScheduleItem::GetNumWorkItems() const
|
||||
{
|
||||
return m_workItems.size();
|
||||
}
|
||||
|
||||
IBackgroundScheduleItemWork* CScheduleItem::GetWorkItem(const uint32 index) const
|
||||
{
|
||||
return m_workItems[index];
|
||||
}
|
||||
|
||||
void CScheduleItem::AddWorkItem(IBackgroundScheduleItemWork* pWork)
|
||||
{
|
||||
// cannot add new work items when item has finished or failed
|
||||
if (m_state == eScheduleItemState_Failed || m_state == eScheduleItemState_Completed)
|
||||
{
|
||||
CryFatalError("Cannot add new work items when item has finished or failed");
|
||||
return;
|
||||
}
|
||||
|
||||
// add to the work list
|
||||
if (m_state == eScheduleItemState_Processing)
|
||||
{
|
||||
m_addedWorkItems.push_back(pWork);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_workItems.push_back(pWork);
|
||||
}
|
||||
}
|
||||
|
||||
void CScheduleItem::AddRef()
|
||||
{
|
||||
CryInterlockedIncrement(&m_refCount);
|
||||
}
|
||||
|
||||
void CScheduleItem::Release()
|
||||
{
|
||||
const int nCount = CryInterlockedDecrement(&m_refCount);
|
||||
assert(nCount >= 0);
|
||||
if (nCount == 0)
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
else if (nCount < 0)
|
||||
{
|
||||
assert(0);
|
||||
CryFatalError("Deleting Reference Counted Object Twice");
|
||||
}
|
||||
}
|
||||
|
||||
void CScheduleItem::RequestStop()
|
||||
{
|
||||
if (m_state == eScheduleItemState_Pending)
|
||||
{
|
||||
// we can stop right away :)
|
||||
m_state = eScheduleItemState_Failed;
|
||||
}
|
||||
else if (m_state == eScheduleItemState_Processing)
|
||||
{
|
||||
m_state = eScheduleItemState_Stopping;
|
||||
|
||||
// signal all pending work to stop
|
||||
uint32 curIndex = 0;
|
||||
while (curIndex < m_processedWorkItems.size())
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = m_processedWorkItems[curIndex];
|
||||
if (pWork->OnStop())
|
||||
{
|
||||
// if the work was stopped remove it from list
|
||||
m_processedWorkItems.erase(m_processedWorkItems.begin() + curIndex);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
// this work item cannot be stopped this frame
|
||||
curIndex += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// if all pending work has been stopped we can assume the failed state
|
||||
if (m_processedWorkItems.empty())
|
||||
{
|
||||
m_state = eScheduleItemState_Failed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
EScheduleWorkItemStatus CScheduleItem::Update()
|
||||
{
|
||||
EScheduleWorkItemStatus retStatus = eScheduleWorkItemStatus_NotFinished;
|
||||
|
||||
switch (m_state)
|
||||
{
|
||||
// finial state - work failed
|
||||
case eScheduleItemState_Failed:
|
||||
{
|
||||
retStatus = eScheduleWorkItemStatus_Failed;
|
||||
break;
|
||||
}
|
||||
|
||||
// final state - work completed
|
||||
case eScheduleItemState_Completed:
|
||||
{
|
||||
retStatus = eScheduleWorkItemStatus_Finished;
|
||||
break;
|
||||
}
|
||||
|
||||
// first update, start all the work items
|
||||
case eScheduleItemState_Pending:
|
||||
{
|
||||
// start all of the tasks
|
||||
bool bHasFailedStarts = false;
|
||||
for (TWorkItems::const_iterator it = m_workItems.begin();
|
||||
it != m_workItems.end(); ++it)
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = (*it);
|
||||
|
||||
if (pWork->OnStart())
|
||||
{
|
||||
m_processedWorkItems.push_back(pWork);
|
||||
}
|
||||
else
|
||||
{
|
||||
bHasFailedStarts = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (bHasFailedStarts)
|
||||
{
|
||||
m_state = eScheduleItemState_Stopping;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_state = eScheduleItemState_Processing;
|
||||
/* FALLS THROUGHT TO PROCESSING STATE */
|
||||
}
|
||||
}
|
||||
|
||||
// work processing state
|
||||
case eScheduleItemState_Processing:
|
||||
{
|
||||
// process new work items that were added while the schedule was created
|
||||
if (!m_addedWorkItems.empty())
|
||||
{
|
||||
for (TWorkItems::const_iterator it = m_addedWorkItems.begin();
|
||||
it != m_addedWorkItems.end(); ++it)
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = (*it);
|
||||
pWork->OnStart();
|
||||
m_processedWorkItems.push_back(pWork);
|
||||
m_workItems.push_back(pWork);
|
||||
}
|
||||
|
||||
m_addedWorkItems.clear();
|
||||
}
|
||||
|
||||
// update work items
|
||||
bool bHasFailedItems = false;
|
||||
TWorkItems completedItems;
|
||||
for (TWorkItems::const_iterator it = m_processedWorkItems.begin();
|
||||
it != m_processedWorkItems.end(); ++it)
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = (*it);
|
||||
|
||||
// update given work item
|
||||
const EScheduleWorkItemStatus status = pWork->OnUpdate();
|
||||
if (status == eScheduleWorkItemStatus_Finished)
|
||||
{
|
||||
completedItems.push_back(pWork);
|
||||
continue;
|
||||
}
|
||||
|
||||
// item failed - we need to stop other tasks
|
||||
if (status == eScheduleWorkItemStatus_Failed)
|
||||
{
|
||||
bHasFailedItems = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// cleanup completed items
|
||||
for (TWorkItems::iterator it = completedItems.begin();
|
||||
it != completedItems.end(); ++it)
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = (*it);
|
||||
TWorkItems::iterator jt = std::find(m_processedWorkItems.begin(), m_processedWorkItems.end(), pWork);
|
||||
m_processedWorkItems.erase(jt);
|
||||
}
|
||||
|
||||
if (!bHasFailedItems)
|
||||
{
|
||||
// all work has finished
|
||||
if (m_processedWorkItems.empty())
|
||||
{
|
||||
retStatus = eScheduleWorkItemStatus_Finished;
|
||||
m_state = eScheduleItemState_Completed;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
// some of the items failed
|
||||
m_state = eScheduleItemState_Stopping;
|
||||
/* FALL THROUGH TO STOPPING STATE */
|
||||
}
|
||||
}
|
||||
|
||||
// We are stopping failed work
|
||||
case eScheduleItemState_Stopping:
|
||||
{
|
||||
uint32 curIndex = 0;
|
||||
while (curIndex < m_processedWorkItems.size())
|
||||
{
|
||||
IBackgroundScheduleItemWork* pWork = m_processedWorkItems[curIndex];
|
||||
if (pWork->OnStop())
|
||||
{
|
||||
// if the work was stopped remove it from list
|
||||
m_processedWorkItems.erase(m_processedWorkItems.begin() + curIndex);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
// this work item cannot be stopped this frame
|
||||
curIndex += 1;
|
||||
}
|
||||
}
|
||||
|
||||
// if all pending work has been stopped we can assume the failed state
|
||||
if (m_processedWorkItems.empty())
|
||||
{
|
||||
m_state = eScheduleItemState_Failed;
|
||||
return eScheduleWorkItemStatus_Failed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return retStatus;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CSchedule::CSchedule(const char* szName)
|
||||
: m_name(szName)
|
||||
, m_refCount(1)
|
||||
, m_bCanceled(false)
|
||||
, m_currentItem(0)
|
||||
, m_state(eScheduleState_Pending)
|
||||
{
|
||||
}
|
||||
|
||||
CSchedule::~CSchedule()
|
||||
{
|
||||
CRY_ASSERT(m_refCount == 0);
|
||||
|
||||
for (TItems::const_iterator it = m_items.begin();
|
||||
it != m_items.end(); ++it)
|
||||
{
|
||||
CScheduleItem* pItem = *it;
|
||||
SAFE_RELEASE(pItem);
|
||||
}
|
||||
|
||||
m_items.clear();
|
||||
}
|
||||
|
||||
const char* CSchedule::GetDescription() const
|
||||
{
|
||||
return m_name.c_str();
|
||||
}
|
||||
|
||||
float CSchedule::GetProgress() const
|
||||
{
|
||||
if (m_currentItem >= m_items.size())
|
||||
{
|
||||
return 1.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
const float itemProgress = 1.0f / (float)(m_items.size());
|
||||
const IBackgroundScheduleItem* pItem = m_items[m_currentItem];
|
||||
return (m_currentItem + pItem->GetProgress()) * itemProgress;
|
||||
}
|
||||
}
|
||||
|
||||
IBackgroundScheduleItem* CSchedule::GetProcessedItem() const
|
||||
{
|
||||
if (m_currentItem >= m_items.size())
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
IBackgroundScheduleItem* pItem = m_items[m_currentItem];
|
||||
return pItem;
|
||||
}
|
||||
}
|
||||
|
||||
const uint32 CSchedule::GetNumItems() const
|
||||
{
|
||||
return m_items.size();
|
||||
}
|
||||
|
||||
IBackgroundScheduleItem* CSchedule::GetItem(const uint32 index) const
|
||||
{
|
||||
return m_items[index];
|
||||
}
|
||||
|
||||
EScheduleState CSchedule::GetState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
void CSchedule::Cancel()
|
||||
{
|
||||
m_bCanceled = true;
|
||||
}
|
||||
|
||||
bool CSchedule::IsCanceled() const
|
||||
{
|
||||
return m_bCanceled;
|
||||
}
|
||||
|
||||
void CSchedule::AddItem(IBackgroundScheduleItem* pItem)
|
||||
{
|
||||
if (NULL == pItem)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// we can add items only in the "pending" state
|
||||
if (pItem->GetState() != eScheduleItemState_Pending)
|
||||
{
|
||||
CryFatalError("Schedule items can be added to schedule only before their work starts");
|
||||
return;
|
||||
}
|
||||
|
||||
// item has no jobs, do not add
|
||||
if (pItem->GetNumWorkItems() == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
m_items.push_back(static_cast<CScheduleItem*>(pItem));
|
||||
pItem->AddRef();
|
||||
}
|
||||
|
||||
void CSchedule::AddRef()
|
||||
{
|
||||
CryInterlockedIncrement(&m_refCount);
|
||||
}
|
||||
|
||||
void CSchedule::Release()
|
||||
{
|
||||
const int nCount = CryInterlockedDecrement(&m_refCount);
|
||||
assert(nCount >= 0);
|
||||
if (nCount == 0)
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
else if (nCount < 0)
|
||||
{
|
||||
assert(0);
|
||||
CryFatalError("Deleting Reference Counted Object Twice");
|
||||
}
|
||||
}
|
||||
|
||||
EScheduleWorkItemStatus CSchedule::Update()
|
||||
{
|
||||
EScheduleWorkItemStatus retStatus = eScheduleWorkItemStatus_NotFinished;
|
||||
|
||||
// we have a cancel request
|
||||
if (m_bCanceled)
|
||||
{
|
||||
CryLog("Schedule '%s' was canceled", GetDescription());
|
||||
|
||||
if (m_state == eScheduleState_Processing && m_currentItem < m_items.size())
|
||||
{
|
||||
// stop the current item
|
||||
CScheduleItem* pItem = m_items[m_currentItem];
|
||||
pItem->RequestStop();
|
||||
m_state = eSccheduleState_Stopping;
|
||||
}
|
||||
else if (m_state != eScheduleState_Completed)
|
||||
{
|
||||
m_state = eScheduleState_Failed;
|
||||
return eScheduleWorkItemStatus_Failed;
|
||||
}
|
||||
}
|
||||
|
||||
// process internal state machine
|
||||
switch (m_state)
|
||||
{
|
||||
// final state - work failed
|
||||
case eScheduleState_Failed:
|
||||
{
|
||||
retStatus = eScheduleWorkItemStatus_Failed;
|
||||
break;
|
||||
}
|
||||
|
||||
// final state - work completed
|
||||
case eScheduleState_Completed:
|
||||
{
|
||||
retStatus = eScheduleWorkItemStatus_Finished;
|
||||
break;
|
||||
}
|
||||
|
||||
// stopping current task
|
||||
case eSccheduleState_Stopping:
|
||||
{
|
||||
if (m_currentItem < m_items.size())
|
||||
{
|
||||
CScheduleItem* pItem = m_items[m_currentItem];
|
||||
if (pItem->Update() != eScheduleWorkItemStatus_NotFinished)
|
||||
{
|
||||
// task was finally stopped
|
||||
m_state = eScheduleState_Failed;
|
||||
retStatus = eScheduleWorkItemStatus_Failed;
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
// first update, switch to processing
|
||||
case eScheduleState_Pending:
|
||||
{
|
||||
m_state = eScheduleState_Processing;
|
||||
m_currentItem = 0;
|
||||
/* FALLS THROUGHT */
|
||||
}
|
||||
|
||||
// if we were in the processing phase inform the current schedule item to stop all it's work
|
||||
case eScheduleState_Processing:
|
||||
{
|
||||
// update schedule items
|
||||
while (m_currentItem < m_items.size())
|
||||
{
|
||||
CScheduleItem* pItem = m_items[m_currentItem];
|
||||
|
||||
const EScheduleWorkItemStatus itemStatus = pItem->Update();
|
||||
if (itemStatus == eScheduleWorkItemStatus_Finished)
|
||||
{
|
||||
m_currentItem += 1;
|
||||
continue;
|
||||
}
|
||||
else if (itemStatus == eScheduleWorkItemStatus_Failed)
|
||||
{
|
||||
m_state = eScheduleState_Failed;
|
||||
retStatus = eScheduleWorkItemStatus_Failed;
|
||||
gEnv->pLog->LogWarning("Schedule '%s' failed on item '%s'.", GetDescription(), pItem->GetDescription());
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
// all items updated
|
||||
if (m_currentItem >= m_items.size())
|
||||
{
|
||||
// empty schedule, complete in one tick
|
||||
m_state = eScheduleState_Completed;
|
||||
retStatus = eScheduleWorkItemStatus_Finished;
|
||||
CryLog("Schedule '%s' completed", GetDescription());
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return retStatus;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CScheduleManager::CScheduleManager()
|
||||
{
|
||||
GetIEditor()->RegisterNotifyListener(this);
|
||||
}
|
||||
|
||||
CScheduleManager::~CScheduleManager()
|
||||
{
|
||||
GetIEditor()->UnregisterNotifyListener(this);
|
||||
|
||||
for (TSchedules::const_iterator it = m_schedules.begin();
|
||||
it != m_schedules.end(); ++it)
|
||||
{
|
||||
CSchedule* pSchedule = *it;
|
||||
SAFE_RELEASE(pSchedule);
|
||||
}
|
||||
|
||||
m_schedules.clear();
|
||||
}
|
||||
|
||||
IBackgroundSchedule* CScheduleManager::CreateSchedule(const char* szName)
|
||||
{
|
||||
return new CSchedule(szName);
|
||||
}
|
||||
|
||||
IBackgroundScheduleItem* CScheduleManager::CreateScheduleItem(const char* szName)
|
||||
{
|
||||
return new CScheduleItem(szName);
|
||||
}
|
||||
|
||||
void CScheduleManager::SubmitSchedule(IBackgroundSchedule* pSchedule)
|
||||
{
|
||||
if (NULL != pSchedule)
|
||||
{
|
||||
if (pSchedule->GetState() != eScheduleState_Pending)
|
||||
{
|
||||
CryFatalError("Only schedules with pending state can be submitted");
|
||||
return;
|
||||
}
|
||||
|
||||
pSchedule->AddRef();
|
||||
m_schedules.push_back(static_cast<CSchedule*>(pSchedule));
|
||||
}
|
||||
}
|
||||
|
||||
const uint32 CScheduleManager::GetNumSchedules() const
|
||||
{
|
||||
return m_schedules.size();
|
||||
}
|
||||
|
||||
IBackgroundSchedule* CScheduleManager::GetSchedule(const uint32 index) const
|
||||
{
|
||||
return m_schedules[index];
|
||||
}
|
||||
|
||||
void CScheduleManager::Update()
|
||||
{
|
||||
while (!m_schedules.empty())
|
||||
{
|
||||
CSchedule* pSchedule = m_schedules[0];
|
||||
|
||||
const EScheduleWorkItemStatus status = pSchedule->Update();
|
||||
if (status == eScheduleWorkItemStatus_NotFinished)
|
||||
{
|
||||
// we need more work next frame
|
||||
break;
|
||||
}
|
||||
|
||||
// schedule has finished, remove current reference
|
||||
m_schedules.erase(m_schedules.begin());
|
||||
SAFE_RELEASE(pSchedule);
|
||||
}
|
||||
}
|
||||
|
||||
void CScheduleManager::OnEditorNotifyEvent(EEditorNotifyEvent ev)
|
||||
{
|
||||
switch (ev)
|
||||
{
|
||||
case eNotify_OnQuit:
|
||||
GetIEditor()->UnregisterNotifyListener(this);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
} // BackgroundScheduleManager
|
||||
@@ -1,117 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_EDITOR_BACKGROUNDSCHEDULEMANAGER_H
|
||||
#define CRYINCLUDE_EDITOR_BACKGROUNDSCHEDULEMANAGER_H
|
||||
#pragma once
|
||||
|
||||
#include "Include/IBackgroundScheduleManager.h"
|
||||
|
||||
namespace BackgroundScheduleManager
|
||||
{
|
||||
class CScheduleItem
|
||||
: public IBackgroundScheduleItem
|
||||
{
|
||||
private:
|
||||
std::string m_name;
|
||||
volatile int m_refCount;
|
||||
|
||||
EScheduleItemState m_state;
|
||||
|
||||
typedef std::vector<IBackgroundScheduleItemWork*> TWorkItems;
|
||||
TWorkItems m_workItems;
|
||||
TWorkItems m_addedWorkItems;
|
||||
TWorkItems m_processedWorkItems;
|
||||
|
||||
public:
|
||||
CScheduleItem(const char* szName);
|
||||
virtual ~CScheduleItem();
|
||||
|
||||
// IBackgroundScheduleItem interface
|
||||
virtual const char* GetDescription() const;
|
||||
virtual EScheduleItemState GetState() const;
|
||||
virtual const float GetProgress() const;
|
||||
virtual const uint32 GetNumWorkItems() const;
|
||||
virtual IBackgroundScheduleItemWork* GetWorkItem(const uint32 index) const;
|
||||
virtual void AddWorkItem(IBackgroundScheduleItemWork* pWork);
|
||||
virtual void AddRef();
|
||||
virtual void Release();
|
||||
|
||||
// Update schedule item
|
||||
EScheduleWorkItemStatus Update();
|
||||
|
||||
// Request to stop work in this item
|
||||
void RequestStop();
|
||||
};
|
||||
|
||||
class CSchedule
|
||||
: public IBackgroundSchedule
|
||||
{
|
||||
private:
|
||||
std::string m_name;
|
||||
volatile int m_refCount;
|
||||
bool m_bCanceled;
|
||||
|
||||
EScheduleState m_state;
|
||||
|
||||
typedef std::vector<CScheduleItem*> TItems;
|
||||
TItems m_items;
|
||||
|
||||
uint32 m_currentItem;
|
||||
|
||||
public:
|
||||
CSchedule(const char* szName);
|
||||
virtual ~CSchedule();
|
||||
|
||||
// IBackgroundSchedule interface
|
||||
virtual const char* GetDescription() const;
|
||||
virtual float GetProgress() const;
|
||||
virtual IBackgroundScheduleItem* GetProcessedItem() const;
|
||||
virtual const uint32 GetNumItems() const;
|
||||
virtual IBackgroundScheduleItem* GetItem(const uint32 index) const;
|
||||
virtual EScheduleState GetState() const;
|
||||
virtual void Cancel();
|
||||
virtual bool IsCanceled() const;
|
||||
virtual void AddItem(IBackgroundScheduleItem* pItem);
|
||||
virtual void AddRef();
|
||||
virtual void Release();
|
||||
|
||||
// Update schedule item
|
||||
EScheduleWorkItemStatus Update();
|
||||
};
|
||||
|
||||
class CScheduleManager
|
||||
: public IBackgroundScheduleManager
|
||||
, public IEditorNotifyListener
|
||||
{
|
||||
private:
|
||||
typedef std::vector<CSchedule*> TSchedules;
|
||||
TSchedules m_schedules;
|
||||
|
||||
public:
|
||||
CScheduleManager();
|
||||
virtual ~CScheduleManager();
|
||||
|
||||
// IBackgroundScheduleManager interface
|
||||
virtual IBackgroundSchedule* CreateSchedule(const char* szName);
|
||||
virtual IBackgroundScheduleItem* CreateScheduleItem(const char* szName);
|
||||
virtual void SubmitSchedule(IBackgroundSchedule* pSchedule);
|
||||
virtual const uint32 GetNumSchedules() const;
|
||||
virtual IBackgroundSchedule* GetSchedule(const uint32 index) const;
|
||||
virtual void Update();
|
||||
|
||||
// IEditorNotifyListener interface implementation
|
||||
virtual void OnEditorNotifyEvent(EEditorNotifyEvent ev) override;
|
||||
};
|
||||
}
|
||||
#endif // CRYINCLUDE_EDITOR_BACKGROUNDSCHEDULEMANAGER_H
|
||||
@@ -1,410 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#include "EditorDefs.h"
|
||||
|
||||
#include "BackgroundTaskManager.h"
|
||||
|
||||
namespace BackgroundTaskManager
|
||||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CTaskManager::CThread::CThread(class CTaskManager* pManager, CQueue* pQueue)
|
||||
: m_pManager(pManager)
|
||||
, m_pQueue(pQueue)
|
||||
{
|
||||
start();
|
||||
}
|
||||
|
||||
CTaskManager::CThread::~CThread()
|
||||
{
|
||||
}
|
||||
|
||||
void CTaskManager::CThread::WaitForThread()
|
||||
{
|
||||
wait();
|
||||
}
|
||||
|
||||
void CTaskManager::CThread::run()
|
||||
{
|
||||
CryThreadSetName(-1, "BackgroundTaskThread");
|
||||
|
||||
while (!m_pManager->IsStopped())
|
||||
{
|
||||
STaskHandle taskHandle;
|
||||
|
||||
// This blocks on Semaphore waiting for task from queue
|
||||
m_pQueue->PopTask(taskHandle);
|
||||
|
||||
// Should not happen but it's a stupid way to crash :)
|
||||
if (NULL == taskHandle.pTask)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (taskHandle.pTask->IsCanceled())
|
||||
{
|
||||
// Task was canceled before we got here
|
||||
m_pManager->AddCompletedTask(taskHandle, eTaskResult_Canceled);
|
||||
}
|
||||
else
|
||||
{
|
||||
const ETaskResult state = taskHandle.pTask->Work();
|
||||
|
||||
if (state == eTaskResult_Resume)
|
||||
{
|
||||
// Put it back into queue, so more important task can take over.
|
||||
m_pManager->AddTask(taskHandle);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Finish task
|
||||
m_pManager->AddCompletedTask(taskHandle, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CTaskManager::CQueue::CQueue()
|
||||
: m_semaphore(INT_MAX, 0) // no good maximum value, assume worst case
|
||||
{
|
||||
}
|
||||
|
||||
void CTaskManager::CQueue::AddTask(const STaskHandle& taskHandle)
|
||||
{
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_lock);
|
||||
|
||||
// TODO: use heap?
|
||||
m_pendingTasks.insert(m_pendingTasks.begin(), taskHandle);
|
||||
std::stable_sort(m_pendingTasks.begin(), m_pendingTasks.end());
|
||||
}
|
||||
|
||||
taskHandle.pTask->SetState(eTaskState_Pending);
|
||||
|
||||
// release internal semaphore so threads can pick up the work
|
||||
m_semaphore.Release();
|
||||
}
|
||||
|
||||
void CTaskManager::CQueue::PopTask(STaskHandle& outTaskHandle)
|
||||
{
|
||||
// wait for job
|
||||
m_semaphore.Acquire();
|
||||
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_lock);
|
||||
|
||||
if (m_pendingTasks.empty())
|
||||
{
|
||||
outTaskHandle.pTask = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
outTaskHandle = m_pendingTasks.back();
|
||||
outTaskHandle.pTask->SetState(eTaskState_Working);
|
||||
m_pendingTasks.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::CQueue::ReleaseSemaphore()
|
||||
{
|
||||
m_semaphore.Release();
|
||||
}
|
||||
|
||||
void CTaskManager::CQueue::Clear()
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_lock);
|
||||
for (uint i = 0; i < m_pendingTasks.size(); ++i)
|
||||
{
|
||||
m_pendingTasks[i].pTask->Release();
|
||||
}
|
||||
|
||||
m_pendingTasks.clear();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
CTaskManager::CTaskManager()
|
||||
: m_bStop(false)
|
||||
, m_nextTaskID(1)
|
||||
, m_listeners(1)
|
||||
{
|
||||
GetIEditor()->RegisterNotifyListener(this);
|
||||
}
|
||||
|
||||
CTaskManager::~CTaskManager()
|
||||
{
|
||||
if (!m_bStop)
|
||||
{
|
||||
Stop();
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::Start(const uint32 threadCount /*=kDefaultThreadCount*/)
|
||||
{
|
||||
m_bStop = false;
|
||||
|
||||
if (m_pThreads.empty())
|
||||
{
|
||||
// Always create one IO thread
|
||||
{
|
||||
CThread* pThread = new CThread(this, &m_pendingTasks[ eTaskThreadMask_IO ]);
|
||||
m_pThreads.push_back(pThread);
|
||||
}
|
||||
|
||||
// We also need at least one generic thread
|
||||
const uint32 numGenericThreads = max<uint32>(threadCount, 1);
|
||||
for (uint32 i = 0; i < numGenericThreads; ++i)
|
||||
{
|
||||
CThread* pThread = new CThread(this, &m_pendingTasks[ eTaskThreadMask_Any ]);
|
||||
m_pThreads.push_back(pThread);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::StartScheduledTasks()
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_tasksLock);
|
||||
|
||||
if (!m_scheduledTasks.empty())
|
||||
{
|
||||
const unsigned int time = GetTickCount();
|
||||
while (!m_scheduledTasks.empty())
|
||||
{
|
||||
const int delta = (int)(time - m_scheduledTasks[0].time);
|
||||
if (delta > 0)
|
||||
{
|
||||
// the soonest task on the list is still in the future, no point in looking at the next entries in the list
|
||||
break;
|
||||
}
|
||||
|
||||
// promote the scheduled task to be a full task
|
||||
AddTask(m_scheduledTasks[0].handle);
|
||||
|
||||
// We held a reference to the task on list, release it
|
||||
m_scheduledTasks[0].handle.pTask->Release();
|
||||
|
||||
m_scheduledTasks.erase(m_scheduledTasks.begin());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::Stop()
|
||||
{
|
||||
if (!m_bStop)
|
||||
{
|
||||
m_bStop = true;
|
||||
GetIEditor()->UnregisterNotifyListener(this);
|
||||
|
||||
// clear queues - no new tasks will be processed
|
||||
for (uint32 i = 0; i < eTaskThreadMask_COUNT; ++i)
|
||||
{
|
||||
m_pendingTasks[i].Clear();
|
||||
}
|
||||
|
||||
// kick all the threads to allow them to quit
|
||||
for (uint32 j = 0; j < m_pThreads.size(); ++j)
|
||||
{
|
||||
for (uint32 i = 0; i < eTaskThreadMask_COUNT; ++i)
|
||||
{
|
||||
m_pendingTasks[i].ReleaseSemaphore();
|
||||
}
|
||||
}
|
||||
|
||||
// Stop threads
|
||||
for (TWorkerThreads::iterator it = m_pThreads.begin();
|
||||
it != m_pThreads.end(); ++it)
|
||||
{
|
||||
(*it)->WaitForThread();
|
||||
delete *it;
|
||||
}
|
||||
|
||||
m_pThreads.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::AddListener(IBackgroundTaskManagerListener* pListener, const char* name)
|
||||
{
|
||||
m_listeners.Add(pListener, name);
|
||||
}
|
||||
|
||||
void CTaskManager::RemoveListener(IBackgroundTaskManagerListener* pListener)
|
||||
{
|
||||
m_listeners.Remove(pListener);
|
||||
}
|
||||
|
||||
void CTaskManager::AddTask(IBackgroundTask* pTask, ETaskPriority priority, ETaskThreadMask threadMask)
|
||||
{
|
||||
MAKE_SURE(pTask != 0, return );
|
||||
|
||||
// keep an extra reference to the task in the manager
|
||||
pTask->AddRef();
|
||||
|
||||
STaskHandle handle;
|
||||
handle.id = CryInterlockedIncrement(&m_nextTaskID);
|
||||
handle.priority = priority;
|
||||
handle.threadMask = threadMask;
|
||||
handle.pTask = pTask;
|
||||
|
||||
AddTask(handle);
|
||||
|
||||
for (TListeners::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
|
||||
{
|
||||
notifier->OnBackgroundTaskAdded(pTask->Description());
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::ScheduleTask(IBackgroundTask* pTask, ETaskPriority priority, int delayMilliseconds, ETaskThreadMask threadMask)
|
||||
{
|
||||
MAKE_SURE(delayMilliseconds >= 0, return );
|
||||
MAKE_SURE(pTask != 0, return );
|
||||
|
||||
// keep an extra reference to the task in the manager
|
||||
pTask->AddRef();
|
||||
|
||||
SScheduledTask task;
|
||||
task.time = GetTickCount() + delayMilliseconds;
|
||||
task.handle.pTask = pTask;
|
||||
task.handle.id = CryInterlockedIncrement(&m_nextTaskID);
|
||||
task.handle.threadMask = threadMask;
|
||||
task.handle.priority = priority;
|
||||
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_tasksLock);
|
||||
m_scheduledTasks.push_back(task);
|
||||
}
|
||||
|
||||
for (TListeners::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
|
||||
{
|
||||
notifier->OnBackgroundTaskAdded(pTask->Description());
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::AddTask(const STaskHandle& handle)
|
||||
{
|
||||
MAKE_SURE(handle.pTask != 0, return );
|
||||
MAKE_SURE(handle.id != 0, return );
|
||||
|
||||
// add task to appropriate queue (every thread mask has it's own queue)
|
||||
m_pendingTasks[handle.threadMask].AddTask(handle);
|
||||
}
|
||||
|
||||
void CTaskManager::AddCompletedTask(const STaskHandle& handle, ETaskResult resultState)
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_tasksLock);
|
||||
|
||||
CRY_ASSERT(handle.pTask->GetState() == eTaskState_Working);
|
||||
CRY_ASSERT(resultState != eTaskResult_Resume);
|
||||
|
||||
// Update task state
|
||||
switch (resultState)
|
||||
{
|
||||
case eTaskResult_Canceled:
|
||||
{
|
||||
handle.pTask->SetState(eTaskState_Canceled);
|
||||
break;
|
||||
}
|
||||
|
||||
case eTaskResult_Completed:
|
||||
{
|
||||
handle.pTask->SetState(eTaskState_Completed);
|
||||
break;
|
||||
}
|
||||
|
||||
case eTaskResult_Failed:
|
||||
{
|
||||
handle.pTask->SetState(eTaskState_Failed);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// add to the list of completed tasks (for calling the Finalize)
|
||||
// TODO: some of the tasks do not require Finalize() and they could be released here instead of the main thread
|
||||
SCompletedTask info;
|
||||
info.pTask = handle.pTask;
|
||||
info.id = handle.id;
|
||||
info.state = resultState;
|
||||
m_completedTasks.push_back(info);
|
||||
}
|
||||
|
||||
void CTaskManager::Update()
|
||||
{
|
||||
std::vector<SCompletedTask> completedTasks;
|
||||
{
|
||||
CryAutoLock<CryMutex> lock(m_tasksLock);
|
||||
m_completedTasks.swap(completedTasks);
|
||||
}
|
||||
|
||||
// call finalize for the completed tasks
|
||||
for (size_t i = 0; i < completedTasks.size(); ++i)
|
||||
{
|
||||
SCompletedTask& handle = completedTasks[i];
|
||||
|
||||
if (NULL != handle.pTask)
|
||||
{
|
||||
string description = handle.pTask->Description(); // copy string as the description is used after pTask is destroyed
|
||||
|
||||
if (handle.state == eTaskResult_Completed)
|
||||
{
|
||||
if (description && description[0] != '\0')
|
||||
{
|
||||
gEnv->pLog->Log("Task Completed: %s", description.c_str());
|
||||
}
|
||||
}
|
||||
else if (handle.state == eTaskResult_Failed)
|
||||
{
|
||||
if (description && description[0] != '\0' && !handle.pTask->FailReported())
|
||||
{
|
||||
gEnv->pLog->LogError("Task Failed: %s ", description.c_str());
|
||||
|
||||
const char* errorMessage = handle.pTask->ErrorMessage();
|
||||
if (errorMessage && errorMessage[0] != '\0')
|
||||
{
|
||||
gEnv->pLog->LogError("\tReason: [%s]", errorMessage);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
handle.pTask->Finalize();
|
||||
|
||||
// release the internal (task manager) reference.
|
||||
// Tthis is usually the last reference to the task so it gets deleted here.
|
||||
handle.pTask->Release();
|
||||
|
||||
for (TListeners::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
|
||||
{
|
||||
notifier->OnBackgroundTaskCompleted(handle.state, description.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CTaskManager::OnEditorNotifyEvent(EEditorNotifyEvent ev)
|
||||
{
|
||||
switch (ev)
|
||||
{
|
||||
case eNotify_OnInit:
|
||||
Start();
|
||||
break;
|
||||
case eNotify_OnIdleUpdate:
|
||||
Update();
|
||||
break;
|
||||
case eNotify_OnQuit:
|
||||
Stop();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,161 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_EDITOR_BACKGROUNDTASKMANAGER_H
|
||||
#define CRYINCLUDE_EDITOR_BACKGROUNDTASKMANAGER_H
|
||||
#pragma once
|
||||
|
||||
#include "Include/IBackgroundTaskManager.h"
|
||||
#include "CryListenerSet.h"
|
||||
|
||||
#include <QThread>
|
||||
|
||||
namespace BackgroundTaskManager
|
||||
{
|
||||
typedef int TTaskID;
|
||||
|
||||
struct STaskHandle
|
||||
{
|
||||
ETaskPriority priority;
|
||||
ETaskThreadMask threadMask;
|
||||
TTaskID id;
|
||||
IBackgroundTask* pTask;
|
||||
|
||||
bool operator<(const STaskHandle& rhs) const
|
||||
{
|
||||
if (priority < rhs.priority)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (priority > rhs.priority)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return id < rhs.id;
|
||||
}
|
||||
};
|
||||
|
||||
struct SCompletedTask
|
||||
{
|
||||
ETaskResult state;
|
||||
TTaskID id;
|
||||
ETaskThreadMask threadMask;
|
||||
IBackgroundTask* pTask;
|
||||
};
|
||||
|
||||
struct SScheduledTask
|
||||
{
|
||||
unsigned int time;
|
||||
STaskHandle handle;
|
||||
};
|
||||
|
||||
class CTaskManager
|
||||
: public IBackgroundTaskManager
|
||||
, public IEditorNotifyListener
|
||||
{
|
||||
public:
|
||||
CTaskManager();
|
||||
~CTaskManager();
|
||||
|
||||
// IBackgroundTaskManager interface implementation
|
||||
virtual void AddTask(IBackgroundTask* pTask, ETaskPriority priority, ETaskThreadMask threadMask) override;
|
||||
virtual void ScheduleTask(IBackgroundTask* pTask, ETaskPriority priority, int delayMilliseconds, ETaskThreadMask threadMask) override;
|
||||
void AddListener(IBackgroundTaskManagerListener* pListener, const char* name) override;
|
||||
void RemoveListener(IBackgroundTaskManagerListener* pListener) override;
|
||||
|
||||
private:
|
||||
// IEditorNotifyListener interface implementation
|
||||
virtual void OnEditorNotifyEvent(EEditorNotifyEvent ev) override;
|
||||
|
||||
void Start(const uint32 threadCount = kDefaultThreadCount);
|
||||
void Stop();
|
||||
void StartScheduledTasks();
|
||||
void AddTask(const STaskHandle& outTask);
|
||||
void AddCompletedTask(const STaskHandle& outTask, ETaskResult resultState);
|
||||
void Update();
|
||||
|
||||
inline bool IsStopped() const
|
||||
{
|
||||
return m_bStop;
|
||||
}
|
||||
|
||||
private:
|
||||
// Internal queue (per thread mask)
|
||||
class CQueue
|
||||
{
|
||||
public:
|
||||
CQueue();
|
||||
|
||||
// Add task to list
|
||||
void AddTask(const STaskHandle& taskHandle);
|
||||
|
||||
// Pop task from list
|
||||
void PopTask(STaskHandle& outTaskHandle);
|
||||
|
||||
// Release thread semaphore without adding a task
|
||||
void ReleaseSemaphore();
|
||||
|
||||
// Remove all pending tasks
|
||||
void Clear();
|
||||
|
||||
private:
|
||||
CrySemaphore m_semaphore;
|
||||
std::vector<STaskHandle> m_pendingTasks;
|
||||
CryMutex m_lock;
|
||||
};
|
||||
|
||||
// Worker thread class implementation
|
||||
class CThread : public QThread
|
||||
{
|
||||
public:
|
||||
CThread(CTaskManager* pManager, CQueue* pQueue);
|
||||
~CThread();
|
||||
|
||||
void WaitForThread();
|
||||
|
||||
private:
|
||||
void run() override;
|
||||
|
||||
private:
|
||||
CTaskManager* m_pManager;
|
||||
CQueue* m_pQueue;
|
||||
};
|
||||
|
||||
private:
|
||||
static const uint32 kMaxThreadCloseWaitTime = 10000; // ms
|
||||
static const uint32 kDefaultThreadCount = 4; // good enough for LiveCreate (main user right now), do not set to less than 2
|
||||
|
||||
CQueue m_pendingTasks[ eTaskThreadMask_COUNT ];
|
||||
|
||||
// Task scheduled for execution in the future
|
||||
std::vector<SScheduledTask> m_scheduledTasks;
|
||||
|
||||
// Completed tasks (waiting for the "finalize" call)
|
||||
std::vector<SCompletedTask> m_completedTasks;
|
||||
|
||||
volatile TTaskID m_nextTaskID;
|
||||
|
||||
typedef std::vector<CThread*> TWorkerThreads;
|
||||
TWorkerThreads m_pThreads;
|
||||
|
||||
CryMutex m_tasksLock;
|
||||
bool m_bStop;
|
||||
|
||||
typedef CListenerSet<IBackgroundTaskManagerListener*> TListeners;
|
||||
TListeners m_listeners;
|
||||
};
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#endif // CRYINCLUDE_EDITOR_BACKGROUNDTASKMANAGER_H
|
||||
@@ -112,7 +112,6 @@ ly_add_target(
|
||||
3rdParty::zlib
|
||||
3rdParty::AWSNativeSDK::STS
|
||||
Legacy::CryCommon
|
||||
Legacy::CryCommon.EngineSettings.Static
|
||||
Legacy::EditorCommon
|
||||
AZ::AzCore
|
||||
AZ::AzToolsFramework
|
||||
|
||||
@@ -85,7 +85,6 @@ AZ_POP_DISABLE_WARNING
|
||||
// Editor
|
||||
#include "Settings.h"
|
||||
|
||||
#include "Include/IBackgroundScheduleManager.h"
|
||||
#include "GameExporter.h"
|
||||
#include "GameResourcesExporter.h"
|
||||
|
||||
@@ -2314,15 +2313,6 @@ int CCryEditApp::IdleProcessing(bool bBackgroundUpdate)
|
||||
#endif
|
||||
}
|
||||
|
||||
// process the work schedule - regardless if the app is active or not
|
||||
GetIEditor()->GetBackgroundScheduleManager()->Update();
|
||||
|
||||
// if there are active schedules keep updating the application
|
||||
if (GetIEditor()->GetBackgroundScheduleManager()->GetNumSchedules() > 0)
|
||||
{
|
||||
bActive = true;
|
||||
}
|
||||
|
||||
m_bPrevActive = bActive;
|
||||
|
||||
AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
|
||||
|
||||
@@ -420,7 +420,6 @@ AZ::Outcome<void, AZStd::string> CGameEngine::Init(
|
||||
#else
|
||||
sip.hWnd = hwndForInputSystem;
|
||||
#endif
|
||||
sip.hWndForInputSystem = hwndForInputSystem;
|
||||
|
||||
sip.pLogCallback = &m_logFile;
|
||||
sip.sLogFileName = "@log@/Editor.log";
|
||||
@@ -503,7 +502,6 @@ AZ::Outcome<void, AZStd::string> CGameEngine::Init(
|
||||
|
||||
bool CGameEngine::InitGame(const char*)
|
||||
{
|
||||
// in editor we do it later, bExecuteCommandLine was set to false
|
||||
m_pISystem->ExecuteCommandLine();
|
||||
|
||||
return true;
|
||||
@@ -608,8 +606,6 @@ void CGameEngine::SwitchToInGame()
|
||||
|
||||
GetIEditor()->Notify(eNotify_OnBeginGameMode);
|
||||
|
||||
m_pISystem->SetThreadState(ESubsys_Physics, false);
|
||||
|
||||
m_pISystem->GetIMovieSystem()->EnablePhysicsEvents(true);
|
||||
m_bInGameMode = true;
|
||||
|
||||
@@ -646,8 +642,6 @@ void CGameEngine::SwitchToInEditor()
|
||||
}
|
||||
m_pISystem->GetIMovieSystem()->Reset(false, false);
|
||||
|
||||
m_pISystem->SetThreadState(ESubsys_Physics, false);
|
||||
|
||||
CViewport* pGameViewport = GetIEditor()->GetViewManager()->GetGameViewport();
|
||||
|
||||
m_pISystem->GetIMovieSystem()->EnablePhysicsEvents(m_bSimulationMode);
|
||||
@@ -791,8 +785,6 @@ void CGameEngine::SetSimulationMode(bool enabled, bool bOnlyPhysics)
|
||||
// Enables engine to know about simulation mode.
|
||||
gEnv->SetIsEditorSimulationMode(enabled);
|
||||
|
||||
m_pISystem->SetThreadState(ESubsys_Physics, false);
|
||||
|
||||
if (m_bSimulationMode)
|
||||
{
|
||||
// [Anton] the order of the next 3 calls changed, since, EVENT_INGAME loads physics state (if any),
|
||||
@@ -903,19 +895,6 @@ void CGameEngine::Update()
|
||||
// [marco] check current sound and vis areas for music etc.
|
||||
// but if in game mode, 'cos is already done in the above call to game->update()
|
||||
unsigned int updateFlags = ESYSUPDATE_EDITOR;
|
||||
|
||||
if (!m_bSimulationMode)
|
||||
{
|
||||
updateFlags |= ESYSUPDATE_IGNORE_PHYSICS;
|
||||
}
|
||||
|
||||
bool bUpdateAIPhysics = GetSimulationMode();
|
||||
|
||||
if (bUpdateAIPhysics)
|
||||
{
|
||||
updateFlags |= ESYSUPDATE_EDITOR_AI_PHYSICS;
|
||||
}
|
||||
|
||||
GetIEditor()->GetAnimation()->Update();
|
||||
GetIEditor()->GetSystem()->UpdatePreTickBus(updateFlags);
|
||||
componentApplication->Tick(gEnv->pTimer->GetFrameTime(ITimer::ETIMER_GAME));
|
||||
|
||||
@@ -550,7 +550,6 @@ struct IEditor
|
||||
virtual class CViewManager* GetViewManager() = 0;
|
||||
virtual class CViewport* GetActiveView() = 0;
|
||||
virtual void SetActiveView(CViewport* viewport) = 0;
|
||||
virtual struct IBackgroundTaskManager* GetBackgroundTaskManager() = 0;
|
||||
virtual struct IEditorFileMonitor* GetFileMonitor() = 0;
|
||||
|
||||
// These are needed for Qt integration:
|
||||
@@ -720,7 +719,6 @@ struct IEditor
|
||||
virtual ESystemConfigPlatform GetEditorConfigPlatform() const = 0;
|
||||
virtual void ReloadTemplates() = 0;
|
||||
virtual IResourceSelectorHost* GetResourceSelectorHost() = 0;
|
||||
virtual struct IBackgroundScheduleManager* GetBackgroundScheduleManager() = 0;
|
||||
virtual void ShowStatusText(bool bEnable) = 0;
|
||||
|
||||
// Provides a way to extend the context menu of an object. The function gets called every time the menu is opened.
|
||||
|
||||
@@ -66,8 +66,6 @@ AZ_POP_DISABLE_WARNING
|
||||
#include "Objects/SelectionGroup.h"
|
||||
#include "Objects/ObjectManager.h"
|
||||
|
||||
#include "BackgroundTaskManager.h"
|
||||
#include "BackgroundScheduleManager.h"
|
||||
#include "EditorFileMonitor.h"
|
||||
#include "MainStatusBar.h"
|
||||
|
||||
@@ -176,8 +174,6 @@ CEditorImpl::CEditorImpl()
|
||||
regCtx.pCommandManager = m_pCommandManager;
|
||||
regCtx.pClassFactory = m_pClassFactory;
|
||||
m_pEditorFileMonitor.reset(new CEditorFileMonitor());
|
||||
m_pBackgroundTaskManager.reset(new BackgroundTaskManager::CTaskManager);
|
||||
m_pBackgroundScheduleManager.reset(new BackgroundScheduleManager::CScheduleManager);
|
||||
m_pUIEnumsDatabase = new CUIEnumsDatabase;
|
||||
m_pDisplaySettings = new CDisplaySettings;
|
||||
m_pDisplaySettings->LoadRegistry();
|
||||
@@ -843,16 +839,6 @@ IIconManager* CEditorImpl::GetIconManager()
|
||||
return m_pIconManager;
|
||||
}
|
||||
|
||||
IBackgroundTaskManager* CEditorImpl::GetBackgroundTaskManager()
|
||||
{
|
||||
return m_pBackgroundTaskManager.get();
|
||||
}
|
||||
|
||||
IBackgroundScheduleManager* CEditorImpl::GetBackgroundScheduleManager()
|
||||
{
|
||||
return m_pBackgroundScheduleManager.get();
|
||||
}
|
||||
|
||||
IEditorFileMonitor* CEditorImpl::GetFileMonitor()
|
||||
{
|
||||
return m_pEditorFileMonitor.get();
|
||||
|
||||
@@ -43,15 +43,12 @@ class CGameEngine;
|
||||
class CExportManager;
|
||||
class CErrorsDlg;
|
||||
class CIconManager;
|
||||
class CBackgroundTaskManager;
|
||||
class CTrackViewSequenceManager;
|
||||
class CEditorFileMonitor;
|
||||
class AzAssetWindow;
|
||||
class AzAssetBrowserRequestHandler;
|
||||
class AssetEditorRequestsHandler;
|
||||
class CAlembicCompiler;
|
||||
struct IBackgroundTaskManager;
|
||||
struct IBackgroundScheduleManager;
|
||||
struct IEditorFileMonitor;
|
||||
class CVegetationMap;
|
||||
|
||||
@@ -61,16 +58,6 @@ namespace Editor
|
||||
class EditorQtApplication;
|
||||
}
|
||||
|
||||
namespace BackgroundScheduleManager
|
||||
{
|
||||
class CScheduleManager;
|
||||
}
|
||||
|
||||
namespace BackgroundTaskManager
|
||||
{
|
||||
class CTaskManager;
|
||||
}
|
||||
|
||||
namespace WinWidget
|
||||
{
|
||||
class WinWidgetManager;
|
||||
@@ -179,8 +166,6 @@ public:
|
||||
IDataBaseManager* GetDBItemManager(EDataBaseItemType itemType);
|
||||
CMusicManager* GetMusicManager() { return m_pMusicManager; };
|
||||
|
||||
IBackgroundTaskManager* GetBackgroundTaskManager() override;
|
||||
IBackgroundScheduleManager* GetBackgroundScheduleManager() override;
|
||||
IEditorFileMonitor* GetFileMonitor() override;
|
||||
void RegisterEventLoopHook(IEventLoopHook* pHook) override;
|
||||
void UnregisterEventLoopHook(IEventLoopHook* pHook) override;
|
||||
@@ -394,8 +379,6 @@ protected:
|
||||
|
||||
//! Export manager for exporting objects and a terrain from the game to DCC tools
|
||||
CExportManager* m_pExportManager;
|
||||
std::unique_ptr<BackgroundTaskManager::CTaskManager> m_pBackgroundTaskManager;
|
||||
std::unique_ptr<BackgroundScheduleManager::CScheduleManager> m_pBackgroundScheduleManager;
|
||||
std::unique_ptr<CEditorFileMonitor> m_pEditorFileMonitor;
|
||||
std::unique_ptr<IResourceSelectorHost> m_pResourceSelectorHost;
|
||||
QString m_selectFileBuffer;
|
||||
|
||||
@@ -1,207 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
//
|
||||
// IBackgroundScheduleManager manages schedule of group of larger operations that should be run in sequence
|
||||
//
|
||||
// Schedules are derived from IBackgroundSchedule and consist of a list of IBackgroundScheduleItems.
|
||||
// Each schedule item is executed IN ORDER for the previous item to complete first.
|
||||
// Each IBackgroundScheduleItems consists of list of user defined work via IBackgroundScheduleItemsWork classes.
|
||||
// Each schedule item work is executed IN PARALEL (they are all started when the item starts).
|
||||
//
|
||||
// Whenever a work item fails to complete the other work items are stopped, the schedule item is marked as "failed"
|
||||
// and so is the whole schedule.
|
||||
//
|
||||
// All logic is performed on the main thread although schedule items are free to use threads.
|
||||
// It is recommended to use IBackgroundTaskManager for dispatching a task list for every schedule work item.
|
||||
//
|
||||
// All objects in the schedule system are reference counted.
|
||||
//
|
||||
|
||||
// State of the whole schedule
|
||||
|
||||
#ifndef CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDSCHEDULEMANAGER_H
|
||||
#define CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDSCHEDULEMANAGER_H
|
||||
#pragma once
|
||||
enum EScheduleState
|
||||
{
|
||||
// Item has not started yet but is on the list
|
||||
eScheduleState_Pending,
|
||||
|
||||
// We are processing this item
|
||||
eScheduleState_Processing,
|
||||
|
||||
// We are stopping the schedule
|
||||
eSccheduleState_Stopping,
|
||||
|
||||
// Schedule item has failed
|
||||
eScheduleState_Failed,
|
||||
|
||||
// Schedule item was canceled
|
||||
eScheduleState_Canceled,
|
||||
|
||||
// Schedule item has completed it's work
|
||||
eScheduleState_Completed,
|
||||
};
|
||||
|
||||
// State of the single schedule item
|
||||
enum EScheduleItemState
|
||||
{
|
||||
// Item has not started yet but is on the list
|
||||
eScheduleItemState_Pending,
|
||||
|
||||
// We are processing this item
|
||||
eScheduleItemState_Processing,
|
||||
|
||||
// We are stopping this item
|
||||
eScheduleItemState_Stopping,
|
||||
|
||||
// Schedule item has failed
|
||||
eScheduleItemState_Failed,
|
||||
|
||||
// Schedule item has completed it's work
|
||||
eScheduleItemState_Completed,
|
||||
};
|
||||
|
||||
// Work item status
|
||||
enum EScheduleWorkItemStatus
|
||||
{
|
||||
// Work is still not finished
|
||||
eScheduleWorkItemStatus_NotFinished,
|
||||
|
||||
// Work has failed
|
||||
eScheduleWorkItemStatus_Failed,
|
||||
|
||||
// Work has finished
|
||||
eScheduleWorkItemStatus_Finished,
|
||||
};
|
||||
|
||||
struct IBackgroundScheduleItemWork
|
||||
{
|
||||
// Get human readable description
|
||||
virtual const char* GetDescription() const = 0;
|
||||
|
||||
// Get work item progress
|
||||
virtual float GetProgress() const = 0;
|
||||
|
||||
// Called when the schedule item containing this work piece has started
|
||||
// If the work cannot be started for any reason return false.
|
||||
virtual bool OnStart() = 0;
|
||||
|
||||
// Called when the schedule item containing this work piece has been canceled or failed externally
|
||||
// Not called when schedule item completed without errors.
|
||||
// If the work cannot be stopped this frame return false.
|
||||
virtual bool OnStop() = 0;
|
||||
|
||||
// Called every frame to advance and check the work state
|
||||
// Should return one of the EBackgroundScheduleWorkItemStatus value
|
||||
virtual EScheduleWorkItemStatus OnUpdate() = 0;
|
||||
|
||||
// Reference counting
|
||||
virtual void AddRef() = 0;
|
||||
virtual void Release() = 0;
|
||||
|
||||
protected:
|
||||
virtual ~IBackgroundScheduleItemWork() {};
|
||||
};
|
||||
|
||||
struct IBackgroundScheduleItem
|
||||
{
|
||||
// Get name of the schedule (debug & display)
|
||||
virtual const char* GetDescription() const = 0;
|
||||
|
||||
// Get interal state
|
||||
virtual EScheduleItemState GetState() const = 0;
|
||||
|
||||
// Get overall progress of this schedule item
|
||||
virtual const float GetProgress() const = 0;
|
||||
|
||||
// Get number of work items in this schedule item
|
||||
virtual const uint32 GetNumWorkItems() const = 0;
|
||||
|
||||
// Get n-th work item from the schedule item
|
||||
virtual IBackgroundScheduleItemWork* GetWorkItem(const uint32 index) const = 0;
|
||||
|
||||
// Add work item to the schedule item
|
||||
virtual void AddWorkItem(IBackgroundScheduleItemWork* pWork) = 0;
|
||||
|
||||
// Reference counting
|
||||
virtual void AddRef() = 0;
|
||||
virtual void Release() = 0;
|
||||
|
||||
protected:
|
||||
virtual ~IBackgroundScheduleItem() {};
|
||||
};
|
||||
|
||||
struct IBackgroundSchedule
|
||||
{
|
||||
// Get name of the schedule (debug & display)
|
||||
virtual const char* GetDescription() const = 0;
|
||||
|
||||
// Get overall progress of the whole schedule
|
||||
virtual float GetProgress() const = 0;
|
||||
|
||||
// Get item being currently processed
|
||||
virtual IBackgroundScheduleItem* GetProcessedItem() const = 0;
|
||||
|
||||
// Get number of items in the schedule
|
||||
virtual const uint32 GetNumItems() const = 0;
|
||||
|
||||
// Get single schedule item
|
||||
virtual IBackgroundScheduleItem* GetItem(const uint32 index) const = 0;
|
||||
|
||||
// Get schedule item
|
||||
virtual EScheduleState GetState() const = 0;
|
||||
|
||||
// Cancel the whole schedule
|
||||
virtual void Cancel() = 0;
|
||||
|
||||
// Is the schedule canceled ?
|
||||
virtual bool IsCanceled() const = 0;
|
||||
|
||||
// Add schedule item at the end of the list
|
||||
virtual void AddItem(IBackgroundScheduleItem* pItem) = 0;
|
||||
|
||||
// Reference counting
|
||||
virtual void AddRef() = 0;
|
||||
virtual void Release() = 0;
|
||||
|
||||
protected:
|
||||
virtual ~IBackgroundSchedule() {};
|
||||
};
|
||||
|
||||
struct IBackgroundScheduleManager
|
||||
{
|
||||
virtual ~IBackgroundScheduleManager() {};
|
||||
|
||||
// Create empty schedule
|
||||
virtual IBackgroundSchedule* CreateSchedule(const char* szName) = 0;
|
||||
|
||||
// Create empty schedule item
|
||||
virtual IBackgroundScheduleItem* CreateScheduleItem(const char* szName) = 0;
|
||||
|
||||
// Issue a schedule to the list (will start processing it)
|
||||
virtual void SubmitSchedule(IBackgroundSchedule* pSchedule) = 0;
|
||||
|
||||
// Get number of schedules on the list
|
||||
virtual const uint32 GetNumSchedules() const = 0;
|
||||
|
||||
// Get n-th schedule
|
||||
virtual IBackgroundSchedule* GetSchedule(const uint32 index) const = 0;
|
||||
|
||||
// Advance work on the schedules
|
||||
virtual void Update() = 0;
|
||||
};
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDSCHEDULEMANAGER_H
|
||||
@@ -1,230 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
//
|
||||
// IBackgroundTaskManager runs background tasks in worker thread.
|
||||
//
|
||||
// Tasks are derived from IBackgroundTask. Each task is split in two parts for:
|
||||
// Work - done in background thread.
|
||||
// Finalize - called afterward in main thread to apply results.
|
||||
//
|
||||
// Task objects are reference counted. Task manager will hold its own reference to the task object
|
||||
// for as long as the task is pending or being executed. If you want to keep the task object around
|
||||
// in your code you will have to call AddRef() and Release() on the task object by yourself so there
|
||||
// will be an extra reference to the task object held by your code.
|
||||
//
|
||||
// Work returns the state of the task. Task can be resumed, then the Work
|
||||
// method will be called again. Other tasks can work between calls to Work.
|
||||
// It is possible to Cancel task. Work method is not invoked any more for
|
||||
// Canceled tasks.
|
||||
//
|
||||
|
||||
#ifndef CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDTASKMANAGER_H
|
||||
#define CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDTASKMANAGER_H
|
||||
#pragma once
|
||||
|
||||
enum ETaskPriority
|
||||
{
|
||||
eTaskPriority_FileUpdateFinal,
|
||||
eTaskPriority_BackgroundScan,
|
||||
eTaskPriority_FileUpdate,
|
||||
eTaskPriority_RealtimePreview
|
||||
};
|
||||
|
||||
// Result code returned by task Work() function
|
||||
enum ETaskResult
|
||||
{
|
||||
// Task has not yet completed, add it back to the task queue with the same parameters (priority and thread mask)
|
||||
eTaskResult_Resume,
|
||||
|
||||
// Task has completed without errors (it's assumed that the result the task was supposed to achieve was achieved)
|
||||
eTaskResult_Completed,
|
||||
|
||||
// Task was canceled
|
||||
eTaskResult_Canceled,
|
||||
|
||||
// Task has failed to complete it's work
|
||||
eTaskResult_Failed,
|
||||
};
|
||||
|
||||
// Internal task tracking state
|
||||
enum ETaskState
|
||||
{
|
||||
// Task was just created.
|
||||
eTaskState_Created,
|
||||
|
||||
// Task was scheduled to be executed in the future.
|
||||
eTaskState_Scheduled,
|
||||
|
||||
// Task was added to the task queue and is waiting for it's time to be executed.
|
||||
eTaskState_Pending,
|
||||
|
||||
// Task is being processed right now.
|
||||
eTaskState_Working,
|
||||
|
||||
// Task was canceled before it has finished (indication that TaskManager has seen the Cancel() call).
|
||||
eTaskState_Canceled,
|
||||
|
||||
// Task Work() function was called but it ended with an error code.
|
||||
eTaskState_Failed,
|
||||
|
||||
// Task has completed it's Work() function without errors.
|
||||
eTaskState_Completed,
|
||||
};
|
||||
|
||||
// Thread mask controls which on which threads given task can be executed.
|
||||
enum ETaskThreadMask
|
||||
{
|
||||
// Task can run only on the IO thread (default)
|
||||
// There is only one IO thread so all task with this flag are run in a sequence.
|
||||
eTaskThreadMask_IO,
|
||||
|
||||
// Task can run on any thread (concurrent tasks allowed)
|
||||
// There can be many threads with this mask so there's no limit on the concurrent task count.
|
||||
eTaskThreadMask_Any,
|
||||
|
||||
eTaskThreadMask_COUNT,
|
||||
};
|
||||
|
||||
struct IBackgroundTask
|
||||
{
|
||||
public:
|
||||
IBackgroundTask()
|
||||
: m_bCanceled(false)
|
||||
, m_state(eTaskState_Created)
|
||||
, m_progress(-1.0f)
|
||||
, m_refCount(0)
|
||||
, m_bFailReported(false)
|
||||
{}
|
||||
|
||||
void Cancel()
|
||||
{
|
||||
m_bCanceled = true;
|
||||
}
|
||||
|
||||
bool IsCanceled() const
|
||||
{
|
||||
return m_bCanceled;
|
||||
}
|
||||
|
||||
bool HasFinished() const
|
||||
{
|
||||
return (m_state == eTaskState_Canceled) ||
|
||||
(m_state == eTaskState_Completed) ||
|
||||
(m_state == eTaskState_Failed);
|
||||
}
|
||||
|
||||
bool HasFinishedWithoutError() const
|
||||
{
|
||||
return (m_state == eTaskState_Completed);
|
||||
}
|
||||
|
||||
ETaskState GetState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
void SetState(ETaskState state)
|
||||
{
|
||||
m_state = state;
|
||||
}
|
||||
|
||||
float GetProgress() const
|
||||
{
|
||||
return m_progress;
|
||||
}
|
||||
|
||||
int AddRef()
|
||||
{
|
||||
return CryInterlockedIncrement(&m_refCount);
|
||||
}
|
||||
|
||||
int Release()
|
||||
{
|
||||
const int nCount = CryInterlockedDecrement(&m_refCount);
|
||||
assert(nCount >= 0);
|
||||
if (nCount == 0)
|
||||
{
|
||||
Delete();
|
||||
}
|
||||
else if (nCount < 0)
|
||||
{
|
||||
assert(0);
|
||||
CryFatalError("Deleting Reference Counted Object Twice");
|
||||
}
|
||||
return nCount;
|
||||
}
|
||||
|
||||
bool FailReported() const{ return m_bFailReported; }
|
||||
|
||||
// Get the user readable description (name) of this task, used for logging
|
||||
virtual const char* Description() const { return ""; }
|
||||
|
||||
// Get the user readable error message (in case when the task fails), used for logging the errors
|
||||
virtual const char* ErrorMessage() const { return ""; }
|
||||
|
||||
// Called from main thread after task is completed just before the task gets destroyed
|
||||
virtual void Finalize() {}
|
||||
|
||||
// Since there's a possibility that task object were created using different allocator
|
||||
// we need a way to delete the task object once we are done with it
|
||||
virtual void Delete() = 0;
|
||||
|
||||
// Invoked from worker thread, actual work is done here
|
||||
virtual ETaskResult Work() = 0;
|
||||
|
||||
protected:
|
||||
void SetProgress(float progress) { m_progress = progress; }
|
||||
void SetFailReported() { m_bFailReported = true; }
|
||||
|
||||
// destructor is hidden to indicate that we should use Release() method
|
||||
virtual ~IBackgroundTask() {}
|
||||
|
||||
private:
|
||||
volatile int m_refCount;
|
||||
ETaskState m_state;
|
||||
float m_progress;
|
||||
bool m_bCanceled;
|
||||
bool m_bFailReported;
|
||||
};
|
||||
|
||||
struct IBackgroundTaskManagerListener
|
||||
{
|
||||
virtual ~IBackgroundTaskManagerListener() {}
|
||||
|
||||
virtual void OnBackgroundTaskAdded(const char* description) = 0;
|
||||
virtual void OnBackgroundTaskCompleted(ETaskResult taskResult, const char* description) = 0;
|
||||
};
|
||||
|
||||
struct IBackgroundTaskManager
|
||||
{
|
||||
enum
|
||||
{
|
||||
BACKGROUND_TASK_ID_INVALID = 0
|
||||
};
|
||||
|
||||
virtual ~IBackgroundTaskManager() {}
|
||||
|
||||
// Add task to the queue with given priority and thread mask
|
||||
virtual void AddTask(IBackgroundTask* pTask, ETaskPriority priority, ETaskThreadMask threadMask) = 0;
|
||||
|
||||
// Schedule task to be executed in the future
|
||||
virtual void ScheduleTask(IBackgroundTask* pTask, ETaskPriority priority, int delayMilliseconds, ETaskThreadMask threadMask) = 0;
|
||||
|
||||
virtual void AddListener(IBackgroundTaskManagerListener* pListener, const char* name) = 0;
|
||||
|
||||
virtual void RemoveListener(IBackgroundTaskManagerListener* pListener) = 0;
|
||||
};
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_EDITOR_INCLUDE_IBACKGROUNDTASKMANAGER_H
|
||||
@@ -97,10 +97,6 @@ void CLevelInfo::ValidateObjects()
|
||||
|
||||
pObject->Validate(m_pReport);
|
||||
|
||||
CUsedResources rs;
|
||||
pObject->GatherUsedResources(rs);
|
||||
rs.Validate(m_pReport);
|
||||
|
||||
m_pReport->SetCurrentValidatorObject(NULL);
|
||||
}
|
||||
|
||||
|
||||
@@ -102,7 +102,6 @@ public:
|
||||
MOCK_METHOD0(GetViewManager, class CViewManager* ());
|
||||
MOCK_METHOD0(GetActiveView, class CViewport* ());
|
||||
MOCK_METHOD1(SetActiveView, void(CViewport*));
|
||||
MOCK_METHOD0(GetBackgroundTaskManager, struct IBackgroundTaskManager* ());
|
||||
MOCK_METHOD0(GetFileMonitor, struct IEditorFileMonitor* ());
|
||||
MOCK_METHOD1(RegisterEventLoopHook, void(IEventLoopHook* ));
|
||||
MOCK_METHOD1(UnregisterEventLoopHook, void(IEventLoopHook* ));
|
||||
@@ -184,7 +183,6 @@ public:
|
||||
MOCK_CONST_METHOD0(GetEditorConfigPlatform, ESystemConfigPlatform());
|
||||
MOCK_METHOD0(ReloadTemplates, void());
|
||||
MOCK_METHOD0(GetResourceSelectorHost, IResourceSelectorHost* ());
|
||||
MOCK_METHOD0(GetBackgroundScheduleManager, struct IBackgroundScheduleManager* ());
|
||||
MOCK_METHOD1(ShowStatusText, void(bool ));
|
||||
MOCK_METHOD1(RegisterObjectContextMenuExtension, void(TContextMenuExtensionFunc ));
|
||||
MOCK_METHOD0(GetEnv, SSystemGlobalEnvironment* ());
|
||||
|
||||
@@ -13,7 +13,6 @@
|
||||
#pragma once
|
||||
|
||||
#include <MainStatusBar.h>
|
||||
#include <IBackgroundTaskManager.h>
|
||||
#include <IRenderer.h>
|
||||
#include <QMutex>
|
||||
#include <QString>
|
||||
|
||||
@@ -92,7 +92,6 @@ AZ_POP_DISABLE_WARNING
|
||||
#include "ErrorReportDialog.h"
|
||||
|
||||
#include "Dialogs/PythonScriptsDialog.h"
|
||||
#include "EngineSettingsManager.h"
|
||||
|
||||
#include "AzAssetBrowser/AzAssetBrowserWindow.h"
|
||||
#include "AssetEditor/AssetEditorWindow.h"
|
||||
@@ -1941,12 +1940,6 @@ void MainWindow::ConnectivityStateChanged(const AzToolsFramework::SourceControlS
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(CRY_ENABLE_RC_HELPER)
|
||||
CEngineSettingsManager settingsManager;
|
||||
settingsManager.SetModuleSpecificBoolEntry("RC_EnableSourceControl", connected);
|
||||
settingsManager.StoreData();
|
||||
#endif
|
||||
|
||||
gSettings.enableSourceControl = connected;
|
||||
gSettings.SaveEnableSourceControlFlag(false);
|
||||
}
|
||||
|
||||
@@ -35,7 +35,6 @@
|
||||
|
||||
class CEntityObject;
|
||||
class QMenu;
|
||||
class IOpticsElementBase;
|
||||
|
||||
/*!
|
||||
* CEntityEventTarget is an Entity event target and type.
|
||||
|
||||
@@ -27,38 +27,3 @@ void CUsedResources::Add(const char* pResourceFileName)
|
||||
files.insert(pResourceFileName);
|
||||
}
|
||||
}
|
||||
|
||||
void CUsedResources::Validate(IErrorReport* pReport)
|
||||
{
|
||||
auto pPak = gEnv->pCryPak;
|
||||
|
||||
for (TResourceFiles::iterator it = files.begin(); it != files.end(); ++it)
|
||||
{
|
||||
const QString& filename = *it;
|
||||
|
||||
bool fileExists = pPak->IsFileExist(filename.toUtf8().data());
|
||||
|
||||
if (!fileExists)
|
||||
{
|
||||
for (int i = 0; !fileExists && i < IResourceCompilerHelper::GetNumEngineImageFormats(); ++i)
|
||||
{
|
||||
fileExists = gEnv->pCryPak->IsFileExist(PathUtil::ReplaceExtension(filename.toUtf8().data(), IResourceCompilerHelper::GetEngineImageFormat(i, true)).c_str());
|
||||
}
|
||||
for (int i = 0; !fileExists && i < IResourceCompilerHelper::GetNumSourceImageFormats(); ++i)
|
||||
{
|
||||
fileExists = gEnv->pCryPak->IsFileExist(PathUtil::ReplaceExtension(filename.toUtf8().data(), IResourceCompilerHelper::GetSourceImageFormat(i, true)).c_str());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (!fileExists)
|
||||
{
|
||||
CErrorRecord err;
|
||||
|
||||
err.error = QObject::tr("Resource File %1 not found,").arg(filename);
|
||||
err.severity = CErrorRecord::ESEVERITY_ERROR;
|
||||
err.flags |= CErrorRecord::FLAG_NOFILE;
|
||||
pReport->ReportError(err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -36,8 +36,6 @@ public:
|
||||
|
||||
CUsedResources();
|
||||
void Add(const char* pResourceFileName);
|
||||
//! validate gathered resources, reports warning if resource is not found
|
||||
void Validate(struct IErrorReport* pReport);
|
||||
|
||||
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
|
||||
TResourceFiles files;
|
||||
|
||||
@@ -280,8 +280,6 @@ set(FILES
|
||||
Include/IAnimationCompressionManager.h
|
||||
Include/IAssetItem.h
|
||||
Include/IAssetItemDatabase.h
|
||||
Include/IBackgroundScheduleManager.h
|
||||
Include/IBackgroundTaskManager.h
|
||||
Include/ICommandManager.h
|
||||
Include/IConsoleConnectivity.h
|
||||
Include/IDataBaseItem.h
|
||||
@@ -343,10 +341,6 @@ set(FILES
|
||||
AssetEditor/AssetEditorWindow.cpp
|
||||
AssetEditor/AssetEditorWindow.h
|
||||
AssetEditor/AssetEditorWindow.ui
|
||||
BackgroundTaskManager.cpp
|
||||
BackgroundScheduleManager.cpp
|
||||
BackgroundTaskManager.h
|
||||
BackgroundScheduleManager.h
|
||||
Commands/CommandManager.cpp
|
||||
Commands/CommandManager.h
|
||||
Controls/BitmapToolTip.cpp
|
||||
|
||||
@@ -160,7 +160,6 @@ void SandboxIntegrationManager::Setup()
|
||||
AzToolsFramework::SliceEditorEntityOwnershipServiceNotificationBus::Handler::BusConnect();
|
||||
|
||||
AzFramework::DisplayContextRequestBus::Handler::BusConnect();
|
||||
SetupFileExtensionMap();
|
||||
|
||||
MainWindow::instance()->GetActionManager()->RegisterActionHandler(ID_FILE_SAVE_SLICE_TO_ROOT, [this]() {
|
||||
SaveSlice(false);
|
||||
@@ -1926,30 +1925,6 @@ void SandboxIntegrationManager::MakeSliceFromEntities(const AzToolsFramework::En
|
||||
AzToolsFramework::SliceUtilities::MakeNewSlice(entitiesAndDescendants, path, inheritSlices, setAsDynamic);
|
||||
}
|
||||
|
||||
void SandboxIntegrationManager::SetupFileExtensionMap()
|
||||
{
|
||||
// There's no central registry for geometry file types.
|
||||
const char* geometryFileExtensions[] =
|
||||
{
|
||||
CRY_GEOMETRY_FILE_EXT, // .cgf
|
||||
CRY_SKEL_FILE_EXT, // .chr
|
||||
CRY_CHARACTER_DEFINITION_FILE_EXT, // .cdf
|
||||
};
|
||||
|
||||
// Cry geometry file extensions.
|
||||
for (const char* extension : geometryFileExtensions)
|
||||
{
|
||||
m_extensionToFileType[AZ::Crc32(extension)] = IFileUtil::EFILE_TYPE_GEOMETRY;
|
||||
}
|
||||
|
||||
// Cry image file extensions.
|
||||
for (size_t i = 0; i < IResourceCompilerHelper::GetNumSourceImageFormats(); ++i)
|
||||
{
|
||||
const char* extension = IResourceCompilerHelper::GetSourceImageFormat(i, false);
|
||||
m_extensionToFileType[AZ::Crc32(extension)] = IFileUtil::EFILE_TYPE_TEXTURE;
|
||||
}
|
||||
}
|
||||
|
||||
void SandboxIntegrationManager::RegisterViewPane(const char* name, const char* category, const AzToolsFramework::ViewPaneOptions& viewOptions, const WidgetCreationFunc& widgetCreationFunc)
|
||||
{
|
||||
QtViewPaneManager::instance()->RegisterPane(name, category, widgetCreationFunc, viewOptions);
|
||||
|
||||
@@ -319,12 +319,10 @@ private:
|
||||
void OnLayerComponentDeactivated(AZ::EntityId entityId) override;
|
||||
|
||||
private:
|
||||
void SetupFileExtensionMap();
|
||||
// Right click context menu when a layer is included in the selection.
|
||||
void SetupLayerContextMenu(QMenu* menu);
|
||||
void SetupSliceContextMenu(QMenu* menu);
|
||||
void SetupSliceContextMenu_Modify(QMenu* menu, const AzToolsFramework::EntityIdList& selectedEntities, const AZ::u32 numEntitiesInSlices);
|
||||
void SetupScriptCanvasContextMenu(QMenu* menu);
|
||||
void SaveSlice(const bool& QuickPushToFirstLevel);
|
||||
void GetEntitiesInSlices(const AzToolsFramework::EntityIdList& selectedEntities, AZ::u32& entitiesInSlices, AZStd::vector<AZ::SliceComponent::SliceInstanceAddress>& sliceInstances);
|
||||
|
||||
@@ -348,9 +346,6 @@ private:
|
||||
};
|
||||
|
||||
private:
|
||||
typedef AZStd::unordered_map<AZ::u32, IFileUtil::ECustomFileType> ExtensionMap;
|
||||
ExtensionMap m_extensionToFileType;
|
||||
|
||||
AZ::Vector2 m_contextMenuViewPoint;
|
||||
AZ::Vector3 m_sliceWorldPos;
|
||||
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AzCore/Interface/Interface.h>
|
||||
|
||||
#include <QVariantMap>
|
||||
|
||||
using PythonWorkerRequestId = int;
|
||||
|
||||
//! Interface to signal the python worker output
|
||||
class PythonWorkerEventsInterface
|
||||
{
|
||||
protected:
|
||||
PythonWorkerEventsInterface() = default;
|
||||
virtual ~PythonWorkerEventsInterface() = default;
|
||||
PythonWorkerEventsInterface(PythonWorkerEventsInterface&&) = delete;
|
||||
PythonWorkerEventsInterface& operator=(PythonWorkerEventsInterface&&) = delete;
|
||||
|
||||
public:
|
||||
AZ_RTTI(PythonWorkerEventsInterface, "{60C83A5A-B8DD-4B98-B8C6-DC2F5914D7C4}");
|
||||
|
||||
// if any OnOutput returns true, it means the command was handled and the worker won't process any further
|
||||
virtual bool OnPythonWorkerOutput(PythonWorkerRequestId requestId, const QString& key, const QVariant& value) = 0;
|
||||
};
|
||||
|
||||
//! Interface to send the python worker requests
|
||||
class PythonWorkerRequestsInterface
|
||||
{
|
||||
protected:
|
||||
PythonWorkerRequestsInterface() = default;
|
||||
virtual ~PythonWorkerRequestsInterface() = default;
|
||||
PythonWorkerRequestsInterface(PythonWorkerRequestsInterface&&) = delete;
|
||||
PythonWorkerRequestsInterface& operator=(PythonWorkerRequestsInterface&&) = delete;
|
||||
|
||||
public:
|
||||
AZ_RTTI(PythonWorkerRequestsInterface, "{B0293028-3575-408E-8CE3-D1B7F3C59A6C}");
|
||||
|
||||
virtual PythonWorkerRequestId AllocateRequestId() = 0;
|
||||
virtual void ExecuteAsync(PythonWorkerRequestId requestId, const char* command, const QVariantMap& args = QVariantMap{}) = 0;
|
||||
virtual bool IsStarted() = 0;
|
||||
};
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
#include "stdafx.h"
|
||||
#include <MaglevControlPanelPlugin.h>
|
||||
#include <IEditor.h>
|
||||
|
||||
const char* TAG = "MaglevControlPanelPlugin";
|
||||
|
||||
MaglevControlPanelPlugin::MaglevControlPanelPlugin(IEditor* editor)
|
||||
: m_pluginSettings(QSettings::IniFormat, QSettings::UserScope, "Amazon", "Lumberyard")
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void MaglevControlPanelPlugin::Release()
|
||||
{
|
||||
}
|
||||
|
||||
void MaglevControlPanelPlugin::OnEditorNotify(EEditorNotifyEvent aEventId)
|
||||
{
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user