C++ ModelContainer类代码示例

int WIN_FFLL_API ffll_load_fcl_file(int model_idx, const char* file)
{
	ModelContainer* container = get_model(model_idx);

	// we have a pointer to the container, so any modifications we
	// make will be in the list. If we used the [] operator here,
	// we'd get a COPY of the model and any changes wouldn't be permanent.

	// perform initialization
	container->init();

	// load the FCL file passed in
	if (container->model->load_from_fcl_file(file))
 		return -1;

	return model_idx;

}; // end ffll_load_fcl_file()

    float MapTree::getIntersectionTime(const Ray& pRay, float pMaxDist, bool pStopAtFirstHit)
    {
        double  firstDistance = inf();

        const IT end = iTree->endRayIntersection();
        IT obj = iTree->beginRayIntersection(pRay, pMaxDist);

        for ( ;obj != end; ++obj)                           // (preincrement is *much* faster than postincrement!)
        {
            /*
            Call your accurate intersection test here.  It is guaranteed
            that the ray hits the bounding box of obj.  (*obj) has type T,
            so you can call methods directly using the "->" operator.
            */
            ModelContainer *model = (ModelContainer *) (*obj);

            float t = model->getIntersectionTime(pRay, pStopAtFirstHit, pMaxDist);

            // just for visual debugging with an external debug class
            #ifdef _DEBUG_VMAPS
            if(gCount3 == gCount1)
            {
                AABox testBox;
                testBox = model->getAABoxBounds();
                gBoxArray.append(testBox);
            }
            ++gCount3;
            #endif
            if(t > 0 && t < inf())
            {
                obj.markBreakNode();
                if(firstDistance > t && pMaxDist >= t)
                {
                    firstDistance = t;
                    if(pStopAtFirstHit) break;
                }
            }
        }
        return firstDistance;
    }

	bool MapTree::isOutDoors(const Vector3& pos)
	{
		Vector3 dir = Vector3(0,-1,0);
		Ray ray = Ray::fromOriginAndDirection(pos, dir);   // direction with length of 1
		unsigned int flags;

		AABSPTree<ModelContainer*>::RayIntersectionIterator MITR;
		AABSPTree<ModelContainer*>::RayIntersectionIterator MITREND;
		RayIntersectionIterator<TreeNode, SubModel> SMITR;
		RayIntersectionIterator<TreeNode, SubModel> SMITREND;
		ModelContainer * mc;
		SubModel * sm;

		MITR = iTree->beginRayIntersection( ray, MAX_CAN_FALL_DISTANCE );
		MITREND = iTree->endRayIntersection();

		for(; MITR != MITREND; ++MITR)
		{
			mc = ((ModelContainer*)*MITR);
			
			Ray relativeRay = Ray::fromOriginAndDirection(ray.origin - mc->getBasePosition(), ray.direction);
			SMITR = mc->beginRayIntersection( relativeRay, MAX_CAN_FALL_DISTANCE );
			SMITREND = mc->endRayIntersection();

			for( ; SMITR != SMITREND; ++SMITR )
			{
				sm = ((SubModel*)&(*SMITR));
#if 0
				if( sm->getIndoorFlag() != 0 )
				{
					unsigned int i = sm->getIndoorFlag();
					printf("=========================================================\n");
					printf("Model indoor flags: %u\n", sm->getIndoorFlag());
					unsigned int z, b;
					for(z = 1, b = 1; b < 32;)
					{
						if(i & z)
							printf("   Bit %u (0x%.8X or %u) is set!\n", b, z, z);

						z <<= 1;
						b+=1;
					}
					printf("=========================================================\n");
				}
#else
				flags = sm->getIndoorFlag();
				if( flags != 0 )
				{
					/* From WoWdev:
					 Flag 	 Meaning
					0x1 	Always set
					0x4 	Has vertex colors (MOCV chunk)
					0x8 	Outdoor
					0x200 	Has lights (MOLR chunk)
					0x800 	Has doodads (MODR chunk)
					0x1000 	Has water (MLIQ chunk)
					0x2000 	Indoor
					0x40000 	Show skybox

					**********************

					0x8000 seems to be set in the areas in citys (while it has the indoor flag, its not
					an indoor area

					*/

					if( !(flags & 0x8) )
						return false;
				}
#endif
			}
		}

		return true;
	}

 //=================================================================
 void getBounds(const ModelContainer& pMc, G3D::AABox& pAABox)
 {
     pAABox = pMc.getAABoxBounds();
 }

 /**
 Functions to use ModelContainer with a AABSPTree
 */
 size_t hashCode(const ModelContainer& pMc)
 {
     return (pMc.getBasePosition() * pMc.getNTriangles()).hashCode();
 }

    bool operator==(const ModelContainer& pMc1, const ModelContainer& pMc2)
    {
        bool result = false;
        if(pMc1.getNSubModel() == pMc2.getNSubModel() && pMc1.getAABoxBounds() == pMc2.getAABoxBounds())
        {
            if(pMc1.getNNodes() == pMc2.getNNodes() && pMc1.getNTriangles() == pMc2.getNTriangles() && pMc1.getBasePosition() == pMc2.getBasePosition())
            {
                result = true;
                for(unsigned int i=0; i<pMc2.getNSubModel(); ++i)
                {
                    SubModel sm1 = pMc2.getSubModel(i);
                    SubModel sm2 = pMc1.getSubModel(i);
                    result = (sm1 == sm2);
                    if(!result) break;
                }
                if(result)
                {
                    for(unsigned int i=0; i<pMc2.getNTriangles(); ++i)
                    {
                        TriangleBox t1=pMc2.getTriangle(i);
                        TriangleBox t2=pMc1.getTriangle(i);
                        result = (t1 == t2);
                        if(!result) break;
                    }
                }
                if(result)
                {
                    for(unsigned int i=0; i<pMc2.getNNodes(); ++i)
                    {
                        TreeNode tn1=pMc2.getTreeNode(i);
                        TreeNode tn2=pMc1.getTreeNode(i);
                        result = (tn1 == tn2);
                        if(!result) break;
                    }
                }
            }
        }

        return(result);
    }