C++ StringVector::size方法代码示例

int TorqueCurve::processLine(Ogre::StringVector args, String model)
{
	// if its just one arguments, it must be a known model
	if (args.size() == 1)
		return setTorqueModel(args[0]);

	// we only accept 2 arguments
	if (args.size() != 2)
		return 1;
	// parse the data
	float pointx = StringConverter::parseReal(args[0]);
	float pointy = StringConverter::parseReal(args[1]);
	Vector3 point = Vector3(pointx,pointy,0);

	// find the spline to attach the points
	if (splines.find(model) == splines.end())
		splines[model] = SimpleSpline();

	// attach the points to the spline
	// LOG("curve "+model+" : " + TOSTRING(point));
	splines[model].addPoint(point);

	// special case for custom model:
	// we set it as active curve as well!
	if (model == TorqueCurve::customModel)
		setTorqueModel(TorqueCurve::customModel);

	return 0;
}

    void SoundManager::startRandomTitle()
    {
        Ogre::StringVector filelist;
        if (mMusicFiles.find(mCurrentPlaylist) == mMusicFiles.end())
        {
            Ogre::StringVector groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups ();
            for (Ogre::StringVector::iterator it = groups.begin(); it != groups.end(); ++it)
            {
                Ogre::StringVectorPtr resourcesInThisGroup = mResourceMgr.findResourceNames(*it,
                                                                                            "Music/"+mCurrentPlaylist+"/*");
                filelist.insert(filelist.end(), resourcesInThisGroup->begin(), resourcesInThisGroup->end());
            }
            mMusicFiles[mCurrentPlaylist] = filelist;
        }
        else
            filelist = mMusicFiles[mCurrentPlaylist];

        if(!filelist.size())
            return;

        int i = rand()%filelist.size();

        // Don't play the same music track twice in a row
        if (filelist[i] == mLastPlayedMusic)
        {
            i = (i+1) % filelist.size();
        }

        streamMusicFull(filelist[i]);
    }

	const VectorString& Ogre2DataManager::getDataListNames(const std::string& _pattern, bool _fullpath)
	{
		static VectorString result;
		result.clear();

		VectorString search;
		if (mAllGroups)
		{
			Ogre::StringVector sp = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
			search.reserve(sp.size());
			for (size_t i = 0; i < sp.size(); i++)
				search.push_back(sp[i]);
		}
		else
			search.push_back(mGroup);

		std::vector<Ogre::FileInfoListPtr> pFileInfos;

		int resultSize = 0;
		for (size_t i = 0; i < search.size(); i++)
		{
			Ogre::FileInfoListPtr pFileInfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(search[i], _pattern);
			resultSize += pFileInfo->size();
			if (!pFileInfo->empty())
				pFileInfos.push_back(pFileInfo);
			else
				pFileInfo.setNull();
		}

		result.reserve(resultSize);

		for (size_t i = 0; i < pFileInfos.size(); i++)
		{
			Ogre::FileInfoListPtr pFileInfo = pFileInfos[i];
			for (Ogre::FileInfoList::iterator fi = pFileInfo->begin(); fi != pFileInfo->end(); ++fi )
			{
				if (fi->path.empty())
				{
					bool found = false;
					for (VectorString::iterator iter = result.begin(); iter != result.end(); ++iter)
					{
						if (*iter == fi->filename)
						{
							found = true;
							break;
						}
					}
					if (!found)
					{
						result.push_back(_fullpath ? fi->archive->getName() + "/" + fi->filename : fi->filename);
					}
				}
			}

			pFileInfo.setNull();
		}

		return result;
	}

