int clearRuleIndex(ruleStruct_t *inRuleStruct) {
if(inRuleStruct == &coreRuleStrct) {
clearResources(RESC_CORE_FUNC_DESC_INDEX);
} else if(inRuleStruct == &appRuleStrct) {
clearResources(RESC_APP_FUNC_DESC_INDEX);
}
return 0;
}
void ResourceManager::registerDataBaseDir(const Common::UString &path) {
clearResources();
_baseDir = Common::FilePath::normalize(path);
for (int i = 0; i < kArchiveMAX; i++)
addArchiveDir((ArchiveType) i, "");
}
DisplayList::~DisplayList() {
mDestroyed = true;
clearResources();
#if MTK_DEBUG_ERROR_CHECK
Caches::getInstance().removeDisplayList(this);
#endif
}
void DynamicObjectStabilizator::stabilize()
{
if( m_DynamicObjects.size() < 2 )
{
return;
}
fixatePoints();
runTimeLine();
clearResources();
}
void ResourceDock::manageUsedResource(const QHash<size_t, QVector<Kite::KMetaProperty>> *ResComponents) {
if (ResComponents->empty()) {
return;
}
for (auto it = resMap.begin(); it != resMap.end(); ++it) {
if (it.value().second == Kite::RTypes::Scene) {
Kite::KFIStream stream;
auto scene = (Kite::KScene *)load(&stream, it.key());
auto eman = scene->getEManager();
scene->clearResources();
auto econtiner = eman->getEntityStorage();
for (auto eit = econtiner->begin(); eit != econtiner->end(); ++eit) {
// first we collect scripts from logic components
std::vector<Kite::KHandle> lcomps;
eit->getScriptComponents(lcomps);
for (auto sit = lcomps.begin(); sit != lcomps.end(); ++sit) {
auto script = (Kite::KLogicCom *)eit->getComponentByHandle((*sit));
if (!script->getScript().str.empty()) {
scene->addResource(script->getScript().str, Kite::RTypes::Script);
}
}
// then we collect resources from other components
for (auto cit = ResComponents->begin(); cit != ResComponents->end(); ++cit) {
if (cit.key() == (size_t)Kite::CTypes::Logic) {
continue;
}
if (eit->hasComponent((Kite::CTypes)cit.key())) {
for (auto pit = cit->begin(); pit != cit->end(); ++pit) {
auto com = eit->getComponent((Kite::CTypes)cit.key());
auto res = com->getProperty(pit->name);
std::string resName;
if (pit->typeName == "std::string") {
resName = res.as<std::string>();
} else if (pit->typeName == "KStringID") {
resName = res.as<Kite::KStringID>().str;
}
if (!resName.empty()) {
scene->addResource(resName, pit->resType);
}
}
}
}
}
}
}
}
bool DX11ViewportRenderer::drawScene(const MRenderingInfo &renderInfo)
//
// Description:
// Draw the Maya scene, using a custom traverser.
//
{
bool useDrawTraversal = true;
float groundPlaneColor[3] = { 0.8f, 0.8f, 0.8f };
if (useDrawTraversal)
{
const MDagPath &cameraPath = renderInfo.cameraPath();
if (cameraPath.isValid())
{
// You can actually keep the traverser classes around
// if desired. Here we just create temporary traversers
// on the fly.
//
MDrawTraversal *trav = new MDrawTraversal;
if (!trav)
{
MGlobal::displayWarning("DX11 renderer : failed to create a traversal class !\n");
return true;
}
trav->enableFiltering( false );
const MRenderTarget &renderTarget = renderInfo.renderTarget();
trav->setFrustum( cameraPath, renderTarget.width(),
renderTarget.height() );
if (!trav->frustumValid())
{
MGlobal::displayWarning("DX11 renderer : Frustum is invalid !\n");
return true;
}
trav->traverse();
unsigned int numItems = trav->numberOfItems();
unsigned int i;
for (i=0; i<numItems; i++)
{
MDagPath path;
trav->itemPath(i, path);
if (path.isValid())
{
bool drawIt = false;
// Default traverer may have view manips showing up.
// This is currently a known Maya bug.
if ( path.hasFn( MFn::kViewManip ))
continue;
//
// Draw surfaces (polys, nurbs, subdivs)
//
bool active = false;
bool templated = false;
if ( path.hasFn( MFn::kMesh) ||
path.hasFn( MFn::kNurbsSurface) ||
path.hasFn( MFn::kSubdiv) )
{
drawIt = true;
if (trav->itemHasStatus( i, MDrawTraversal::kActiveItem ))
{
active = true;
}
if (trav->itemHasStatus( i, MDrawTraversal::kTemplateItem ))
{
templated = true;
}
}
//
// Draw the ground plane
//
else if (path.hasFn( MFn::kSketchPlane ) ||
path.hasFn( MFn::kGroundPlane ))
{
MMatrix matrix = path.inclusiveMatrix();
MFnDagNode dagNode(path);
MBoundingBox box = dagNode.boundingBox();
drawBounds( matrix, box, groundPlaneColor );
}
if (drawIt)
{
drawSurface( path, active, templated );
}
}
}
if (trav)
delete trav;
// Cleanup any unused resource items
bool onlyInvalidItems = true;
clearResources( onlyInvalidItems, false );
}
}
else
{
// Draw some poly bounding boxes
//
MItDag::TraversalType traversalType = MItDag::kDepthFirst;
MFn::Type filter = MFn::kMesh;
MStatus status;
MItDag dagIterator( traversalType, filter, &status);
for ( ; !dagIterator.isDone(); dagIterator.next() )
{
MDagPath dagPath;
status = dagIterator.getPath(dagPath);
if ( !status ) {
status.perror("MItDag::getPath");
continue;
}
MFnDagNode dagNode(dagPath, &status);
if ( !status ) {
status.perror("MFnDagNode constructor");
continue;
}
MMatrix matrix = dagPath.inclusiveMatrix();
MBoundingBox box = dagNode.boundingBox();
drawBounds( matrix, box, groundPlaneColor );
}
}
return true;
}
/* virtual */
DX11ResourceManager::~DX11ResourceManager()
{
const bool onlyInvalidItems = false;
clearResources(onlyInvalidItems, true);
}
void DisplayList::initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing) {
DISPLAY_LIST_LOGD("init displaylist %s <%p>", getName(), this);
if (reusing) {
// re-using display list - clear out previous allocations
clearResources();
}
init();
mDisplayListData = recorder.getDisplayListData();
mSize = mDisplayListData->allocator.usedSize();
if (mSize == 0) {
return;
}
// allocate reusable ops for state-deferral
LinearAllocator& alloc = mDisplayListData->allocator;
mClipRectOp = new (alloc) ClipRectOp();
mSaveLayerOp = new (alloc) SaveLayerOp();
mSaveOp = new (alloc) SaveOp();
mRestoreToCountOp = new (alloc) RestoreToCountOp();
if (CC_UNLIKELY(!mSaveOp)) { // temporary debug logging
ALOGW("Error: %s's SaveOp not allocated, size %d", getName(), mSize);
CRASH();
}
mFunctorCount = recorder.getFunctorCount();
Caches& caches = Caches::getInstance();
caches.registerFunctors(mFunctorCount);
caches.resourceCache.lock();
const Vector<SkBitmap*>& bitmapResources = recorder.getBitmapResources();
for (size_t i = 0; i < bitmapResources.size(); i++) {
SkBitmap* resource = bitmapResources.itemAt(i);
mBitmapResources.add(resource);
caches.resourceCache.incrementRefcountLocked(resource);
}
const Vector<SkBitmap*> &ownedBitmapResources = recorder.getOwnedBitmapResources();
for (size_t i = 0; i < ownedBitmapResources.size(); i++) {
SkBitmap* resource = ownedBitmapResources.itemAt(i);
mOwnedBitmapResources.add(resource);
caches.resourceCache.incrementRefcountLocked(resource);
}
const Vector<SkiaColorFilter*>& filterResources = recorder.getFilterResources();
for (size_t i = 0; i < filterResources.size(); i++) {
SkiaColorFilter* resource = filterResources.itemAt(i);
mFilterResources.add(resource);
caches.resourceCache.incrementRefcountLocked(resource);
}
const Vector<Res_png_9patch*>& patchResources = recorder.getPatchResources();
for (size_t i = 0; i < patchResources.size(); i++) {
Res_png_9patch* resource = patchResources.itemAt(i);
mPatchResources.add(resource);
caches.resourceCache.incrementRefcountLocked(resource);
}
const Vector<SkiaShader*>& shaders = recorder.getShaders();
for (size_t i = 0; i < shaders.size(); i++) {
SkiaShader* resource = shaders.itemAt(i);
mShaders.add(resource);
caches.resourceCache.incrementRefcountLocked(resource);
}
const SortedVector<SkPath*>& sourcePaths = recorder.getSourcePaths();
for (size_t i = 0; i < sourcePaths.size(); i++) {
mSourcePaths.add(sourcePaths.itemAt(i));
caches.resourceCache.incrementRefcountLocked(sourcePaths.itemAt(i));
}
const Vector<Layer*>& layers = recorder.getLayers();
for (size_t i = 0; i < layers.size(); i++) {
mLayers.add(layers.itemAt(i));
caches.resourceCache.incrementRefcountLocked(layers.itemAt(i));
}
caches.resourceCache.unlock();
mPaints.appendVector(recorder.getPaints());
mRegions.appendVector(recorder.getRegions());
mPaths.appendVector(recorder.getPaths());
mMatrices.appendVector(recorder.getMatrices());
}
void DisplayList::reset() {
clearResources();
init();
}
DisplayList::~DisplayList() {
mDestroyed = true;
clearResources();
}
void ResourceManager::clear() {
_rimsAreERFs = false;
_hashAlgo = Common::kHashFNV64;
clearResources();
}
