ogrecollisionmanager.cpp

opcode是功能强大

	void CollisionManager::destroyContext(CollisionContext *cc)
	{
		assert(cc);
		ContextIterator i, iend;
		iend = context_list.end();
		for (i = context_list.begin(); i != iend; ++i)
		{
			if (i->second == cc)
			{
				context_list.erase(i->first);
				delete cc;
				break;
			}
		}
	}

	void CollisionManager::attachShape(ICollisionShape *cs)
	{
		Ogre::String new_id = getResourceID(cs->getName());

		ShapeIterator i = shape_list.find(new_id);
		if (i != shape_list.end())
		{
			// Warning! Shape already exsists.
			// Return doing nothing, if the pointer is valid
			// otherwise: delete the new_id shape from the shape list.
			if(i->second)
			{
				return;
			} else
			{
				shape_list.erase(i->first);
			}
		}

		shape_list.insert(ShapeList::value_type(new_id,cs));
	}

	void CollisionManager::detachShape(ICollisionShape *cs)
	{
		assert(cs);
		ShapeIterator i, iend;
		iend = shape_list.end();
		for (i = shape_list.begin(); i != iend; ++i)
		{
			if (i->second == cs)
			{
				shape_list.erase(i->first);
				break;
			}
		}
	}

	void CollisionManager::destroyShape(ICollisionShape *cs)
	{
		assert(cs);
		ShapeIterator i, iend;
		iend = shape_list.end();
		for (i = shape_list.begin(); i != iend; ++i)
		{
			if (i->second == cs)
			{
				shape_list.erase(i->first);
				delete cs;
				break;
			}
		}
	}

	SceneManager *CollisionManager::getSceneManager(void)
	{
		return mSceneMgr;
	}

	CollisionContext *CollisionManager::getContext(const Ogre::String& name)
	{
		ContextIterator i = context_list.find(name);

		if (i == context_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Error! CollisionContext '" + name + "' not found. Did you create it?", "CollisionManager::getContext");
		}
		return i->second;
	}

	CollisionContext *CollisionManager::getDefaultContext(void)
	{
		if (!default_context)
		{
			default_context = createContext("default");
		}
		return default_context;
	}

	/// Get a resource id string from a path name, or create a unique
	/// resource id string if no name is given.
	Ogre::String CollisionManager::getResourceID(const Ogre::String& name)
	{
		char buf[512];
		if (name == "")
			sprintf(buf,"res%d",(int)unique_id++);
		else
		{
			// cut name to 32 characters and convert illegal chars
			// to underscores
			char c;
			char *str;
			int len = strlen(name.c_str())+1;
			int off = len - sizeof(buf);
			if (off < 0) off = 0;
			len -= off;
			strcpy(buf,&(name[off]));
			str = buf;
			while ((c = *str))
			{
				if ((c=='.')||(c=='/')||(c=='\\')||(c==':'))
					*str='_';
				str++;
			}
		}
		return Ogre::String(buf);
	}

	void CollisionManager::addCollClass(const Ogre::String& cl_name)
	{
		CollClassIterator i = collclass_list.find(cl_name);
		if (i != collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "Error! CollisionClass '" + cl_name + "' already exsist. Check your code.", "CollisionManager::addCollClass");
		}
		collclass_list.insert(CollClassList::value_type(cl_name,collclass_list.size()+1));
	}

	Ogre::String CollisionManager::getCollisionTypeEnum(CollisionType colltype)
	{
		switch(colltype)
		{
		case COLLTYPE_IGNORE:
			return "COLLTYPE_IGNORE";
			break;
		case COLLTYPE_QUICK:
			return "COLLTYPE_QUICK";
			break;
		case COLLTYPE_CONTACT:
			return "COLLTYPE_CONTACT";
			break;
		case COLLTYPE_BBOX:
			return "COLLTYPE_BBOX";
			break;
		case COLLTYPE_EXACT:
			return "COLLTYPE_EXACT";
			break;
		default:
			return "COLLTYPE_UNKNOWN";
			break;
		}
	}
	/// Important: Collision types MUST be bidirectional, if one object
	/// checks collision with another object, the collision type must
	/// be identical as if the check would be in the other direction.
	/// Due to the implementation of the top-level-collision check,
	/// one of the 2 checks may return false, although a collision may
	/// take place!
	void CollisionManager::addCollType(const Ogre::String& cl1, const Ogre::String& cl2, CollisionType collType)
	{
		// Retrieve the first collision class
		CollClassIterator i = collclass_list.find(cl1);
		if (i == collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionClass '" +  cl1 + "' not found! Did you call CollisionManager::addCollClass? If you did, check the names of your collisionclasses.", "CollisionManager::addCollType");
		}
		int cc1 = i->second;

		// Retrieve the second collision class
		i = collclass_list.find(cl2);
		if (i == collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionClass '" +  cl2 + "' not found! Did you call CollisionManager::addCollClass? If you did, check the names of your collisionclasses.", "CollisionManager::addCollType");
		}
		int cc2 = i->second;

		int key = 0;
		get_merged_id(cc1, cc2, key);
		
		// This key shouldn't exsist, but check anyway.
		CollTypeIterator h = colltype_table.find(key);
		if (h != colltype_table.end())
		{
			OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "Error! CollisionType '" + cl1 + "->" + cl2 + "' already exsist. Check your code.", "CollisionManager::addCollType");
		}
		colltype_table.insert(CollTypeList::value_type(key,collType));
	}

	CollisionClass CollisionManager::queryCollClass(const Ogre::String& cc)
	{
		CollClassIterator i = collclass_list.find(cc);

		if (i == collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionClass '" +  cc + "' not found!", "CollisionManager::queryCollClass");
		}

		return i->second;
	}

	CollisionType CollisionManager::queryCollType(CollisionClass cc1, CollisionClass cc2)
	{

		// check for CollClass override cases
		if ((cc1 == COLLTYPE_ALWAYS_IGNORE) || (cc2 == COLLTYPE_ALWAYS_IGNORE))
		{
			return COLLTYPE_IGNORE;
		}
		else if ((cc1 == COLLTYPE_ALWAYS_QUICK) || (cc2 == COLLTYPE_ALWAYS_QUICK))
		{
			return COLLTYPE_QUICK;
		}
		else if ((cc1 == COLLTYPE_ALWAYS_CONTACT) || (cc2 == COLLTYPE_ALWAYS_CONTACT))
		{
			return COLLTYPE_CONTACT;
		}
		else if ((cc1 == COLLTYPE_ALWAYS_EXACT) || (cc2 == COLLTYPE_ALWAYS_EXACT))
		{
			return COLLTYPE_EXACT;
		}

		int key = 0;
		get_merged_id(cc1, cc2, key);
		CollTypeIterator i = colltype_table.find(key);
		if (i == colltype_table.end())
		{
			// Return a default, in case the user don't want to define every possible collision type.
			return COLLTYPE_IGNORE;
			//OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionType '" + getCollisionTypeEnum(colltype_table[key]) + "' not found!", "CollisionManager::queryCollType");
		}
		return colltype_table[key];
	}

	CollisionType CollisionManager::queryCollType(const Ogre::String& s_cc1, const Ogre::String& s_cc2)
	{
		CollClassIterator i = collclass_list.find(s_cc1);
		if (i == collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionClass '" +  s_cc1 + "' not found!", "CollisionManager::queryCollType");
		}
		CollisionClass class1 = i->second;
		i = collclass_list.find(s_cc2);
		if (i == collclass_list.end())
		{
			OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "CollisionClass '" +  s_cc2 + "' not found!", "CollisionManager::queryCollType");
		}
		CollisionClass class2 = i->second;

		return queryCollType(class1,class2);
	}

};