C++ gkString类代码示例

bool getTok(const gkString& buf, const gkString& dim, gkString& tok, size_t &start)
{
	const size_t size = buf.size();
	const size_t dimsize = dim.size();

	size_t pos = gkString::npos;

	while (start < size) 
	{
		pos = buf.find(dim, start);
		
		if (pos == gkString::npos) 
			pos = size;
		
		if (start == pos)
			start += dimsize; 
		else
			break;
	}

	if (start >= size) return false;

	tok.assign(&buf[start], pos-start);
	start = pos + dimsize;

	return true;
}

BOM getTextBom(gkString& line, bool removeBom) 
{
	size_t len = line.size();
	BOM bom = getTextEncoding(line.c_str(), len);
	if (bom != BOM_NONE && removeBom) {
		//strip bom
		line = line.substr(getBOMLength(bom));
	}
	return bom;
}

void splitFileName(const gkString& path, gkString& dir, gkString& base, gkString& ext)
{
	if (path.empty()) return;
	if (path == "." || path == "..")
	{
		dir = path;
		return;
	}

	gkString fpath = path, fname;

	char delim = '/';

	bool bdelim = fpath.find_last_of('\\') != gkString::npos;
	bool fdelim = fpath.find_last_of('/')  != gkString::npos;

	if (bdelim) 
	{
		if (fdelim) //normalize to \ to /
			std::replace(fpath.begin(), fpath.end(), '\\', '/');
		else
			delim = '\\';
	} 

	size_t i = fpath.find_last_of(delim);

	if (i != gkString::npos) 
	{
		dir = fpath.substr(0, i);
		fname = fpath.substr(i+1, path.size()-1);
	} 
	else 
	{
		dir.clear();
		fname = fpath;
	}

	i = fname.find_last_of('.');
	if (i != gkString::npos) 
	{
		base = fname.substr(0, i);
		ext = fname.substr(i+1, fname.size()-1);
	} 
	else 
	{
		base = fname;
		ext.clear();
	}
}

bool OgreKit::init(const gkString& blend)
{
	gkPrintf("----------- OgreKit Android Demo init -----------------");
	LOG_FOOT;

	gkString cfgfname;	
	// Parse command line
	m_blend = gkDefaultBlend;
	if (!blend.empty()) m_blend = blend;

	getPrefs().debugFps = true;
	getPrefs().wintitle = gkString("OgreKit Demo (Press Escape to exit)[") + m_blend + gkString("]");
	getPrefs().blendermat=true;
	//getPrefs().shaderCachePath="/sdcard/gamekit";
	getPrefs().enableshadows=false;
	getPrefs().viewportOrientation="portrait";
	//	m_prefs.disableSound=false;
	gkPath path = cfgfname;	

	LOG_FOOT;

	// overide settings if found
	if (path.isFileInBundle())
		getPrefs().load(path.getPath());

	LOG_FOOT;

	m_inited = initialize();
	LOG_FOOT;
	//gkMessageManager::getSingleton().addListener(this);
	return m_inited;
}

bool getAttrib(const TiXmlElement* XMLNode, const gkString& attrib, bool& value)
{
	if (!XMLNode || !XMLNode->Attribute(attrib)) return false;

	value = parseBool(XMLNode->Attribute(attrib.c_str()));
	return true;
}

bool gkResourceGroupManager::initRTShaderSystem(const gkString& shaderLang, const gkString& shaderCachePath, bool hasFixedCapability)
{
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
	GK_ASSERT( m_materialLoader == 0);

	m_materialLoader = new gkMaterialLoader();

	Ogre::RTShader::ShaderGenerator::initialize();
	
	Ogre::RTShader::ShaderGenerator::getSingleton().setTargetLanguage(shaderLang);
	if (!shaderCachePath.empty())
		Ogre::RTShader::ShaderGenerator::getSingleton().setShaderCachePath(shaderCachePath);

	Ogre::RTShader::ShaderGenerator* shaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
	GK_ASSERT(shaderGenerator);

	if (!hasFixedCapability)
	{
		gkMaterialLoader::createRTSSMaterial("BaseWhite");
		gkMaterialLoader::createRTSSMaterial("BaseWhiteNoLighting", false);
		gkMaterialLoader::createRTSSMaterial("World", false);
	}
	return true;

#else
	return false;
#endif

}

bool gsRayTest::cast(gsRay& ray, const gkString& prop, gsGameObject* excludeObj)
{
	if (prop.empty() && !excludeObj)
		return m_ray->collides(ray);
	else{
		xrayFilter xray(excludeObj?excludeObj->get():0, prop, "");
		gkVector3 from(ray.getOrigin());
		gkVector3 to(ray.getOrigin()+ray.getDirection()*100);
		return m_ray->collides(from,to,xray);
	}
}

