1515 lines
44 KiB
C++
1515 lines
44 KiB
C++
|
||
|
||
#include "trenderer.h"
|
||
#include "trendererP.h"
|
||
|
||
// TnzCore includes
|
||
#include "tsystem.h"
|
||
#include "tthreadmessage.h"
|
||
#include "tthread.h"
|
||
#include "tconvert.h"
|
||
#include "tstream.h"
|
||
#include "trasterimage.h"
|
||
#include "trop.h"
|
||
#include "timagecache.h"
|
||
#include "tstopwatch.h"
|
||
|
||
// TnzBase includes
|
||
#include "trenderresourcemanager.h"
|
||
#include "tpredictivecachemanager.h"
|
||
|
||
// Qt includes
|
||
#include <QEventLoop>
|
||
#include <QCoreApplication>
|
||
#include <QReadWriteLock>
|
||
#include <QReadLocker>
|
||
#include <QWriteLocker>
|
||
#include <QThreadStorage>
|
||
|
||
// tcg includes
|
||
#include "tcg/tcg_deleter_types.h"
|
||
|
||
// Debug
|
||
//#define DIAGNOSTICS
|
||
//#include "diagnostics.h"
|
||
|
||
#include <queue>
|
||
#include <functional>
|
||
|
||
using namespace TThread;
|
||
|
||
std::vector<const TFx *> calculateSortedFxs(TRasterFxP rootFx);
|
||
|
||
//================================================================================
|
||
// Preliminaries - Anonymous namespace
|
||
//================================================================================
|
||
|
||
namespace {
|
||
// TRenderer-thread association storage. It provides TRenderers the per-thread
|
||
// singleton status from inside a rendering process.
|
||
QThreadStorage<TRendererImp **> rendererStorage;
|
||
|
||
// Same for render process ids.
|
||
QThreadStorage<unsigned long *> renderIdsStorage;
|
||
|
||
//-------------------------------------------------------------------------------
|
||
|
||
// Interlacing functions for field-based rendering
|
||
inline void interlace(TRasterP f0, const TRasterP &f1, int field) {
|
||
if (f0->getPixelSize() != f1->getPixelSize())
|
||
throw TException("interlace: invalid raster combination");
|
||
|
||
assert(f0->getBounds() == f1->getBounds());
|
||
|
||
int outWrapBytes = f0->getWrap() * f0->getPixelSize();
|
||
int inWrapBytes = f1->getWrap() * f1->getPixelSize();
|
||
int outWrapBytes2 = outWrapBytes * 2;
|
||
int inWrapBytes2 = inWrapBytes * 2;
|
||
int rowSize = f0->getLx() * f0->getPixelSize();
|
||
|
||
f1->lock();
|
||
f0->lock();
|
||
UCHAR *rowIn = f1->getRawData();
|
||
UCHAR *rowOut = f0->getRawData();
|
||
|
||
if (field) rowIn += inWrapBytes;
|
||
|
||
int count = f0->getLy() / 2;
|
||
while (--count) {
|
||
memcpy(rowOut, rowIn, rowSize);
|
||
rowIn += inWrapBytes2;
|
||
rowOut += outWrapBytes2;
|
||
}
|
||
|
||
f1->unlock();
|
||
f0->unlock();
|
||
}
|
||
} // anonymous namespace
|
||
|
||
//================================================================================
|
||
// Preliminaries - output rasters management
|
||
//================================================================================
|
||
|
||
//===================
|
||
// RasterItem
|
||
//-------------------
|
||
|
||
//! The RasterItem class represents a reusable output raster for rendering
|
||
//! purposes.
|
||
//! RasterItems are used as TRenderer's output rasters in order to avoid the
|
||
//! overhead
|
||
//! of allocating one raster for each rendered frame.
|
||
//! Each frame-rendering task will lock a RasterItem as preallocated output
|
||
//! before starting the
|
||
//! render, therefore changing the \b RasterItem::m_busy attribute accordingly.
|
||
//! As each frame is rendered on a separate thread, the number of RasterItems
|
||
//! that
|
||
//! TRenderer will allocate depends on the number of rendering threads specified
|
||
//! to it.
|
||
|
||
//! \sa RasterPool, TRenderer classes
|
||
|
||
class RasterItem {
|
||
std::string m_rasterId;
|
||
|
||
public:
|
||
int m_bpp;
|
||
bool m_busy;
|
||
|
||
//---------------------------------------------------------
|
||
|
||
RasterItem(const TDimension &size, int bpp, bool busyFlag)
|
||
: m_rasterId(""), m_bpp(bpp), m_busy(busyFlag) {
|
||
TRasterP raster;
|
||
if (bpp == 32)
|
||
raster = TRaster32P(size);
|
||
else if (bpp == 64)
|
||
raster = TRaster64P(size);
|
||
else
|
||
assert(false);
|
||
|
||
m_rasterId = TImageCache::instance()->getUniqueId();
|
||
TImageCache::instance()->add(m_rasterId, TRasterImageP(raster));
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
~RasterItem() { TImageCache::instance()->remove(m_rasterId); }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRasterP getRaster() const {
|
||
TRasterImageP rimg =
|
||
(TRasterImageP)TImageCache::instance()->get(m_rasterId, true);
|
||
return rimg ? rimg->getRaster() : TRasterP();
|
||
}
|
||
|
||
private:
|
||
// not implemented
|
||
RasterItem();
|
||
RasterItem(const TRaster &RasterItem);
|
||
};
|
||
|
||
//================================================================================
|
||
|
||
//===================
|
||
// RasterPool
|
||
//-------------------
|
||
|
||
//! Stores a list of RasterItems under TRenderer's requests.
|
||
class RasterPool {
|
||
TDimension m_size;
|
||
int m_bpp;
|
||
|
||
typedef std::list<RasterItem *> RasterRepository;
|
||
RasterRepository m_rasterRepository;
|
||
|
||
TThread::Mutex m_repositoryLock;
|
||
|
||
public:
|
||
RasterPool() : m_size(-1, -1) {}
|
||
~RasterPool();
|
||
|
||
void setRasterSpecs(const TDimension &size, int bpp);
|
||
void getRasterSpecs(TDimension &size, int &bpp) {
|
||
size = m_size;
|
||
bpp = m_bpp;
|
||
}
|
||
|
||
TRasterP getRaster();
|
||
TRasterP getRaster(const TDimension &size, int bpp);
|
||
|
||
void releaseRaster(const TRasterP &r);
|
||
|
||
void clear();
|
||
};
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RasterPool::clear() {
|
||
QMutexLocker sl(&m_repositoryLock);
|
||
clearPointerContainer(m_rasterRepository);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RasterPool::setRasterSpecs(const TDimension &size, int bpp) {
|
||
if (size != m_size || bpp != m_bpp) {
|
||
m_size = size;
|
||
m_bpp = bpp;
|
||
clear();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRasterP RasterPool::getRaster(const TDimension &size, int bpp) {
|
||
assert(size == m_size && bpp == m_bpp);
|
||
return getRaster();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Returns for the first not-busy raster
|
||
TRasterP RasterPool::getRaster() {
|
||
QMutexLocker sl(&m_repositoryLock);
|
||
|
||
RasterRepository::iterator it = m_rasterRepository.begin();
|
||
while (it != m_rasterRepository.end()) {
|
||
RasterItem *rasItem = *it;
|
||
if (rasItem->m_busy == false) {
|
||
TRasterP raster = rasItem->getRaster();
|
||
|
||
if (!raster) {
|
||
delete rasItem;
|
||
m_rasterRepository.erase(it++);
|
||
continue;
|
||
}
|
||
|
||
rasItem->m_busy = true;
|
||
raster->clear();
|
||
return raster;
|
||
}
|
||
|
||
++it;
|
||
}
|
||
|
||
RasterItem *rasItem = new RasterItem(m_size, m_bpp, true);
|
||
m_rasterRepository.push_back(rasItem);
|
||
|
||
return rasItem->getRaster();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Cerca il raster \b r in m_rasterRepository; se lo trova setta a \b false il
|
||
//! campo \b m_busy.
|
||
void RasterPool::releaseRaster(const TRasterP &r) {
|
||
if (!r) return;
|
||
|
||
QMutexLocker sl(&m_repositoryLock);
|
||
for (RasterRepository::iterator it = m_rasterRepository.begin();
|
||
it != m_rasterRepository.end(); ++it) {
|
||
RasterItem *rasItem = *it;
|
||
if (rasItem->getRaster()->getRawData() == r->getRawData()) {
|
||
assert(rasItem->m_busy);
|
||
rasItem->m_busy = false;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
RasterPool::~RasterPool() {
|
||
/*if (m_rasterRepository.size())
|
||
TSystem::outputDebug("~RasterPool: itemCount = " + toString
|
||
((int)m_rasterRepository.size())+" (should be 0)\n");*/
|
||
|
||
// Release all raster items
|
||
clear();
|
||
}
|
||
|
||
//================================================================================
|
||
// Internal rendering classes declaration
|
||
//================================================================================
|
||
|
||
//=====================
|
||
// TRendererImp
|
||
//---------------------
|
||
|
||
class TRendererImp final : public TSmartObject {
|
||
public:
|
||
struct RenderInstanceInfos {
|
||
int m_canceled;
|
||
int m_activeTasks;
|
||
int m_status;
|
||
|
||
RenderInstanceInfos()
|
||
: m_canceled(false), m_activeTasks(0), m_status(TRenderer::IDLE) {}
|
||
};
|
||
|
||
public:
|
||
typedef std::vector<TRenderPort *> PortContainer;
|
||
typedef PortContainer::iterator PortContainerIterator;
|
||
|
||
QReadWriteLock m_portsLock;
|
||
PortContainer m_ports;
|
||
|
||
QMutex m_renderInstancesMutex;
|
||
std::map<unsigned long, RenderInstanceInfos> m_activeInstances;
|
||
|
||
//! The renderer Id is a number uniquely associated with a TRenderer instance.
|
||
static unsigned long m_rendererIdCounter;
|
||
|
||
//! The render Id is a number uniquely associated with a render process
|
||
//! started
|
||
//! with the startRendering() method.
|
||
static unsigned long m_renderIdCounter;
|
||
|
||
unsigned long m_rendererId;
|
||
|
||
Executor m_executor;
|
||
|
||
bool m_precomputingEnabled;
|
||
RasterPool m_rasterPool;
|
||
|
||
std::vector<TRenderResourceManager *> m_managers;
|
||
|
||
TAtomicVar m_undoneTasks;
|
||
// std::vector<QEventLoop*> m_waitingLoops;
|
||
std::vector<bool *> m_waitingLoops;
|
||
|
||
TRasterFxP rootFx;
|
||
|
||
//-------------------------------------------------------------
|
||
|
||
TRendererImp(int nThreads);
|
||
~TRendererImp();
|
||
|
||
void startRendering(unsigned long renderId,
|
||
const std::vector<TRenderer::RenderData> &renderDatas);
|
||
|
||
void notifyRasterStarted(const TRenderPort::RenderData &rd);
|
||
void notifyRasterCompleted(const TRenderPort::RenderData &rd);
|
||
void notifyRasterFailure(const TRenderPort::RenderData &rd, TException &e);
|
||
void notifyRenderFinished(bool isCanceled = false);
|
||
|
||
void addPort(TRenderPort *port);
|
||
void removePort(TRenderPort *port);
|
||
|
||
void abortRendering(unsigned long renderId);
|
||
void stopRendering(bool waitForCompleteStop);
|
||
|
||
bool hasToDie(unsigned long renderId);
|
||
int getRenderStatus(unsigned long renderId);
|
||
|
||
void enablePrecomputing(bool on) { m_precomputingEnabled = on; }
|
||
bool isPrecomputingEnabled() const { return m_precomputingEnabled; }
|
||
|
||
void setThreadsCount(int nThreads) { m_executor.setMaxActiveTasks(nThreads); }
|
||
|
||
inline void declareRenderStart(unsigned long renderId);
|
||
inline void declareRenderEnd(unsigned long renderId);
|
||
inline void declareFrameStart(double frame);
|
||
inline void declareFrameEnd(double frame);
|
||
inline void declareStatusStart(int renderStatus);
|
||
inline void declareStatusEnd(int renderStatus);
|
||
|
||
void quitWaitingLoops();
|
||
};
|
||
|
||
#ifdef _WIN32
|
||
template class DVAPI TSmartPointerT<TRendererImp>;
|
||
#endif
|
||
|
||
typedef TSmartPointerT<TRendererImp> TRendererImpP;
|
||
|
||
unsigned long TRendererImp::m_rendererIdCounter = 0;
|
||
unsigned long TRendererImp::m_renderIdCounter = 0;
|
||
|
||
//================================================================================
|
||
|
||
//===================
|
||
// RenderTask
|
||
//-------------------
|
||
|
||
class RenderTask final : public TThread::Runnable {
|
||
std::vector<double> m_frames;
|
||
|
||
unsigned long m_taskId;
|
||
unsigned long m_renderId;
|
||
|
||
TRendererImpP m_rendererImp;
|
||
|
||
TFxPair m_fx;
|
||
TPointD m_framePos;
|
||
TDimension m_frameSize;
|
||
TRenderSettings m_info;
|
||
|
||
bool m_fieldRender, m_stereoscopic;
|
||
|
||
Mutex m_rasterGuard;
|
||
TTile m_tileA; // in normal and field rendering, Rendered at given frame; in
|
||
// stereoscopic, rendered left frame
|
||
TTile m_tileB; // in field rendering, rendered at frame + 0.5; in
|
||
// stereoscopic, rendered right frame
|
||
|
||
public:
|
||
RenderTask(unsigned long renderId, unsigned long taskId, double frame,
|
||
const TRenderSettings &ri, const TFxPair &fx,
|
||
const TPointD &framePos, const TDimension &frameSize,
|
||
const TRendererImpP &rendererImp);
|
||
|
||
~RenderTask() {}
|
||
|
||
void addFrame(double frame) { m_frames.push_back(frame); }
|
||
|
||
void buildTile(TTile &tile);
|
||
void releaseTiles();
|
||
|
||
void onFrameStarted();
|
||
void onFrameCompleted();
|
||
void onFrameFailed(TException &e);
|
||
|
||
void preRun();
|
||
void run() override;
|
||
|
||
int taskLoad() override { return 100; }
|
||
|
||
void onFinished(TThread::RunnableP) override;
|
||
};
|
||
|
||
//================================================================================
|
||
// Implementations
|
||
//================================================================================
|
||
|
||
//==================
|
||
// TRenderer
|
||
//------------------
|
||
|
||
TRenderer::TRenderer(int nThread) {
|
||
m_imp = new TRendererImp(nThread); // Already adds a ref
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRenderer::TRenderer(TRendererImp *imp) : m_imp(imp) {
|
||
if (m_imp) m_imp->addRef();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRenderer::TRenderer(const TRenderer &r) : m_imp(r.m_imp) {
|
||
if (m_imp) m_imp->addRef();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::operator=(const TRenderer &r) {
|
||
m_imp = r.m_imp;
|
||
if (m_imp) m_imp->addRef();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRenderer::~TRenderer() {
|
||
if (m_imp) m_imp->release();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! The static method is intended for use inside a rendering thread only. It
|
||
//! returns
|
||
//! a copy of the eventual TRenderer interface installed on the thread -
|
||
//! or an empty TRenderer if none happened to be. It can be set using the
|
||
//! install() and uninstall() methods.
|
||
TRenderer TRenderer::instance() {
|
||
TRendererImp **lData = rendererStorage.localData();
|
||
if (lData) return TRenderer(*lData);
|
||
return 0;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Returns the renderer id.
|
||
unsigned long TRenderer::rendererId() { return m_imp->m_rendererId; }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Returns the rendering process id currently running on the invoking
|
||
//! thread.
|
||
unsigned long TRenderer::renderId() {
|
||
unsigned long *lData = renderIdsStorage.localData();
|
||
return lData ? *lData : -1;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Builds and returns an id for starting a new rendering process.
|
||
unsigned long TRenderer::buildRenderId() {
|
||
return TRendererImp::m_renderIdCounter++;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Returns the renderId that will be used by the next startRendering() call.
|
||
//! This method can be used to retrieve the renderId of a rendering instance
|
||
//! before it is actually started - provided that no other render instance
|
||
//! is launched inbetween.
|
||
unsigned long TRenderer::nextRenderId() {
|
||
return TRendererImp::m_renderIdCounter;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareRenderStart(unsigned long renderId) {
|
||
// Inform the resource managers
|
||
for (unsigned int i = 0; i < m_managers.size(); ++i)
|
||
m_managers[i]->onRenderInstanceStart(renderId);
|
||
}
|
||
|
||
//! Declares that the render process of passed renderId is about to start.
|
||
void TRenderer::declareRenderStart(unsigned long renderId) {
|
||
m_imp->declareRenderStart(renderId);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareRenderEnd(unsigned long renderId) {
|
||
// Inform the resource managers
|
||
for (int i = m_managers.size() - 1; i >= 0; --i)
|
||
m_managers[i]->onRenderInstanceEnd(renderId);
|
||
}
|
||
|
||
//! Declares that the render process of passed renderId has ended.
|
||
void TRenderer::declareRenderEnd(unsigned long renderId) {
|
||
m_imp->declareRenderEnd(renderId);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareFrameStart(double frame) {
|
||
// Inform the resource managers
|
||
for (unsigned int i = 0; i < m_managers.size(); ++i)
|
||
m_managers[i]->onRenderFrameStart(frame);
|
||
}
|
||
|
||
//! Declares that render of passed frame is about to start.
|
||
void TRenderer::declareFrameStart(double frame) {
|
||
m_imp->declareFrameStart(frame);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareFrameEnd(double frame) {
|
||
// Inform the resource managers
|
||
for (int i = m_managers.size() - 1; i >= 0; --i)
|
||
m_managers[i]->onRenderFrameEnd(frame);
|
||
}
|
||
|
||
//! Declares that render of passed has ended.
|
||
void TRenderer::declareFrameEnd(double frame) { m_imp->declareFrameEnd(frame); }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareStatusStart(int renderStatus) {
|
||
// Inform the resource managers
|
||
for (unsigned int i = 0; i < m_managers.size(); ++i)
|
||
m_managers[i]->onRenderStatusStart(renderStatus);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
inline void TRendererImp::declareStatusEnd(int renderStatus) {
|
||
// Inform the resource managers
|
||
for (int i = m_managers.size() - 1; i >= 0; --i)
|
||
m_managers[i]->onRenderStatusEnd(renderStatus);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Installs the specified render process on the invoking thread.
|
||
void TRenderer::install(unsigned long renderId) {
|
||
m_imp->addRef();
|
||
rendererStorage.setLocalData(new (TRendererImp *)(m_imp));
|
||
renderIdsStorage.setLocalData(new unsigned long(renderId));
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Uninstalls any rendering process active on the invoking thread.
|
||
void TRenderer::uninstall() {
|
||
rendererStorage.setLocalData(0);
|
||
renderIdsStorage.setLocalData(0);
|
||
m_imp->release();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRenderResourceManager *TRenderer::getManager(unsigned int id) const {
|
||
return m_imp->m_managers[id];
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::enablePrecomputing(bool on) { m_imp->enablePrecomputing(on); }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
bool TRenderer::isPrecomputingEnabled() const {
|
||
return m_imp->isPrecomputingEnabled();
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::setThreadsCount(int nThreads) {
|
||
m_imp->setThreadsCount(nThreads);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::addPort(TRenderPort *port) { m_imp->addPort(port); }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::removePort(TRenderPort *port) { m_imp->removePort(port); }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
unsigned long TRenderer::startRendering(double f, const TRenderSettings &info,
|
||
const TFxPair &actualRoot) {
|
||
assert(f >= 0);
|
||
|
||
std::vector<RenderData> *rds = new std::vector<RenderData>;
|
||
rds->push_back(RenderData(f, info, actualRoot));
|
||
return startRendering(rds);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Queues a rendering event in the main event loop.
|
||
//! NOTE: The passed pointer is owned by the TRenderer after it is submitted for
|
||
//! rendering -
|
||
//! do not delete it later.
|
||
unsigned long TRenderer::startRendering(
|
||
const std::vector<RenderData> *renderDatas) {
|
||
if (renderDatas->empty()) {
|
||
delete renderDatas;
|
||
return -1;
|
||
}
|
||
|
||
// Build a new render Id
|
||
unsigned long renderId = m_imp->m_renderIdCounter++;
|
||
|
||
TRendererStartInvoker::StartInvokerRenderData srd;
|
||
srd.m_renderId = renderId;
|
||
srd.m_renderDataVector = renderDatas;
|
||
TRendererStartInvoker::instance()->emitStartRender(m_imp, srd);
|
||
|
||
return renderId;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::abortRendering(unsigned long renderId) {
|
||
m_imp->abortRendering(renderId);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRenderer::stopRendering(bool waitForCompleteStop) {
|
||
m_imp->stopRendering(waitForCompleteStop);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
bool TRenderer::isAborted(unsigned long renderId) const {
|
||
return m_imp->hasToDie(renderId);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
int TRenderer::getRenderStatus(unsigned long renderId) const {
|
||
return m_imp->getRenderStatus(renderId);
|
||
}
|
||
|
||
//================================================================================
|
||
|
||
//=====================
|
||
// TRendererImp
|
||
//---------------------
|
||
|
||
TRendererImp::TRendererImp(int nThreads)
|
||
: m_executor()
|
||
, m_undoneTasks()
|
||
, m_rendererId(m_rendererIdCounter++)
|
||
, m_precomputingEnabled(true) {
|
||
m_executor.setMaxActiveTasks(nThreads);
|
||
|
||
std::vector<TRenderResourceManagerGenerator *> &generators =
|
||
TRenderResourceManagerGenerator::generators(false);
|
||
|
||
// May be adopted by other TRenderers from now on.
|
||
addRef();
|
||
|
||
rendererStorage.setLocalData(new (TRendererImp *)(this));
|
||
|
||
unsigned int i;
|
||
for (i = 0; i < generators.size(); ++i) {
|
||
TRenderResourceManager *manager = (*generators[i])();
|
||
if (manager) m_managers.push_back(manager);
|
||
}
|
||
|
||
rendererStorage.setLocalData(0);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRendererImp::~TRendererImp() {
|
||
rendererStorage.setLocalData(new (TRendererImp *)(this));
|
||
|
||
int i;
|
||
for (i = m_managers.size() - 1; i >= 0; --i)
|
||
if (m_managers[i]->renderHasOwnership()) delete m_managers[i];
|
||
|
||
rendererStorage.setLocalData(0);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::addPort(TRenderPort *port) {
|
||
QWriteLocker sl(&m_portsLock);
|
||
|
||
PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);
|
||
if (it == m_ports.end()) m_ports.push_back(port);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::removePort(TRenderPort *port) {
|
||
QWriteLocker sl(&m_portsLock);
|
||
|
||
PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);
|
||
if (it != m_ports.end()) m_ports.erase(it);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
bool TRendererImp::hasToDie(unsigned long renderId) {
|
||
QMutexLocker sl(&m_renderInstancesMutex);
|
||
|
||
std::map<unsigned long, RenderInstanceInfos>::iterator it =
|
||
m_activeInstances.find(renderId);
|
||
assert(it != m_activeInstances.end());
|
||
return it == m_activeInstances.end() ? true : it->second.m_canceled;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
int TRendererImp::getRenderStatus(unsigned long renderId) {
|
||
QMutexLocker sl(&m_renderInstancesMutex);
|
||
|
||
std::map<unsigned long, RenderInstanceInfos>::iterator it =
|
||
m_activeInstances.find(renderId);
|
||
assert(it != m_activeInstances.end());
|
||
return it == m_activeInstances.end() ? true : it->second.m_status;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::abortRendering(unsigned long renderId) {
|
||
QMutexLocker sl(&m_renderInstancesMutex);
|
||
|
||
std::map<unsigned long, RenderInstanceInfos>::iterator it =
|
||
m_activeInstances.find(renderId);
|
||
if (it != m_activeInstances.end()) it->second.m_canceled = true;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::stopRendering(bool waitForCompleteStop) {
|
||
QMutexLocker sl(&m_renderInstancesMutex);
|
||
|
||
{
|
||
// Tasks already stop rendering on their own when they don't find their
|
||
// render ids here.
|
||
std::map<unsigned long, RenderInstanceInfos>::iterator it;
|
||
for (it = m_activeInstances.begin(); it != m_activeInstances.end(); ++it)
|
||
it->second.m_canceled = true;
|
||
}
|
||
|
||
if (waitForCompleteStop && m_undoneTasks > 0) {
|
||
// Sometimes, QEventLoop suddenly stops processing slots (especially those
|
||
// notifications
|
||
// from active rendering instances) - therefore resulting in a block of the
|
||
// application.
|
||
// I've not figured out why (#QTBUG-11649?) - but substituting with a plain
|
||
// while
|
||
// seems to do the trick...
|
||
|
||
/*QEventLoop eventLoop;
|
||
m_waitingLoops.push_back(&eventLoop);
|
||
eventLoop.exec();*/
|
||
|
||
bool loopQuit = false;
|
||
m_waitingLoops.push_back(&loopQuit);
|
||
|
||
sl.unlock();
|
||
|
||
while (!loopQuit)
|
||
QCoreApplication::processEvents(QEventLoop::AllEvents |
|
||
QEventLoop::WaitForMoreEvents);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::quitWaitingLoops() {
|
||
// Make the stopRendering waiting loops quit
|
||
while (!m_waitingLoops.empty()) {
|
||
// rendererImp->m_waitingLoops.back()->quit();
|
||
*m_waitingLoops.back() = true;
|
||
m_waitingLoops.pop_back();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::notifyRasterStarted(const TRenderPort::RenderData &rd) {
|
||
// Since notifications may trigger port removals, we always work on a copy of
|
||
// the ports
|
||
// vector.
|
||
TRendererImp::PortContainer portsCopy;
|
||
{
|
||
QReadLocker sl(&m_portsLock);
|
||
portsCopy = m_ports;
|
||
}
|
||
|
||
for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();
|
||
++it)
|
||
(*it)->onRenderRasterStarted(rd);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::notifyRasterCompleted(const TRenderPort::RenderData &rd) {
|
||
TRendererImp::PortContainer portsCopy;
|
||
{
|
||
QReadLocker sl(&m_portsLock);
|
||
portsCopy = m_ports;
|
||
}
|
||
|
||
assert(rd.m_rasA);
|
||
|
||
for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();
|
||
++it)
|
||
(*it)->onRenderRasterCompleted(rd);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::notifyRasterFailure(const TRenderPort::RenderData &rd,
|
||
TException &e) {
|
||
TRendererImp::PortContainer portsCopy;
|
||
{
|
||
QReadLocker sl(&m_portsLock);
|
||
portsCopy = m_ports;
|
||
}
|
||
|
||
for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();
|
||
++it)
|
||
(*it)->onRenderFailure(rd, e);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::notifyRenderFinished(bool isCanceled) {
|
||
TRendererImp::PortContainer portsCopy;
|
||
{
|
||
QReadLocker sl(&m_portsLock);
|
||
portsCopy = m_ports;
|
||
}
|
||
|
||
auto sortedFxs = calculateSortedFxs(rootFx);
|
||
for (auto fx : sortedFxs) {
|
||
if (fx) const_cast<TFx *>(fx)->callEndRenderHandler();
|
||
}
|
||
|
||
for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();
|
||
++it)
|
||
(*it)->onRenderFinished();
|
||
}
|
||
|
||
//================================================================================
|
||
|
||
//====================
|
||
// TRenderPort
|
||
//--------------------
|
||
|
||
TRenderPort::TRenderPort() {}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
TRenderPort::~TRenderPort() {}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Setta \b m_renderArea a \b area e pulisce l'istanza corrente di \b
|
||
//! RasterPool.
|
||
void TRenderPort::setRenderArea(const TRectD &area) { m_renderArea = area; }
|
||
|
||
//---------------------------------------------------------
|
||
|
||
//! Ritorna \b m_renderArea.
|
||
TRectD &TRenderPort::getRenderArea() { return m_renderArea; }
|
||
|
||
//================================================================================
|
||
|
||
//===================
|
||
// RenderTask
|
||
//-------------------
|
||
|
||
RenderTask::RenderTask(unsigned long renderId, unsigned long taskId,
|
||
double frame, const TRenderSettings &ri,
|
||
const TFxPair &fx, const TPointD &framePos,
|
||
const TDimension &frameSize,
|
||
const TRendererImpP &rendererImp)
|
||
: m_renderId(renderId)
|
||
, m_taskId(taskId)
|
||
, m_info(ri)
|
||
, m_fx(fx)
|
||
, m_frameSize(frameSize)
|
||
, m_framePos(framePos)
|
||
, m_rendererImp(rendererImp)
|
||
, m_fieldRender(ri.m_fieldPrevalence != TRenderSettings::NoField)
|
||
, m_stereoscopic(ri.m_stereoscopic) {
|
||
m_frames.push_back(frame);
|
||
|
||
// Connect the onFinished slot
|
||
connect(this, SIGNAL(finished(TThread::RunnableP)), this,
|
||
SLOT(onFinished(TThread::RunnableP)));
|
||
connect(this, SIGNAL(exception(TThread::RunnableP)), this,
|
||
SLOT(onFinished(TThread::RunnableP)));
|
||
|
||
// The shrink info is currently reversed to the settings'affine. Shrink info
|
||
// in the TRenderSettings
|
||
// is no longer supported.
|
||
m_info.m_shrinkX = m_info.m_shrinkY = 1;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::preRun() {
|
||
TRectD geom(m_framePos, TDimensionD(m_frameSize.lx, m_frameSize.ly));
|
||
|
||
if (m_fx.m_frameA) m_fx.m_frameA->dryCompute(geom, m_frames[0], m_info);
|
||
|
||
if (m_fx.m_frameB)
|
||
m_fx.m_frameB->dryCompute(
|
||
geom, m_fieldRender ? m_frames[0] + 0.5 : m_frames[0], m_info);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::run() {
|
||
// Retrieve the task's frame
|
||
assert(!m_frames.empty());
|
||
double t = m_frames[0];
|
||
|
||
if (m_rendererImp->hasToDie(m_renderId)) {
|
||
TException e("Render task aborted");
|
||
onFrameFailed(e);
|
||
return;
|
||
}
|
||
|
||
// Install the renderer in current thread
|
||
rendererStorage.setLocalData(
|
||
new (TRendererImp *)(m_rendererImp.getPointer()));
|
||
renderIdsStorage.setLocalData(new unsigned long(m_renderId));
|
||
|
||
// Inform the managers of frame start
|
||
m_rendererImp->declareFrameStart(t);
|
||
|
||
auto sortedFxs = calculateSortedFxs(m_fx.m_frameA);
|
||
for (auto fx : sortedFxs) {
|
||
if (fx) const_cast<TFx *>(fx)->callStartRenderFrameHandler(&m_info, t);
|
||
}
|
||
|
||
try {
|
||
onFrameStarted();
|
||
|
||
TStopWatch::global(8).start();
|
||
|
||
if (!m_fieldRender && !m_stereoscopic) {
|
||
// Common case - just build the first tile
|
||
buildTile(m_tileA);
|
||
/*-- 通常はここがFxのレンダリング処理 --*/
|
||
m_fx.m_frameA->compute(m_tileA, t, m_info);
|
||
} else {
|
||
assert(!(m_stereoscopic && m_fieldRender));
|
||
// Field rendering or stereoscopic case
|
||
if (m_stereoscopic) {
|
||
buildTile(m_tileA);
|
||
m_fx.m_frameA->compute(m_tileA, t, m_info);
|
||
|
||
buildTile(m_tileB);
|
||
m_fx.m_frameB->compute(m_tileB, t, m_info);
|
||
}
|
||
// if fieldPrevalence, Decide the rendering frames depending on field
|
||
// prevalence
|
||
else if (m_info.m_fieldPrevalence == TRenderSettings::EvenField) {
|
||
buildTile(m_tileA);
|
||
m_fx.m_frameA->compute(m_tileA, t, m_info);
|
||
|
||
buildTile(m_tileB);
|
||
m_fx.m_frameB->compute(m_tileB, t + 0.5, m_info);
|
||
} else {
|
||
buildTile(m_tileB);
|
||
m_fx.m_frameA->compute(m_tileB, t, m_info);
|
||
|
||
buildTile(m_tileA);
|
||
m_fx.m_frameB->compute(m_tileA, t + 0.5, m_info);
|
||
}
|
||
}
|
||
|
||
TStopWatch::global(8).stop();
|
||
|
||
onFrameCompleted();
|
||
} catch (TException &e) {
|
||
onFrameFailed(e);
|
||
} catch (...) {
|
||
TException ex("Unknown render exception");
|
||
onFrameFailed(ex);
|
||
}
|
||
|
||
// Inform the managers of frame end
|
||
m_rendererImp->declareFrameEnd(t);
|
||
|
||
// Uninstall the renderer from current thread
|
||
rendererStorage.setLocalData(0);
|
||
renderIdsStorage.setLocalData(0);
|
||
|
||
for (auto fx : sortedFxs) {
|
||
if (fx) const_cast<TFx *>(fx)->callEndRenderFrameHandler(&m_info, t);
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::buildTile(TTile &tile) {
|
||
tile.m_pos = m_framePos;
|
||
tile.setRaster(
|
||
m_rendererImp->m_rasterPool.getRaster(m_frameSize, m_info.m_bpp));
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::releaseTiles() {
|
||
m_rendererImp->m_rasterPool.releaseRaster(m_tileA.getRaster());
|
||
m_tileA.setRaster(TRasterP());
|
||
if (m_fieldRender || m_stereoscopic) {
|
||
m_rendererImp->m_rasterPool.releaseRaster(m_tileB.getRaster());
|
||
m_tileB.setRaster(TRasterP());
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::onFrameStarted() {
|
||
TRenderPort::RenderData rd(m_frames, m_info, 0, 0, m_renderId, m_taskId);
|
||
m_rendererImp->notifyRasterStarted(rd);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::onFrameCompleted() {
|
||
TRasterP rasA(m_tileA.getRaster());
|
||
TRasterP rasB(m_tileB.getRaster());
|
||
|
||
if (m_fieldRender) {
|
||
assert(rasB);
|
||
|
||
double t = m_frames[0];
|
||
|
||
int f = (m_info.m_fieldPrevalence == TRenderSettings::EvenField) ? 0 : 1;
|
||
interlace(rasA, rasB, f);
|
||
rasB = TRasterP();
|
||
}
|
||
|
||
TRenderPort::RenderData rd(m_frames, m_info, rasA, rasB, m_renderId,
|
||
m_taskId);
|
||
m_rendererImp->notifyRasterCompleted(rd);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::onFrameFailed(TException &e) {
|
||
// TRasterP evenRas(m_evenTile.getRaster());
|
||
|
||
TRenderPort::RenderData rd(m_frames, m_info, m_tileA.getRaster(),
|
||
m_tileB.getRaster(), m_renderId, m_taskId);
|
||
m_rendererImp->notifyRasterFailure(rd, e);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void RenderTask::onFinished(TThread::RunnableP) {
|
||
TRendererImp *rendererImp = m_rendererImp.getPointer();
|
||
--rendererImp->m_undoneTasks;
|
||
|
||
// Tiles release back to the Raster Pool happens in the main thread, after all
|
||
// possible
|
||
// signals emitted in the onFrameCompleted/Failed notifications have been
|
||
// resolved, thus
|
||
// ensuring that no other rendering thread owns the rasters before them.
|
||
releaseTiles();
|
||
|
||
// Update the render instance status
|
||
bool instanceExpires = false;
|
||
bool isCanceled = false;
|
||
{
|
||
QMutexLocker sl(&rendererImp->m_renderInstancesMutex);
|
||
std::map<unsigned long, TRendererImp::RenderInstanceInfos>::iterator it =
|
||
rendererImp->m_activeInstances.find(m_renderId);
|
||
|
||
if (it != rendererImp->m_activeInstances.end() &&
|
||
(--it->second.m_activeTasks) <= 0) {
|
||
instanceExpires = true;
|
||
isCanceled = (m_info.m_isCanceled && *m_info.m_isCanceled);
|
||
rendererImp->m_activeInstances.erase(m_renderId);
|
||
// m_info is freed, don't access further!
|
||
}
|
||
}
|
||
|
||
// If the render instance has just expired
|
||
if (instanceExpires) {
|
||
/*-- キャンセルされた場合はm_overallRenderedRegionの更新をしない --*/
|
||
|
||
// Inform the render ports
|
||
rendererImp->notifyRenderFinished(isCanceled);
|
||
|
||
// NOTE: This slot is currently invoked on the main thread. It could
|
||
// eventually be
|
||
// invoked directly on rendering threads, specifying the
|
||
// Qt::DirectConnection option -
|
||
// but probably there would be no real advantage in doing so...
|
||
|
||
// Temporarily install the renderer in current thread
|
||
rendererStorage.setLocalData(new (TRendererImp *)(rendererImp));
|
||
renderIdsStorage.setLocalData(new unsigned long(m_renderId));
|
||
|
||
// Inform the resource managers
|
||
rendererImp->declareRenderEnd(m_renderId);
|
||
|
||
// Uninstall the temporary
|
||
rendererStorage.setLocalData(0);
|
||
renderIdsStorage.setLocalData(0);
|
||
|
||
rendererImp->m_rasterPool
|
||
.clear(); // Isn't this misplaced? Should be in the block
|
||
} // below...
|
||
|
||
// If no rendering task (of this or other render instances) is found...
|
||
if (rendererImp->m_undoneTasks == 0) {
|
||
QMutexLocker sl(&rendererImp->m_renderInstancesMutex);
|
||
rendererImp->quitWaitingLoops();
|
||
}
|
||
}
|
||
|
||
//================================================================================
|
||
// Tough Stuff
|
||
//================================================================================
|
||
|
||
void TRendererStartInvoker::emitStartRender(TRendererImp *renderer,
|
||
StartInvokerRenderData rd) {
|
||
renderer->addRef();
|
||
Q_EMIT startRender(renderer, rd);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererStartInvoker::doStartRender(TRendererImp *renderer,
|
||
StartInvokerRenderData rd) {
|
||
renderer->startRendering(rd.m_renderId, *rd.m_renderDataVector);
|
||
renderer->release();
|
||
delete rd.m_renderDataVector;
|
||
}
|
||
|
||
std::vector<const TFx *> calculateSortedFxs(TRasterFxP rootFx) {
|
||
std::map<const TFx *, std::set<const TFx *>> E; /* 辺の情報 */
|
||
std::set<const TFx *> Sources; /* 入次数0のノード群 */
|
||
|
||
std::queue<const TFx *> Q;
|
||
Q.push(rootFx.getPointer());
|
||
|
||
E[rootFx.getPointer()] = std::set<const TFx *>();
|
||
|
||
while (!Q.empty()) {
|
||
const TFx *vptr = Q.front();
|
||
Q.pop();
|
||
if (!vptr) {
|
||
continue;
|
||
}
|
||
|
||
/* 繋がっている入力ポートの先の Fx を訪問する
|
||
入力ポートが無ければ終了 */
|
||
int portCount = vptr->getInputPortCount();
|
||
if (portCount < 1) {
|
||
Sources.insert(vptr);
|
||
continue;
|
||
}
|
||
for (int i = 0; i < portCount; i++) {
|
||
TFxPort *port = vptr->getInputPort(i);
|
||
if (!port) {
|
||
continue;
|
||
}
|
||
TFxP u = port->getFx();
|
||
const TFx *uptr = u.getPointer();
|
||
if (E.count(uptr) == 0) {
|
||
E[uptr] = std::set<const TFx *>();
|
||
}
|
||
if (E[uptr].count(vptr) == 0) {
|
||
E[uptr].insert(vptr);
|
||
}
|
||
Q.push(uptr);
|
||
}
|
||
}
|
||
|
||
/* トポロジカルソート */
|
||
std::set<const TFx *> visited;
|
||
std::vector<const TFx *> L;
|
||
std::function<void(const TFx *)> visit = [&visit, &visited, &E,
|
||
&L](const TFx *fx) {
|
||
if (visited.count(fx)) return;
|
||
visited.insert(fx);
|
||
auto edge = E[fx];
|
||
for (auto i = edge.cbegin(); i != edge.cend(); i++) {
|
||
visit(*i);
|
||
}
|
||
L.insert(L.begin(), fx);
|
||
};
|
||
for (auto i = E.cbegin(); i != E.cend(); i++) {
|
||
visit(i->first);
|
||
}
|
||
return L;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
|
||
void TRendererImp::startRendering(
|
||
unsigned long renderId,
|
||
const std::vector<TRenderer::RenderData> &renderDatas) {
|
||
rootFx = renderDatas.front().m_fxRoot.m_frameA;
|
||
int T = renderDatas.size();
|
||
for (int z = 0; z < T; z++) {
|
||
auto sortedFxs = calculateSortedFxs(renderDatas[z].m_fxRoot.m_frameA);
|
||
if (z == 0) {
|
||
for (auto fx : sortedFxs) {
|
||
if (fx) const_cast<TFx *>(fx)->callStartRenderHandler();
|
||
}
|
||
}
|
||
}
|
||
|
||
struct locals {
|
||
static inline void setStorage(TRendererImp *imp, unsigned long renderId) {
|
||
rendererStorage.setLocalData(new (TRendererImp *)(imp));
|
||
renderIdsStorage.setLocalData(new unsigned long(renderId));
|
||
}
|
||
|
||
static inline void clearStorage() {
|
||
rendererStorage.setLocalData(0);
|
||
renderIdsStorage.setLocalData(0);
|
||
}
|
||
|
||
static inline void declareStatusStart(TRendererImp *imp,
|
||
TRenderer::RenderStatus status,
|
||
RenderInstanceInfos *renderInfos) {
|
||
renderInfos->m_status = status;
|
||
imp->declareStatusStart(status);
|
||
}
|
||
|
||
//-----------------------------------------------------------------------
|
||
|
||
struct InstanceDeclaration {
|
||
TRendererImp *m_imp;
|
||
unsigned long m_renderId;
|
||
bool m_rollback;
|
||
|
||
InstanceDeclaration(TRendererImp *imp, unsigned long renderId)
|
||
: m_imp(imp), m_renderId(renderId), m_rollback(true) {}
|
||
|
||
~InstanceDeclaration() {
|
||
if (m_rollback) {
|
||
QMutexLocker locker(&m_imp->m_renderInstancesMutex);
|
||
|
||
m_imp->m_activeInstances.erase(m_renderId);
|
||
if (m_imp->m_undoneTasks == 0) m_imp->quitWaitingLoops();
|
||
}
|
||
}
|
||
|
||
void commit() { m_rollback = false; }
|
||
};
|
||
|
||
struct StorageDeclaration {
|
||
StorageDeclaration(TRendererImp *imp, unsigned long renderId) {
|
||
setStorage(imp, renderId);
|
||
}
|
||
|
||
~StorageDeclaration() { clearStorage(); }
|
||
};
|
||
|
||
struct RenderDeclaration {
|
||
TRendererImp *m_imp;
|
||
unsigned long m_renderId;
|
||
bool m_rollback;
|
||
|
||
RenderDeclaration(TRendererImp *imp, unsigned long renderId)
|
||
: m_imp(imp), m_renderId(renderId), m_rollback(true) {
|
||
imp->declareRenderStart(renderId);
|
||
}
|
||
|
||
~RenderDeclaration() {
|
||
if (m_rollback) m_imp->declareRenderEnd(m_renderId);
|
||
}
|
||
|
||
void commit() { m_rollback = false; }
|
||
};
|
||
|
||
struct StatusDeclaration {
|
||
TRendererImp *m_imp;
|
||
TRenderer::RenderStatus m_status;
|
||
|
||
StatusDeclaration(TRendererImp *imp, TRenderer::RenderStatus status,
|
||
RenderInstanceInfos *renderInfos)
|
||
: m_imp(imp), m_status(status) {
|
||
declareStatusStart(imp, status, renderInfos);
|
||
}
|
||
|
||
~StatusDeclaration() { m_imp->declareStatusEnd(m_status); }
|
||
};
|
||
}; // locals
|
||
|
||
// DIAGNOSTICS_CLEAR;
|
||
|
||
//----------------------------------------------------------------------
|
||
// Preliminary initializations
|
||
//----------------------------------------------------------------------
|
||
|
||
// Calculate the overall render area - sum of all render ports' areas
|
||
TRectD renderArea;
|
||
{
|
||
QReadLocker sl(&m_portsLock);
|
||
|
||
for (PortContainerIterator it = m_ports.begin(); it != m_ports.end(); ++it)
|
||
renderArea += (*it)->getRenderArea();
|
||
}
|
||
|
||
const TRenderSettings &info(renderDatas[0].m_info);
|
||
|
||
// Extract the render geometry
|
||
TPointD pos(renderArea.getP00());
|
||
TDimension frameSize(tceil(renderArea.getLx()), tceil(renderArea.getLy()));
|
||
|
||
TRectD camBox(TPointD(pos.x / info.m_shrinkX, pos.y / info.m_shrinkY),
|
||
TDimensionD(frameSize.lx, frameSize.ly));
|
||
|
||
// Refresh the raster pool specs
|
||
m_rasterPool.setRasterSpecs(frameSize, info.m_bpp);
|
||
|
||
// Set a temporary active instance count - so that hasToDie(renderId) returns
|
||
// false
|
||
RenderInstanceInfos *renderInfos;
|
||
{
|
||
QMutexLocker locker(&m_renderInstancesMutex);
|
||
renderInfos = &m_activeInstances[renderId];
|
||
renderInfos->m_activeTasks = 1;
|
||
}
|
||
|
||
locals::InstanceDeclaration instanceDecl(this, renderId);
|
||
|
||
//----------------------------------------------------------------------
|
||
// Clustering - Render Tasks creation
|
||
//----------------------------------------------------------------------
|
||
|
||
std::vector<RenderTask *> tasksVector;
|
||
|
||
struct TasksCleaner {
|
||
std::vector<RenderTask *> &m_tasksVector;
|
||
~TasksCleaner() {
|
||
std::for_each(m_tasksVector.begin(), m_tasksVector.end(),
|
||
tcg::deleter<RenderTask>());
|
||
}
|
||
} tasksCleaner = {tasksVector};
|
||
|
||
unsigned long tasksIdCounter = 0;
|
||
|
||
std::map<std::string, RenderTask *> clusters;
|
||
std::vector<TRenderer::RenderData>::const_iterator it;
|
||
std::map<std::string, RenderTask *>::iterator jt;
|
||
|
||
for (it = renderDatas.begin(); it != renderDatas.end(); ++it) {
|
||
// Check for user cancels
|
||
if (hasToDie(renderId)) return;
|
||
|
||
// Build the frame's description alias
|
||
const TRenderer::RenderData &renderData = *it;
|
||
|
||
/*--- カメラサイズ (LevelAutoやノイズで使用する) ---*/
|
||
TRenderSettings rs = renderData.m_info;
|
||
rs.m_cameraBox = camBox;
|
||
/*--- 途中でPreview計算がキャンセルされたときのフラグ ---*/
|
||
rs.m_isCanceled = &renderInfos->m_canceled;
|
||
|
||
TRasterFxP fx = renderData.m_fxRoot.m_frameA;
|
||
assert(fx);
|
||
|
||
double frame = renderData.m_frame;
|
||
|
||
std::string alias = fx->getAlias(frame, renderData.m_info);
|
||
if (renderData.m_fxRoot.m_frameB)
|
||
alias = alias +
|
||
renderData.m_fxRoot.m_frameB->getAlias(frame, renderData.m_info);
|
||
|
||
// Search the alias among stored clusters - and store the frame
|
||
jt = clusters.find(alias);
|
||
|
||
if (jt == clusters.end()) {
|
||
RenderTask *newTask =
|
||
new RenderTask(renderId, tasksIdCounter++, renderData.m_frame, rs,
|
||
renderData.m_fxRoot, pos, frameSize, this);
|
||
|
||
tasksVector.push_back(newTask);
|
||
clusters.insert(std::make_pair(alias, newTask));
|
||
} else
|
||
jt->second->addFrame(renderData.m_frame);
|
||
|
||
// Call processEvents to make the GUI reactive.
|
||
QCoreApplication::instance()->processEvents();
|
||
}
|
||
|
||
// Release the clusters - we'll just need the tasks vector from now on
|
||
clusters.clear();
|
||
|
||
std::vector<RenderTask *>::iterator kt, kEnd = tasksVector.end();
|
||
{
|
||
// Install TRenderer on current thread before proceeding
|
||
locals::StorageDeclaration storageDecl(this, renderId);
|
||
|
||
// Inform the resource managers
|
||
locals::RenderDeclaration renderDecl(this, renderId);
|
||
|
||
//----------------------------------------------------------------------
|
||
// Precomputing
|
||
//----------------------------------------------------------------------
|
||
|
||
if (m_precomputingEnabled) {
|
||
// Set current maxTileSize for cache manager precomputation
|
||
const TRenderSettings &rs = renderDatas[0].m_info;
|
||
TPredictiveCacheManager::instance()->setMaxTileSize(rs.m_maxTileSize);
|
||
TPredictiveCacheManager::instance()->setBPP(rs.m_bpp);
|
||
|
||
// Perform the first precomputing run - fx usages declaration
|
||
{
|
||
locals::StatusDeclaration firstrunDecl(this, TRenderer::FIRSTRUN,
|
||
renderInfos);
|
||
|
||
for (kt = tasksVector.begin(); kt != kEnd; ++kt) {
|
||
if (hasToDie(renderId)) return;
|
||
|
||
(*kt)->preRun();
|
||
|
||
// NOTE: Thread-specific data must be temporarily uninstalled before
|
||
// processing events (which may redefine the thread data).
|
||
locals::clearStorage();
|
||
QCoreApplication::instance()->processEvents();
|
||
locals::setStorage(this, renderId);
|
||
}
|
||
}
|
||
|
||
// Pass to the TESTRUN status - this one should faithfully reproduce
|
||
// the actual COMPUTING status
|
||
{
|
||
locals::StatusDeclaration testrunDecl(this, TRenderer::TESTRUN,
|
||
renderInfos);
|
||
|
||
for (kt = tasksVector.begin(); kt != kEnd; ++kt) {
|
||
if (hasToDie(renderId)) return;
|
||
|
||
(*kt)->preRun();
|
||
|
||
// NOTE: Thread-specific data must be temporarily uninstalled before
|
||
// processing events (which may redefine the thread data).
|
||
locals::clearStorage();
|
||
QCoreApplication::instance()->processEvents();
|
||
locals::setStorage(this, renderId);
|
||
}
|
||
}
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
// Render
|
||
//----------------------------------------------------------------------
|
||
|
||
locals::declareStatusStart(this, TRenderer::COMPUTING, renderInfos);
|
||
|
||
// Update the tasks counts
|
||
m_undoneTasks += tasksVector.size();
|
||
{
|
||
QMutexLocker locker(&m_renderInstancesMutex);
|
||
renderInfos->m_activeTasks = tasksVector.size();
|
||
}
|
||
|
||
renderDecl.commit(); // Declarations are taken over by render tasks
|
||
}
|
||
|
||
instanceDecl.commit(); // Same here
|
||
|
||
// Launch the render
|
||
for (kt = tasksVector.begin(); kt != tasksVector.end(); ++kt)
|
||
m_executor.addTask(*kt);
|
||
|
||
tasksVector.clear(); // Prevent tasks destruction by TasksCleaner
|
||
}
|
||
|
||
void TRenderer::initialize() { TRendererStartInvoker::instance(); }
|