//-----------------------------------------------------------------------------
void Ogitors::COFSSceneSerializer::_upgradeOgsceneFileFrom3To4(TiXmlNode* ogsceneRootNode)
{
    TiXmlElement* element = ogsceneRootNode->FirstChildElement();   

    OFS::OfsPtr& mFile = OgitorsRoot::getSingletonPtr()->GetProjectFile();
    OgitorsSystem *mSystem = OgitorsSystem::getSingletonPtr();

    OFS::FileList list;
    mFile->listFilesRecursive("/", list);

    Ogre::StringVector terFiles;

    for( unsigned int i = 0;i < list.size(); i++ )
    {
        if(list[i].flags && OFS::OFS_FILE)
        {
            if(list[i].name.substr(list[i].name.size() - 4, 4) == ".ogt")
            {
                terFiles.push_back( list[i].name );
            }
        }
    }

    if( terFiles.size() > 0 )
    {
        Ogre::SceneManager *pUpgSM = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "UpgradeSCM");

        for( unsigned int i = 0;i < terFiles.size(); i++ )
        {
            Ogre::String filenameorig = terFiles[i];
            Ogre::String filenamebackup = filenameorig + ".backup";

            mFile->renameFile( filenameorig.c_str(), filenamebackup.c_str() );

            OFS::OFSHANDLE *filebackup = new OFS::OFSHANDLE();
            OFS::OFSHANDLE *fileorig = new OFS::OFSHANDLE();

            mFile->createFile(*fileorig, filenameorig.c_str());
            mFile->openFile(*filebackup, filenamebackup.c_str(), OFS::OFS_READ);

            {
                OgreTerrainConverter conv;

                Ogre::DataStreamPtr stream_in = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, filebackup));
                Ogre::DataStreamPtr stream_out = Ogre::DataStreamPtr(OGRE_NEW OfsDataStream(mFile, fileorig));
                Ogre::DataStreamPtr compressStream(OGRE_NEW Ogre::DeflateStream(filenameorig, stream_in));
                Ogre::StreamSerialiser ser_in(compressStream);
                Ogre::StreamSerialiser ser_out(stream_out);

                conv.Upgrade( ser_in, ser_out );
            }
        }

        Ogre::Root::getSingletonPtr()->destroySceneManager(pUpgSM);
    }
}

/**----------------------------------------------------------------------------
    Add nxJoint actuator to the scene

    \param nxJoint (NxRevoluteJoint *)
    \return (void)
-----------------------------------------------------------------------------*/
void Actuators::addActuator(Joint* joint)
{
	double Kp = 0, Ti = 0, Td = 0;
	int type = 0;

	// get controller data from userData
	NxJointDesc* desc = NULL;
	joint->getDesc(&desc);

	//if (joint->getFlags()&NX_RJF_MOTOR_ENABLED)
	if (desc->userData != NULL)
	{
		Ogre::StringVector s = Ogre::StringConverter::parseStringVector(Ogre::String((char*)desc->userData));
		s.size() > 0 ? Kp = Ogre::StringConverter::parseReal(s[0]) : Kp = 0.1;
		s.size() > 1 ? Ti = Ogre::StringConverter::parseReal(s[1]) : Ti = 0;
		s.size() > 2 ? Td = Ogre::StringConverter::parseReal(s[2]) : Td = 0.1;
		s.size() > 3 ? type = Ogre::StringConverter::parseInt(s[3]) : type = 0;
	}
	else
	{
		if (joint->getType() == NX_JOINT_D6)
		{
			NxD6JointDesc* descD6 = dynamic_cast<NxD6JointDesc*>(desc);

			if (descD6->twistDrive.driveType == NX_D6JOINT_DRIVE_POSITION)
			{
				type = 1;
			}
		}

	}

	Sensor<double, Joint>* sensor;

	switch (type)
	{
		case 0:
			sensor = new SensorVelocity(joint);
			break;
		case 1:
			sensor = new SensorPosition(joint);
			break;
		case 2:
			sensor = new SensorTorque(joint);
			break;
		default:
			throw Exception("Unknown sensor for controller", "actuators");
	}


	Controller<double>* controllerPID = new ControllerPID(Kp, Ti, Td, 0);
	boost::shared_ptr<Actuator > actuator(new ActuatorPID(joint, controllerPID, sensor));
	mActuators.push_back(actuator);

}

