示例#1
0
    bool Collidable::Collides(Collidable* inputPtr, CollisionResponseFunc func, CollisionFeedback *feedbackPtr)
    {
        CollisionFeedback defaultFeedback;
        if( feedbackPtr == 0 )
            feedbackPtr = &defaultFeedback;

        Collidable *invokingPtr = this;
        if( this->GetCOType() > inputPtr->GetCOType() )
        {
            invokingPtr = inputPtr;
            inputPtr = this;
        }

        feedbackPtr->collisionPair.collidablePtrs[0] = invokingPtr;
        feedbackPtr->collisionPair.collidablePtrs[1] = inputPtr;

        if( CollisionLibrary::GetInstance().GetPairCollisionFunc( invokingPtr->GetCOType(), inputPtr->GetCOType())(feedbackPtr) )
        {
            if( func != 0 )
                func( feedbackPtr );

            return true;
        }

        return false;
    }	
示例#2
0
			void Activate(unsigned int aId)
			{
				const CollidableTemplate &collidabletemplate = Database::collidabletemplate.Get(aId);
				Collidable *collidable = new Collidable(collidabletemplate, aId);
				Database::collidable.Put(aId, collidable);
				collidable->AddToWorld();
			}
void Asteroid::ResolveCollision(Collidable& collidable)
{
   if (collidable.GetCollidableType() == CollidableType_Asteroid)
   {
      dynamic_cast<Asteroid&>(collidable).ResolveCollision(*this);
   }
   else if (collidable.GetCollidableType() == CollidableType_Shot)
   {
      dynamic_cast<Shot&>(collidable).ResolveCollision(*this);
   }
   else if (collidable.GetCollidableType() == CollidableType_Player)
   {
      dynamic_cast<Player&>(collidable).ResolveCollision(*this);
   }
}
示例#4
0
文件: OcTree.cpp 项目: sindney/fury3d
	void OcTree::WalkScene(const Collidable &collider, const FilterFunc &filterFunc) const
	{
		using TreeNodePair = std::pair<bool, OcTreeNode::Ptr>;

		std::deque<TreeNodePair> possiblePairs;
		possiblePairs.push_back(std::make_pair(false, m_Root));

		while (!possiblePairs.empty())
		{
			// pop next possible node.
			TreeNodePair currentPair = possiblePairs.back();
			possiblePairs.pop_back();

			// procced
			bool tested = currentPair.first;
			OcTreeNode::Ptr treeNode = currentPair.second;

			if (treeNode->GetTotalSceneNodeCount() > 0)
			{
				Side result = tested ? Side::IN : collider.IsInside(treeNode->GetAABB());

				if (result != Side::OUT)
				{
					if (result == Side::IN)
						tested = true;

					// test currentTreeNode's belonging sceneNodes
					int sceneNodeCount = treeNode->GetSceneNodeCount();
					for (int i = 0; i < sceneNodeCount; i++)
					{
						SceneNode::Ptr sceneNode = treeNode->GetSceneNodeAt(i);
						if (tested || collider.IsInsideFast(sceneNode->GetWorldAABB()))
							filterFunc(sceneNode);
					}

					// add currentTreeNode's childs to possiblePairs vector.
					for (int i = 0; i < 8; i++)
					{
						OcTreeNode::Ptr childNode = treeNode->GetChildAt(i);
						if (childNode != nullptr && childNode->GetTotalSceneNodeCount() > 0)
							possiblePairs.push_back(std::make_pair(tested, childNode));
					}
				}
			}
		}
	}
