//----------------------------------------------------------------------- PatchMeshPtr MeshManager::createBezierPatch(const String& name, const String& groupName, void* controlPointBuffer, VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, PatchSurface::VisibleSide visibleSide, HardwareBuffer::Usage vbUsage, HardwareBuffer::Usage ibUsage, bool vbUseShadow, bool ibUseShadow) { if (width < 3 || height < 3) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Bezier patch require at least 3x3 control points", "MeshManager::createBezierPatch"); } MeshPtr pMesh = getByName(name); if (!pMesh.isNull()) { OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "A mesh called " + name + " already exists!", "MeshManager::createBezierPatch"); } PatchMesh* pm = OGRE_NEW PatchMesh(this, name, getNextHandle(), groupName); pm->define(controlPointBuffer, declaration, width, height, uMaxSubdivisionLevel, vMaxSubdivisionLevel, visibleSide, vbUsage, ibUsage, vbUseShadow, ibUseShadow); pm->load(); ResourcePtr res(pm); addImpl(res); return res.staticCast<PatchMesh>(); }
//========================================================= double TesterManager::runTest(const std::string& strTName) { double dRez = TM_EMPTY; if (m_MTC.empty()) { return dRez; } if (strTName == std::string()) { // run all tests // first resolve dependencies std::vector<std::string> vcStrDeps; if (!resolveDeps(vcStrDeps)) { DBG_ERR("Manager '%s', looped dependency detected, final results could seem better than actual", m_strName.c_str()); } for (std::vector<std::string>::const_iterator vscit = vcStrDeps.begin(); vscit != vcStrDeps.end(); ++vscit) { const std::string& strDepName = *vscit; double dDepRez = runTest(strDepName); if (0.0 <= dDepRez && dDepRez <= 1.0) { m_DRM[strDepName] = dDepRez; } else { DBG_ERR("Manager '%s', error running dependency test, runTest returned %g", m_strName.c_str(), dDepRez); } } // now run all the rest std::size_t sztTestsRun = m_MTC.size(); double dSum = 0.0; for (MapTesterClasses::iterator mtcit = m_MTC.begin(); mtcit != m_MTC.end(); ++mtcit) { const std::string& strCName = mtcit->first; if (strCName == std::string()) { DBG_ERR("Manager '%s', empty class name detected", m_strName.c_str()); continue; } double dTest = runTest(strCName); if (0.0 <= dTest && dTest <= 1.0) { dSum += dTest; } } dRez = dSum / double(sztTestsRun); } else { // run specific test TesterMethod* pTM = nullptr; TesterClass* pTC = nullptr; if (getByName(strTName, pTC, pTM)) { if (pTM) { if (m_DRM.find(strTName) != m_DRM.end()) { dRez = m_DRM[strTName]; } else { dRez = pTM->runTest(); if (0.0 <= dRez && dRez <= 1.0) { m_DRM[strTName] = dRez; } } } else { dRez = pTC->runTest(); } } else { dRez = TM_ERROR; } } return dRez; }
void CloudAtlasControlWindow::CenterWidget::checkBoxClick(std::string name) { osgWidget::Widget* ckWidget = getByName(name); if (name == "bottom") { osgWidget::Window* win = static_cast<osgWidget::Window::EmbeddedWindow*>(ckWidget)->getWindow(); VirtualDataSceneWidget::VCheckBox* check = static_cast<VirtualDataSceneWidget::VCheckBox*>(win); bool state = check->getState(); if (state) _probeLayer->showCloudAtlas(CloudAtlas_Bottom); else _probeLayer->closeCloudAtlas(CloudAtlas_Bottom); } else if (name == "center") { osgWidget::Window* win = static_cast<osgWidget::Window::EmbeddedWindow*>(ckWidget)->getWindow(); VirtualDataSceneWidget::VCheckBox* check = static_cast<VirtualDataSceneWidget::VCheckBox*>(win); bool state = check->getState(); if (state) _probeLayer->showCloudAtlas(CloudAtlas_Center); else _probeLayer->closeCloudAtlas(CloudAtlas_Center); } else if (name == "top") { osgWidget::Window* win = static_cast<osgWidget::Window::EmbeddedWindow*>(ckWidget)->getWindow(); VirtualDataSceneWidget::VCheckBox* check = static_cast<VirtualDataSceneWidget::VCheckBox*>(win); bool state = check->getState(); if (state) _probeLayer->showCloudAtlas(CloudAtlas_Top); else _probeLayer->closeCloudAtlas(CloudAtlas_Top); } }
//----------------------------------------------------------------------- CompositorInstance *CompositorManager::addCompositor(Viewport *vp, const String &compositor, int addPosition) { CompositorPtr comp = getByName(compositor); if(comp.isNull()) return 0; CompositorChain *chain = getCompositorChain(vp); return chain->addCompositor(comp, addPosition==-1 ? CompositorChain::LAST : (size_t)addPosition); }
//----------------------------------------------------------------------- void ResourceManager::remove(const String& name) { ResourcePtr res = getByName(name); if (!res.isNull()) { removeImpl(res); } }
Ogre::ResourcePtr EntityRecipeManager::create(const Ogre::String& name, const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader, const Ogre::NameValuePairList* createParams) { Ogre::ResourcePtr ret = getByName(name); if (ret.isNull()) { return Ogre::ResourceManager::create(name, group, isManual, loader, createParams); } S_LOG_WARNING("EntityRecipe with name " << name << " already exists."); return Ogre::ResourcePtr(); }
/** * По данным в узле 1 - <exist> и чтению узла 2 <in> * строим 2 множества - множество передачи от 1 к 2 * множество данных, требуемых в 2 от других узлов (кроме 1) * Подробнее принцип смотри в readme.!!! */ void createForwardTransition(const stringSet &exist, const stringSet &in, stringSet &local, stringSet &other) { // Все данные из <exist> - детерминированные // Если in - детерминированный - передать только это // иначе - передать весь массив(измерение) для синхронизации stringSet::const_iterator beg = in.begin(); stringSet::const_iterator end = in.end(); while (beg != end) { TParam cur = (*--end); if (cur. isScalarVar()) { if (find(cur, exist)) in_out::insert(local, cur); else in_out::insert(other, cur); continue; } if (cur. isScalarArray()) { // это мощная недетерминированная передача stringSet p = getByName(exist, cur. getName()); // Если в р есть весь массив - то его в local if (find(p. begin(), p.end(), cur) == p. end()) { // если не весь - то делим sub на local/other concat(local, p); concat(other, sub(cur, p)); } else { // fixme :array to many elements concat(local, toLocalMemoryUse(cur. unroll())); } continue; } // isScalarElement() int dim = cur. getDimension(); TIndex *indexes = cur. getIndexes(); TDimensionList list = cur. getTypeInfo(). second; TDimensionList::iterator cur_beg = list. begin(); for (int i = dim - 1; i >= 0; i--, cur_beg++) { if (indexes[i]. isAtom()) { cur. setIndex(i, TRange(0, (*cur_beg - 1))); } } intersect(exist, toLocalMemoryUse(cur), local, other); delete[] indexes; } packUnifySet(local); packUnifySet(other); }
LogFilePtr LogFileManager::load(const Ogre::String &name, const Ogre::String &group) { LogFilePtr textf = getByName(name); if (textf.isNull()) textf = create(name, group); textf->load(); return textf; }
//========================================================= unsigned long TesterManager::getFullDepSet(const std::string& strName, DepSet& outDS, const DepSet& dsDepPath, std::map<std::string, DepSet>* pFDS) const { unsigned long ulRet = 0; outDS.clear(); TesterMethod* pTM = nullptr; TesterClass* pTC = nullptr; if (!getByName(strName, pTC, pTM)) { DBG_ERR("Manager '%s', invalid name: '%s'", m_strName.c_str(), strName.c_str()); return GFDS_InvalidName; } if (pFDS) { std::map<std::string, DepSet>::const_iterator msdscit = pFDS->find(strName); if (msdscit != pFDS->end()) { outDS = msdscit->second; return GFDS_Used_Cache; } } DepSet dsDep, dsPath = dsDepPath; dsPath.insert(strName); if (pTM != nullptr) { pTM->getDependencies(dsDep); } else if (pTC != nullptr) { pTC->getDependencies(dsDep); } else { DBG_ERR("Manager '%s', name '%s'; getByName: nullptrs for TesterClass and TesterMethod", m_strName.c_str(), strName.c_str()); return GFDS_InvalidName; } for (DepSet::const_iterator dscit = dsDep.begin(); dscit != dsDep.end(); ++dscit) { const std::string& strDep = *dscit; if (strDep.empty()) { DBG_ERR("Manager '%s', name '%s'; empty dependency name", m_strName.c_str(), strName.c_str()); ulRet |= GFDS_InvalidName; continue; } if (dsPath.find(strDep) != dsPath.end()) { DBG_ERR("Manager '%s', name '%s'; looped dependency: '%s'", m_strName.c_str(), strName.c_str(), strDep.c_str()); ulRet |= GFDS_Looped_Deps; continue; } if (outDS.find(strDep) != outDS.end()) { // already processed continue; } outDS.insert(strDep); DepSet dsSubDep; ulRet |= getFullDepSet(strDep, dsSubDep, dsPath, pFDS); outDS.insert(dsSubDep.begin(), dsSubDep.end()); } if (pFDS) { if (pFDS->find(strName) == pFDS->end()) { pFDS->operator[](strName) = outDS; } } return ulRet; }
//----------------------------------------------------------------------- void ResourceManager::unload(const String& name) { ResourcePtr res = getByName(name); if (!res.isNull()) { // Unload resource res->unload(); } }
VectorWidgetPtr LayoutManager::loadLayout(const std::string& _file, const std::string& _prefix, Widget* _parent) { mCurrentLayoutName = _file; ResourceLayout* resource = getByName(_file, false); if (!resource) { ResourceManager::getInstance().load(_file); resource = getByName(_file, false); } VectorWidgetPtr result; if (resource) result = resource->createLayout(_prefix, _parent); else MYGUI_LOG(Warning, "Layout '" << _file << "' couldn't be loaded"); mCurrentLayoutName = ""; return result; }
//----------------------------------------------------------------------- ResourcePtr ResourceManager::load(const String& name, const String& group, bool isManual, ManualResourceLoader* loader, const NameValuePairList* loadParams) { ResourcePtr ret = getByName(name); if (ret.isNull()) { ret = create(name, group, isManual, loader, loadParams); } // ensure loaded ret->load(); return ret; }
Ogre::ResourcePtr ModelDefinitionManager::create(const Ogre::String& name, const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader, const Ogre::NameValuePairList* createParams) { Ogre::ResourcePtr ret = getByName(name); if (ret.isNull()) { return Ogre::ResourceManager::create(name, group, isManual, loader, createParams); } //Report this. We count on this happening a lot (user media overriding shared media for example), so we will not consider it a failure. S_LOG_INFO("ModelDefinition with name " << name << " already exists."); return Ogre::ResourcePtr(); }
SoundFXPtr SoundFXManager::load (const Ogre::String& name, const Ogre::String& group) { // Obtención del recurso por nombre... SoundFXPtr soundFXPtr = getByName(name); // Si no ha sido creado, se crea. if (soundFXPtr.isNull()) soundFXPtr = create(name, group); // Carga explícita del recurso. soundFXPtr->load(); return soundFXPtr; }
TrackPtr TrackManager::load (const Ogre::String& name, const Ogre::String& group) { // Obtención del recurso por nombre... TrackPtr trackPtr = getByName(name); // Si no ha sido creado, se crea. if (trackPtr.isNull()) trackPtr = create(name, group); // Carga explícita del recurso. trackPtr->load(); return trackPtr; }
//----------------------------------------------------------------------- ArchiveEx* ArchiveManager::load( const String& filename, const String& archiveType, int priority /* =1 */ ) { ArchiveEx* pArch = (ArchiveEx*)(getByName(filename)); if (!pArch) { // Search factories ArchiveFactoryMap::iterator it = mArchFactories.find(archiveType); if (it == mArchFactories.end()) // Factory not found Except(Exception::ERR_ITEM_NOT_FOUND, "Cannot find an archive factory " "to deal with archive of type " + archiveType, "ArchiveManager::load"); pArch = it->second->createObj( filename ); ResourceManager::load(pArch, priority); } return pArch; }
//--------------------------------------------------------------------------- GpuProgramPtr GpuProgramManager::loadFromString(const String& name, const String& groupName, const String& code, GpuProgramType gptype, const String& syntaxCode) { GpuProgramPtr prg; { OGRE_LOCK_AUTO_MUTEX prg = getByName(name); if (prg.isNull()) { prg = createProgramFromString(name, groupName, code, gptype, syntaxCode); } } prg->load(); return prg; }
//----------------------------------------------------------------------- ResourceManager::ResourceCreateOrRetrieveResult ResourceManager::createOrRetrieve( const String& name, const String& group, bool isManual, ManualResourceLoader* loader, const NameValuePairList* params) { // Lock for the whole get / insert OGRE_LOCK_AUTO_MUTEX ResourcePtr res = getByName(name, group); bool created = false; if (res.isNull()) { created = true; res = create(name, group, isManual, loader, params); } return ResourceCreateOrRetrieveResult(res, created); }
void PointerManager::setPointer(const std::string& _name, Widget* _owner) { if (nullptr == mMousePointer) return; IResource* result = getByName(_name); if (result == nullptr) { mPointer = nullptr; mMousePointer->setVisible(false); return; } mMousePointer->setVisible(mVisible); mPointer = result->castType<IPointer>(); mPointer->setImage(mMousePointer); mPointer->setPosition(mMousePointer, mPoint); mWidgetOwner = _owner; }
//----------------------------------------------------------------------- Texture * TextureManager::load( const String &name, TextureType texType, int numMipMaps, Real gamma, int priority ) { Texture* tex = (Texture*)getByName( name ); if( tex == NULL ) { tex = (Texture*)create( name, texType ); if (numMipMaps == -1) tex->setNumMipMaps(mDefaultNumMipMaps); else tex->setNumMipMaps(numMipMaps); tex->setGamma( gamma ); tex->enable32Bit( mIs32Bit ); ResourceManager::load( tex, priority ); } return tex; }
const PageSizeInfo & PageSizeInfo::findNearest(int w, int h) { int p = -1; int d = 99999; for(int i = 0; !__pages[i].isNull(); i++) { if(w <= __pages[i].width() && h <= __pages[i].height()) { int t = (__pages[i].width() - w) + (__pages[i].height() - h); if(t < d) { p = i; d = t; } } } if(p == -1) return getByName("Letter"); return __pages[p]; }
bool Window::setFocused(const std::string& name) { Widget* w1 = getByName(name); bool found = false; if(!w1) { // Just like above, we couldn't find the widget in the toplevel, so lets see if // one of our EmbeddedWindow objects has it. The difference here is that we // search by name. WindowList wl; getEmbeddedList(wl); for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) { Widget* w2 = w->get()->getByName(name); if(w2) { found = true; w1 = w2; } } } else found = true; if(!found) { warn() << "Window [" << _name << "] couldn't find a Widget named [" << name << "] to set as it's focus." << std::endl ; return false; } _setFocused(w1); return true; }
KoPAPageBase *KPrCustomSlideShows::pageByIndex(const QString &name, int index) const { QList<KoPAPageBase*> pages = getByName(name); return pages.value(index); }
int KPrCustomSlideShows::indexByPage(const QString &name, KoPAPageBase *page) const { QList<KoPAPageBase*> pages = getByName(name); return pages.indexOf(page); }
bool LayoutManager::isExist(const std::string& _name) const { return getByName(_name, false) != nullptr; }
//----------------------------------------------------------------------- void TextureManager::unload( String filename ) { Resource* res = getByName( filename ); ResourceManager::unload( res ); }
//----------------------------------------------------------------------- void Quake3ShaderManager::parseScript(DataStreamPtr& stream, const String& group) { String line; Quake3Shader* pShader; char tempBuf[512]; pShader = 0; bool dummy = false; while(!stream->eof()) { line = stream->getLine(); // Ignore comments & blanks if (!(line.length() == 0 || line.substr(0,2) == "//")) { if (pShader == 0) { // No current shader if (getByName(line) == 0) { dummy = false; } else { // Defined before, parse but ignore // Q3A has duplicates in shaders, doh dummy = true; } // So first valid data should be a shader name pShader = create(line); // Skip to and over next { stream->readLine(tempBuf, 511, "{"); } else { // Already in a shader if (line == "}") { // Finished shader if (dummy && pShader) { OGRE_DELETE pShader; } pShader = 0; } else if (line == "{") { // new pass parseNewShaderPass(stream, pShader); } else { // Attribute StringUtil::toLowerCase(line); parseShaderAttrib(line, pShader); } } } } }
Widget* Frame::_getCorner(CornerType c) const { return const_cast<Widget*>(getByName(cornerTypeToString(c))); }
Widget* Frame::_getBorder(BorderType b) const { return const_cast<Widget*>(getByName(borderTypeToString(b))); }
/// AST to the list of columns with types. Columns of Nested type are expanded into a list of real columns. static ColumnsAndDefaults parseColumns(const ASTExpressionList & column_list_ast, const Context & context) { /// list of table columns in correct order NamesAndTypesList columns{}; ColumnDefaults defaults{}; /// Columns requiring type-deduction or default_expression type-check std::vector<std::pair<NameAndTypePair *, ASTColumnDeclaration *>> defaulted_columns{}; /** all default_expressions as a single expression list, * mixed with conversion-columns for each explicitly specified type */ ASTPtr default_expr_list = std::make_shared<ASTExpressionList>(); default_expr_list->children.reserve(column_list_ast.children.size()); for (const auto & ast : column_list_ast.children) { auto & col_decl = typeid_cast<ASTColumnDeclaration &>(*ast); if (col_decl.type) { columns.emplace_back(col_decl.name, DataTypeFactory::instance().get(col_decl.type)); } else /// we're creating dummy DataTypeUInt8 in order to prevent the NullPointerException in ExpressionActions columns.emplace_back(col_decl.name, std::make_shared<DataTypeUInt8>()); /// add column to postprocessing if there is a default_expression specified if (col_decl.default_expression) { defaulted_columns.emplace_back(&columns.back(), &col_decl); /** for columns with explicitly-specified type create two expressions: * 1. default_expression aliased as column name with _tmp suffix * 2. conversion of expression (1) to explicitly-specified type alias as column name */ if (col_decl.type) { const auto & final_column_name = col_decl.name; const auto tmp_column_name = final_column_name + "_tmp"; const auto data_type_ptr = columns.back().type.get(); default_expr_list->children.emplace_back(setAlias( makeASTFunction("CAST", std::make_shared<ASTIdentifier>(tmp_column_name), std::make_shared<ASTLiteral>(Field(data_type_ptr->getName()))), final_column_name)); default_expr_list->children.emplace_back(setAlias(col_decl.default_expression->clone(), tmp_column_name)); } else default_expr_list->children.emplace_back(setAlias(col_decl.default_expression->clone(), col_decl.name)); } } /// set missing types and wrap default_expression's in a conversion-function if necessary if (!defaulted_columns.empty()) { const auto actions = ExpressionAnalyzer{default_expr_list, context, {}, columns}.getActions(true); const auto block = actions->getSampleBlock(); for (auto & column : defaulted_columns) { const auto name_and_type_ptr = column.first; const auto col_decl_ptr = column.second; const auto & column_name = col_decl_ptr->name; const auto has_explicit_type = nullptr != col_decl_ptr->type; auto & explicit_type = name_and_type_ptr->type; /// if column declaration contains explicit type, name_and_type_ptr->type is not null if (has_explicit_type) { const auto & tmp_column = block.getByName(column_name + "_tmp"); const auto & deduced_type = tmp_column.type; /// type mismatch between explicitly specified and deduced type, add conversion for non-array types if (!explicit_type->equals(*deduced_type)) { col_decl_ptr->default_expression = makeASTFunction("CAST", col_decl_ptr->default_expression, std::make_shared<ASTLiteral>(explicit_type->getName())); col_decl_ptr->children.clear(); col_decl_ptr->children.push_back(col_decl_ptr->type); col_decl_ptr->children.push_back(col_decl_ptr->default_expression); } } else /// no explicit type, name_and_type_ptr->type is null, set to deduced type explicit_type = block.getByName(column_name).type; defaults.emplace(column_name, ColumnDefault{ columnDefaultKindFromString(col_decl_ptr->default_specifier), col_decl_ptr->default_expression }); } } return {Nested::flatten(columns), defaults}; }