int PlayState::interpretConsoleCommand(const MyGUI::UString & command)
{
    /* This method must be redone in a different way */

    std::string sCommand = (std::string)command;
    Ogre::StringVector splitStrings = Ogre::StringUtil::split(sCommand, " ", 4);
    std::string s = splitStrings.front();
    if(s.compare("close")==0) {
        notifyWindowButtonPressed(mConsoleWindow, s);
    } else if(s.compare("pause")==0) {
        pauseGame();
    } else if(s.compare("quit")==0) {
        mContinue = false;
    } else if(s.compare("push")==0 && splitStrings.size()>=5 ) {

        if(mActors.find(splitStrings[1]) != mActors.end()) {
            OgreBulletDynamics::RigidBody* body = mActors[splitStrings[1]]->getBody();
            if(body) {
                Vector3 dir = Vector3(atof(splitStrings[2].c_str()),atof(splitStrings[3].c_str()),atof(splitStrings[4].c_str()));
                body->getBulletObject()->activate();
                body->applyImpulse(dir*50,Vector3(0, 0.05, 0));
            } else {
                return 0;
            }
        }
    } else if(s.compare("move")==0 && splitStrings.size()>=5) {
        Actor *actor = mActors[splitStrings[1]];
        if (actor) {

            btTransform transform;
            transform.setIdentity();
            transform.setOrigin(OgreBulletCollisions::OgreBtConverter::to(Vector3(atof(splitStrings[2].c_str()),atof(splitStrings[3].c_str()),atof(splitStrings[4].c_str()))));
            actor->getBody()->getBulletRigidBody()->clearForces();
            actor->getBody()->getBulletRigidBody()->setLinearVelocity(btVector3(0,0,0));
            actor->getBody()->getBulletRigidBody()->setAngularVelocity(btVector3(0,0,0));
            actor->getBody()->getBulletRigidBody()->setWorldTransform(transform);
        } else {
            return 0;
        }
    } else if(s.compare("debug")==0) {
        if(splitStrings.size()<2) {
            alterPlayState(DEBUG);
        } else if(splitStrings[1].compare("off")==0) {
            alterPlayState(NORMAL);
        }
    } else if(s.compare("win")==0) {
        GameManager::getSingletonPtr()->changeState(WinState::getInstance());
        return -1;
    } else {
        return 0;
    }
    return 1;
}

	//------------------------------------------------------------------------
	void OptimiseTool::doInvoke(const OptionList& toolOptions,
		const Ogre::StringVector& inFileNames, const Ogre::StringVector& outFileNamesArg)
	{
		// Name count has to match, else we have no way to figure out how to apply output
		// names to input files.
		if (!(outFileNamesArg.empty() || inFileNames.size() == outFileNamesArg.size()))
		{
			fail("number of output files must match number of input files.");
		}

		mPosTolerance = mNormTolerance = mUVTolerance = 1e-06f;
		mKeepIdentityTracks = OptionsUtil::isOptionSet(toolOptions, "keep-identity-tracks");
		for (OptionList::const_iterator it = toolOptions.begin(); it != toolOptions.end(); ++it)
		{
			if (it->first == "tolerance")
			{
				mPosTolerance = mNormTolerance = mUVTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "pos_tolerance")
			{
				mPosTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "norm_tolerance")
			{
				mNormTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
			else if (it->first == "uv_tolerance")
			{
				mUVTolerance = static_cast<float>(any_cast<Real>(it->second));
			}
		}


		StringVector outFileNames = outFileNamesArg.empty() ? inFileNames : outFileNamesArg;

		// Process the meshes
		for (size_t i = 0, end = inFileNames.size(); i < end; ++i)
		{
			if (StringUtil::endsWith(inFileNames[i], ".mesh", true))
			{
				processMeshFile(inFileNames[i], outFileNames[i]);
			}
			else if (StringUtil::endsWith(inFileNames[i], ".skeleton", true))
			{
				processSkeletonFile(inFileNames[i], outFileNames[i]);
			}
			else
			{
				warn("unrecognised name ending for file " + inFileNames[i]);
				warn("file skipped.");
			}
		}
	}

void DotSceneLoader::processPagedGeometry(rapidxml::xml_node<>* XMLNode) {
	Ogre::String filename = "../Projects/SampleScene3/" + getAttrib(XMLNode,
			"fileName");
	Ogre::String model = getAttrib(XMLNode, "model");
// Ogre::Real pagesize = getAttribReal(XMLNode, "pageSize");
// Ogre::Real batchdistance = getAttribReal(XMLNode, "batchDistance");
// Ogre::Real impostordistance = getAttribReal(XMLNode, "impostorDistance");
// Ogre::Vector4 bounds = Ogre::StringConverter::parseVector4(getAttrib(
//   XMLNode, "bounds"));

	std::ifstream stream(filename.c_str());

	if (!stream.is_open())
		return;

	Ogre::StringVector list;

	char res[128];

	PGInstanceList mInstanceList;

	while (!stream.eof()) {
		stream.getline(res, 128);
		Ogre::String resStr(res);

//  ParseStringVector(resStr, list);

		if (list.size() == 3) {
			PGInstanceInfo info;

			info.pos = Ogre::StringConverter::parseVector3(list[0]);
			info.scale = Ogre::StringConverter::parseReal(list[1]);
			info.yaw = Ogre::StringConverter::parseReal(list[2]);

			mInstanceList.push_back(info);
		} else if (list.size() == 4) {
			PGInstanceInfo info;

			info.pos = Ogre::StringConverter::parseVector3(list[1]);
			info.scale = Ogre::StringConverter::parseReal(list[2]);
			info.yaw = Ogre::StringConverter::parseReal(list[3]);

			mInstanceList.push_back(info);
		}
	}

	stream.close();

// if (model != "") {
//    Ogre::Entity *mEntityHandle = mSceneMgr->createEntity(model + ".mesh");
//  }
}

 void OgitorsScriptConsole::addFunction(std::string &arg)
 {
     Ogre::StringVector result = mInterpreter->addFunction(console_str, arg);
     OGRE_LOCK_AUTO_MUTEX;
     for(unsigned int i = 0;i < result.size();i++)
         mOutput.push_back(result[i]);
 }

 void OgitorsScriptConsole::listFunctions()
 {
     Ogre::StringVector result = mInterpreter->listFunctions(console_str);
     OGRE_LOCK_AUTO_MUTEX;
     for(unsigned int i = 0;i < result.size();i++)
         mOutput.push_back(result[i]);
 }

void VLogicModel::_createBoundingBoxFromExternal()
{
    Ogre::StringVector values = Ogre::StringUtil::split(mExternalBoundingBoxValue, " ");

    if (values.size() != 3)
    {
        OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
                    "the bounding box parameter count must be 3!",
                    "LogicModel::_createBoundingBoxFromExternal");

        return;
    }

    Ogre::Real x = Ogre::StringConverter::parseReal(values[0]);
    Ogre::Real y = Ogre::StringConverter::parseReal(values[1]);
    Ogre::Real z = Ogre::StringConverter::parseReal(values[2]);

    Ogre::Vector3 ptMin;
    ptMin.x = -x / 2;
    ptMin.y = 0.0f;
    ptMin.z = -z / 2;

    Ogre::Vector3 ptMax;
    ptMax.x = x / 2;
    ptMax.y = y;
    ptMax.z = z / 2;

    mExternalBoundingBox = new Ogre::AxisAlignedBox(ptMin, ptMax);
}

 void OgitorsScriptConsole::execString(std::string &arg)
 {
     Ogre::StringVector result = mInterpreter->execString(console_str, arg);
     OGRE_LOCK_AUTO_MUTEX;
     mOutput.push_back("Executing : " + arg);
     for(unsigned int i = 0;i < result.size();i++)
         mOutput.push_back(result[i]);
 }

void Viewer::loadMeshList()
{
    emit clearMesh();
    Ogre::StringVector groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
    for (size_t i = 0; i < groups.size(); i++)
    {
        Ogre::StringVector names = *Ogre::ResourceGroupManager::getSingleton().listResourceNames(groups[i]).get();
        for (size_t j=0; j < names.size(); j++)
        {
            size_t pos = names[j].find(".mesh");
            if (pos <= names[j].size())
            {
                emit sendMeshName(names[j].c_str());
            }
        }
    }
}

//url should be like http://toto.net/index.html -> return toto.net
std::string Downloader::extractHost(const std::string& url)
{
	Ogre::StringVector tmp = Ogre::StringUtil::split(url, "/");
	if (tmp.size() < 2)
		return "";
	else
		return tmp[1];
}

 void OgitorsScriptConsole::testScript(std::string &file)
 {
     Ogre::StringVector result = mInterpreter->compileModule(console_str, file);
     OGRE_LOCK_AUTO_MUTEX;
     mOutput.push_back("Testing Script : " + file);
     for(unsigned int i = 0;i < result.size();i++)
         mOutput.push_back(result[i]);
 }