int parseScalarArray(liScalarVec &v, const gkString& str, const gkString& delims)
{
	if (str.empty()) return 0;

	liStrVec sv = strSplit(str, delims);
	v.clear(); v.reserve(sv.size());
	for (size_t i = 0; i < sv.size(); i++)
		v.push_back(Ogre::StringConverter::parseReal(sv[i]));

	return v.size();
}

//-- gkString
//from ogre3d StringUtil
liStrVec strSplit( const gkString& str, const gkString& delims, UTuint32 maxSplits)
{
	liStrVec ret;
    // Pre-allocate some space for performance
    ret.reserve(maxSplits ? maxSplits+1 : 10);    // 10 is guessed capacity for most case

    unsigned int numSplits = 0;

    // Use STL methods 
    size_t start, pos;
    start = 0;
    do 
    {
        pos = str.find_first_of(delims, start);
        if (pos == start)
        {
            // Do nothing
            start = pos + 1;
        }
        else if (pos == gkString::npos || (maxSplits && numSplits == maxSplits))
        {
            // Copy the rest of the gkString
            ret.push_back( str.substr(start) );
            break;
        }
        else
        {
            // Copy up to delimiter
            ret.push_back( str.substr(start, pos - start) );
            start = pos + 1;
        }
        // parse up to next real data
        start = str.find_first_not_of(delims, start);
        ++numSplits;

    } while (pos != gkString::npos);



    return ret;
}

int gkTextManager::getTextType(const gkString& name)
{
	int i = 0;
	while (TextItemMap[i].name != 0)
	{
		if (name.find(TextItemMap[i].name) != name.npos)
			return TextItemMap[i].type;
		++i;
	}
	return TT_ANY;

}

void gkGUIManager::loadFont(const gkString& name) {
    gkFont *fnt = gkFontManager::getSingleton().getByName<gkFont>(name);

    if (fnt)
    {
        Rocket::Core::FontDatabase::LoadFontFace((const unsigned char*)fnt->getData(), fnt->getSize());
    }
    else
    {
        Rocket::Core::FontDatabase::LoadFontFace(name.c_str());
    }
}

bool xmlConfig::load(const gkString &fileName)
{
	if (!openSections(fileName, mSections, "config")) {
		gkPrintf("[XML] Can't open file: '%s'", fileName.c_str());
		return false;
	}
	
	mLoaded = true;
	mFileName = fileName;

	return mLoaded;
}

void gkDynamicsWorld::exportBullet(const gkString& fileName)
{
	int maxSerializeBufferSize = 1024 * 1024 * 5;

	btDefaultSerializer*    serializer = new btDefaultSerializer(maxSerializeBufferSize);
	m_dynamicsWorld->serialize(serializer);

	FILE* file = fopen(fileName.c_str(), "wb");
	fwrite(serializer->getBufferPointer(), serializer->getCurrentBufferSize(), 1, file);

	fclose(file);
	delete serializer;
}

bool gkPhysicsController::collidesWith(const gkString& name, gkContactInfo* cpy, bool emptyFilter)
{

	if (!m_localContacts.empty())
	{
		if (name.empty() && emptyFilter)
		{
			if (cpy) *cpy = m_localContacts.at(0);
			return true;
		}


		UTsize i, s;
		gkContactInfo::Array::Pointer p;

		i = 0;
		s = m_localContacts.size();
		p = m_localContacts.ptr();

		while (i < s)
		{
			GK_ASSERT(p[i].collider);
			gkGameObject* gobj = p[i].collider->getObject();

			if (name.find(gobj->getName()) != gkString::npos)
			{
				if (cpy) *cpy = p[i];
				return true;
			}

			++i;
		}
	}

	return false;
}

bool gkPhysicsController::sensorTest(gkGameObject* ob, const gkString& prop, const gkString& material, bool onlyActor, bool testAllMaterials)
{
	GK_ASSERT(ob);

	if (onlyActor)
	{
		if (ob->getProperties().isActor())
		{
			if (prop.empty() && material.empty())
				return true;

			if (!prop.empty())
			{
				if (ob->hasVariable(prop))
					return true;
			}
			else if (!material.empty())
			{
				if (ob->hasSensorMaterial(material, !testAllMaterials))
					return true;
			}
		}
	}
	else
	{
		if (prop.empty() && material.empty())
			return true;

		if (!prop.empty())
		{
			if (ob->hasVariable(prop))
				return true;
		}
		else if (!material.empty())
		{
			if (ob->hasSensorMaterial(material, !testAllMaterials))
				return true;
		}
	}

	return false;
}