Пример #1
0
    //-----------------------------------------------------------------------
    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>();
    }
Пример #2
0
//=========================================================
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;
}
Пример #3
0
	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);
		}
	}
Пример #4
0
//-----------------------------------------------------------------------
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);
}
Пример #5
0
	//-----------------------------------------------------------------------
	void ResourceManager::remove(const String& name)
	{
		ResourcePtr res = getByName(name);

		if (!res.isNull())
		{
			removeImpl(res);
		}
	}
Пример #6
0
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();
}
Пример #7
0
/**
 * По данным в узле 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);
}
Пример #8
0
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;
}
Пример #9
0
//=========================================================
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;
}
Пример #10
0
	//-----------------------------------------------------------------------
	void ResourceManager::unload(const String& name)
	{
		ResourcePtr res = getByName(name);

		if (!res.isNull())
		{
			// Unload resource
			res->unload();

		}
	}
Пример #11
0
	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;
	}
Пример #12
0
    //-----------------------------------------------------------------------
    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();

}
Пример #14
0
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;
}
Пример #15
0
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;
}
Пример #16
0
//-----------------------------------------------------------------------
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;
}
Пример #17
0
    //---------------------------------------------------------------------------
	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;
    }
Пример #18
0
    //-----------------------------------------------------------------------
    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);
	}
Пример #19
0
	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;
	}
Пример #20
0
//-----------------------------------------------------------------------
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;
}
Пример #21
0
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];
}
Пример #22
0
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;
}
Пример #23
0
KoPAPageBase *KPrCustomSlideShows::pageByIndex(const QString &name, int index) const
{
    QList<KoPAPageBase*> pages = getByName(name);
    return pages.value(index);
}
Пример #24
0
int KPrCustomSlideShows::indexByPage(const QString &name, KoPAPageBase *page) const
{
    QList<KoPAPageBase*> pages = getByName(name);
    return pages.indexOf(page);
}
Пример #25
0
	bool LayoutManager::isExist(const std::string& _name) const
	{
		return getByName(_name, false) != nullptr;
	}
Пример #26
0
//-----------------------------------------------------------------------
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);
                    }

                }

            }


        }

    }
Пример #28
0
Widget* Frame::_getCorner(CornerType c) const
{
    return const_cast<Widget*>(getByName(cornerTypeToString(c)));
}
Пример #29
0
Widget* Frame::_getBorder(BorderType b) const
{
    return const_cast<Widget*>(getByName(borderTypeToString(b)));
}
Пример #30
0
/// 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};
}