void buildTestScene1()
{
    float w,h,f;
    w = 9.0f;
    h = 6.0f;
    f = 6.0f;

    cam = PinholeCamera(Vec3(0.0f,0.0f,0.0f), Vec3(0.0f,0.0f,-5.0f), Vec3(0.0f,1.0f,0.0f),f,w,h);
    buffer = RayBuffer();
    PointLight *l;
    l = new PointLight(Vec3(1.0f,0.0f,1.0f),Col(1.0f,1.0f,1.0f), 15, 1, 1, 1);
    lights.addLight(*l);
    l = new PointLight(Vec3(-3.0f,3.0f,-1.0f),Col(1.0f,1.0f,1.0f), 10, 1, 1, 1);
    lights.addLight(*l);
    l = new PointLight(Vec3(2.0f,0.0f,0.0f),Col(0.30f,0.30f,0.30f), 4, 1, 1, 1);
    lights.addLight(*l);



    std::vector<Collidable *> *vec = new std::vector<Collidable *>();

    Collidable *c;

    c = new Sphere(Vec3(0.0f, .5f, -4.20f), 1.0f, Material(1));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Sphere(Vec3(-0.0f, -1.0f, -3.0f), 0.5f, Material(2));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Sphere(Vec3(-0.0f, 0.00f, -0.50f), 0.1f, Material(3));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Sphere(Vec3(0.7f, 0.30f, -2.5f), 0.5f, Material(4));
    c->precomputeBounds();
    //vec->push_back(c);
    c = new Sphere(Vec3(02.0f, 0.00f, -5.0f), 0.70f, Material(4));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Sphere(Vec3(0.9f, 0.00f, -02.50f), 0.50f, Material(7));
    c->precomputeBounds();
    vec->push_back(c);


    sceneTree.buildTreeStart(*vec);


    sceneTree.isLeaf = true;
    sceneTree.items = vec;
    sceneTree.xMin = -100;
    sceneTree.xMax = 100;
    sceneTree.yMin = -100;
    sceneTree.yMax = 100;
    sceneTree.zMin = -100;
    sceneTree.zMax = 100;

    sceneTree.axis = -1;
    sceneTree.depth = 0;
    sceneTree.id = 55;

}
示例#6
0
bool Collidable::collides_with(Collidable &c)
{
	if (c.collidable_get_type() == COLLIDABLE_POINT) {
		General::Point<float> pos;
		c.collidable_get_position(pos);
		return collides_with_point(pos);
	}
	else if (c.collidable_get_type() == COLLIDABLE_BOX) {
		General::Point<float> pos;
		General::Point<int> offset;
		General::Size<int> size;
		c.collidable_get_position(pos);
		c.collidable_get_box(offset, size);
		return collides_with_box(pos, offset, size);
	}
	else { // COLLIDABLE_BONES
		General::Point<float> pos;
		std::vector<Bones::Bone> bones;
		c.collidable_get_position(pos);
		c.collidable_get_bones(bones);
		return collides_with_bones(pos, bones);
	}

	// Should never get here
	General::log_message("IMPOSSIBLE CONDITION: collides_with unknown");
	return false;
}
示例#7
0
bool8_t Collidable::IsColliding(Collidable other) {
	bool right = other.GetPosition().x > GetPosition().x + GetWidth();
	bool left = other.GetPosition().x + other.GetWidth() < GetPosition().x;
	bool up = other.GetPosition().y + other.GetHeight() < GetPosition().y;
	bool down = other.GetPosition().y > GetPosition().y + GetHeight();

	return right || left || up || down;
}
示例#8
0
bool Collision::Check(const Collidable& a, const Collidable& b, Vector *v)
{
    if((a.collisionBits & b.collisionBits) == 0)
        return false;

    switch(a.getShape())
    {
        case COLL_AABB:
            switch(b.getShape())
            {
                case COLL_AABB:     return AABB_vs_AABB((const AABB&)a, (const AABB&)b, v);
                case COLL_CIRCLE:   return AABB_vs_Circle((const AABB&)a, (const Circle&)b, v);
                case COLL_LINE:     return AABB_vs_Line((const AABB&)a, (const Line&)b, v);
            }
            break;

        case COLL_CIRCLE:
            switch(b.getShape())
            {
                case COLL_AABB:     return AABB_vs_Circle((const AABB&)b, (const Circle&)a, v);
                case COLL_CIRCLE:   return Circle_vs_Circle((const Circle&)a, (const Circle&)b, v);
                case COLL_LINE:     return Circle_vs_Line((const Circle&)a, (const Line&)b, v);
            }
            break;

        case COLL_LINE:
            switch(b.getShape())
            {
                case COLL_AABB:     return AABB_vs_Line((const AABB&)b, (const Line&)a, v);
                case COLL_CIRCLE:   return Circle_vs_Line((const Circle&)b, (const Line&)a, v);
                case COLL_LINE:     return Line_vs_Line((const Line&)a, (const Line&)b, v);
            }
            break;
    }

    assert(false);
    return false;
}
示例#9
0
bool CollisionHandler::checkCollisions(Collidable & c)
{
	for (int i = 0; i < NUM_TYPES; i++)
	{
		List<Collidable>::Iterator iter = collidables[i].getIterator();
		while(iter.hasNext())
		{
			Collidable * c2 = iter.next();
			if (&c != c2 && c.intersects(c2))
				return true;
		}
	}

	return false;
}
示例#10
0
	Actor* ActorFactory::CreateActor(tinyxml2::XMLElement* actorNode, std::string sourceName)
	{
		Actor* pActor = new Actor;
		pActor->SetId(GetNextActorId());
		pActor->SetSource(sourceName);


		tinyxml2::XMLElement* propertiesNode = actorNode->FirstChildElement("Properties");
		if (!propertiesNode)
		{
			LOG("Actor Factory", "Failed to load actor properties");
			return NULL;
		}
		else
		{
			if (!pActor->Init(propertiesNode))
			{
				LOG("Actor Factory", "Actor properties node loading failed");
				return false;
			}
		}

		//--------------------------------------------------------

		tinyxml2::XMLElement* componentsNode = actorNode->FirstChildElement("Components");
		if (!componentsNode)
		{
			LOG("Actor Factory", "Failed to load actor components");
			return NULL;
		}
		else
		{
			tinyxml2::XMLElement* rendCompNode = componentsNode->FirstChildElement("RenderComponent");
			if (rendCompNode)
			{
				Renderable*pRend = new Renderable(pActor);

				if (!pRend->Init(rendCompNode))
				{
					LOG("Actor Factory", "Renderable component loading failed");
					return false;
				}

				pActor->AddComponent(pRend);
			}
				
			tinyxml2::XMLElement* moveCompNode = componentsNode->FirstChildElement("MovableComponent");
			if (moveCompNode)
			{

				Movable* pMoveComp = new Movable(pActor);

				if (!pMoveComp->Init(moveCompNode))
				{
					LOG("Actor Factory", "Movable component loading failed");
					return false;
				}

				pActor->AddComponent(pMoveComp);
			}

			tinyxml2::XMLElement* colCompNode = componentsNode->FirstChildElement("CollisionComponent");
			if (colCompNode)
			{
				//std::sting type = colCompNode->FirstChildElement("Type")->Attribute("value");
				//if (type == "BOX")
				//{
				//colComp = new Rectangle(pActor);
				//}
				//else if (type == "BOX")
				//{
				//	colComp = new Rectangle(pActor);
				//}

				Collidable* pColComp;
				pColComp = new Rectangle(pActor);

				if (!pColComp->Init(moveCompNode))
				{
					LOG("Actor Factory", "Rectangel collidable component loading failed");
					return false;
				}

				pActor->AddComponent(pColComp);
			}
		}

		g_pBGL->GetLevelManager()->InsertActor(pActor);

		return pActor;
	}
void buildTestScene2()
{
    float w,h,f;
    w = 9.0f;
    h = 6.0f;
    f = 3.0f;

    float con = 2;

    cam = PinholeCamera(Vec3(0.0f,0.0f,0.0f), Vec3(0.0f,0.0f,-5.0f), Vec3(0.0f,1.0f,0.0f),f,w,h);
    buffer = RayBuffer();
    PointLight *l;
    l = new PointLight(Vec3(0.0f, con-0.10f, -con),Col(1.0f,1.0f,1.0f), 15, 1, 1, 1);
    lights.addLight(*l);


    std::vector<Collidable *> *vec = new std::vector<Collidable *>();

    Collidable *c;

    c = new Sphere(Vec3(0.0f, 0.0f, -2.0f), 0.50f, Material(3));
    c->precomputeBounds();
    vec->push_back(c);

    c = new Sphere(Vec3(-1.0f, -1.0f, -3.0f), 1.0f, Material(1));
    c->precomputeBounds();
    vec->push_back(c);


    //left
    c = new Triangle( Vec3(-con,-con,0), Vec3(-con,-con,-2*con), Vec3(-con,con,0), Material(8));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(-con,-con,-2*con), Vec3(-con,con,-2*con), Vec3(-con,con,0), Material(8));
    c->precomputeBounds();
    vec->push_back(c);
    //right
    c = new Triangle( Vec3(con,-con,0), Vec3(con,con,0), Vec3(con,-con,-2*con), Material(9));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(con,-con,-2*con), Vec3(con,con,0), Vec3(con,con,-2*con), Material(9));
    c->precomputeBounds();
    vec->push_back(c);
    //back
    c = new Triangle( Vec3(-con,con,-2*con), Vec3(-con,-con,-2*con), Vec3(con,-con,-2*con), Material(10));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(-con,con,-2*con), Vec3(con,-con,-2*con), Vec3(con,con,-2*con), Material(10));
    c->precomputeBounds();
    vec->push_back(c);
    //bottom
    c = new Triangle( Vec3(-con,-con,0), Vec3(con,-con,0), Vec3(con,-con,-2*con), Material(10));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(-con,-con,-2*con), Vec3(-con,-con,0), Vec3(con,-con,-2*con), Material(10));
    c->precomputeBounds();
    vec->push_back(c);
    //top
    c = new Triangle( Vec3(-con,con,0), Vec3(con,con,-2*con), Vec3(con,con,0), Material(10));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(-con,con,-2*con), Vec3(con,con,-2*con), Vec3(-con,con,0), Material(10));
    c->precomputeBounds();
    vec->push_back(c);


    //front
    c = new Triangle( Vec3(-con,con,con), Vec3(con,-con,con), Vec3(-con,-con,con), Material(2));
    c->precomputeBounds();
    vec->push_back(c);
    c = new Triangle( Vec3(-con,con,con), Vec3(con,con,con), Vec3(con,-con,con), Material(2));
    c->precomputeBounds();
    vec->push_back(c);


    sceneTree.buildTreeStart(*vec);


    sceneTree.isLeaf = true;
    sceneTree.items = vec;
    sceneTree.xMin = -100;
    sceneTree.xMax = 100;
    sceneTree.yMin = -100;
    sceneTree.yMax = 100;
    sceneTree.zMin = -100;
    sceneTree.zMax = 100;

    sceneTree.axis = -1;
    sceneTree.depth = 0;
    sceneTree.id = 55;

}
示例#12
0
bool Sprite::doesCollideWith(const Collidable& other) const
{
	return intersecting(this->getBoundingRect(), other.getBoundingRect());
}
bool Collidable::collide(Collidable& b) {
    return Collision::check(getBoundingBox(), b.getBoundingBox());
}
static bool beamCheckCollision( QVector pos, float len, const Collidable &un )
{
    return (un.GetPosition()-pos).MagnitudeSquared() <= len*len+2*len*un.radius+un.radius*un.radius;
}
示例#15
0
文件: Pong.cpp 项目: DomenicP/Pong
bool Pong::areColliding(const Collidable &a, const Collidable &b) const
{
	return a.getRight() >= b.getLeft() && a.getLeft() <= b.getRight()
		&& a.getBottom() >= b.getTop() && a.getTop() <= b.getBottom();
}
示例#16
0
	bool AxisAlignedBox::Intersect(const Collidable& collidable)const
	{ return collidable.Intersect(*this); }