ogrepaginglandscaperayscenequery.cpp

使用stl技术,(还没看,是听说的)

/***************************************************************************
OgrePagingLandScapeRaySceneQuery.cpp  -  description
-------------------
begin                : Fri Sep 10 2003
copyright            : (C) 2003 by Jose A Milan
email                : [e-mail]
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Lesser General Public License as        *
*   published by the Free Software Foundation; either version 2 of the    *
*   License, or (at your option) any later version.                       *
*                                                                         *
***************************************************************************/

#include "OgreEntity.h"

#include "OgreVector3.h"
#include "OgreColourValue.h"

#include "OgreSceneManager.h"

#include "OgrePagingLandScapeOptions.h"

#include "OgrePagingLandScapeSceneManager.h"

#include "OgrePagingLandScapeData2DManager.h"

#include "OgrePagingLandScapeRaySceneQuery.h"

namespace Ogre
{

//----------------------------------------------------------------------------
// This function return the vertex interpolated height.
// Supplied by Praetor. Thanks a lot. ]:)
void PagingLandScapeRaySceneQuery::execute(RaySceneQueryListener* listener) 
{ 
    ulong mask = getQueryMask();  
   
    if (!(mask & RSQ_AllTerrain))     
    {
        static WorldFragment worldFrag;
            worldFrag.fragmentType = SceneQuery::WFT_SINGLE_INTERSECTION;

        const Vector3& dir = mRay.getDirection();
        const Vector3& origin = mRay.getOrigin();
         
        // Straight up / down?
        if ((mask & RSQ_Height) || dir == Vector3::UNIT_Y || dir == Vector3::NEGATIVE_UNIT_Y)
        {
            Real height = PagingLandScapeData2DManager::getSingleton().getRealWorldHeight(origin.x, origin.z);

            worldFrag.singleIntersection.x = origin.x;
            worldFrag.singleIntersection.z = origin.z;
            worldFrag.singleIntersection.y = height;

            listener->queryResult(&worldFrag, 
                (worldFrag.singleIntersection - origin).length());       
        }        
        else if (mask & RSQ_MODIF)
        {
            if (static_cast<PagingLandScapeSceneManager*>(mParentSceneMgr)->intersectSegment(
                            origin, origin + (dir * 100000), &worldFrag.singleIntersection, true))
            {
                listener->queryResult(&worldFrag, 
                    (worldFrag.singleIntersection - origin).length());
            }
        }
        else if (mask & RSQ_FirstTerrain)
        {
            Real resFactor = 1;
			// Only bother if the non-default mask has been set
			if((mask & RSQ_1xRes) == 0)
			{
				if(mask & RSQ_2xRes)
                {
					resFactor = 0.5;
				} 
                else if(mask & RSQ_4xRes) 
                {
					resFactor = 0.25;
				} 
                else if(mask & RSQ_8xRes) 
                {
					resFactor = 0.125;
				}
			}

            Vector3 ray = mRay.getOrigin();
	        Real dist = 0;
            ray += mRay.getDirection() * resFactor;
            dist += 1 * resFactor;

            Vector3 land = getHeightAt(ray);
            if(ray.y < land.y)
            {
                worldFrag.singleIntersection = land;
                listener->queryResult(&worldFrag, dist);
            }
        }
        else if (static_cast<PagingLandScapeSceneManager*>(mParentSceneMgr)->intersectSegment(
            origin, origin + (dir * 100000), &worldFrag.singleIntersection))
        {
            listener->queryResult(&worldFrag, 
                (worldFrag.singleIntersection - origin).length());
        }
    }
    else if(mask & RSQ_AllTerrain)
	{
		Real resFactor = 1;
		// Only bother if the non-default mask has been set
		if((mask & RSQ_1xRes) == 0)
		{
			if(mask & RSQ_2xRes)
            {
				resFactor = 0.5;
			} 
            else if(mask & RSQ_4xRes) 
            {
				resFactor = 0.25;
			} 
            else if(mask & RSQ_8xRes) 
            {
				resFactor = 0.125;
			}
		}

        Vector3 ray = mRay.getOrigin();
	    Real dist = 0.0f;
        Vector3 land = getHeightAt(ray);
		while (land.y != -1)
		{
			ray += mRay.getDirection() * resFactor;
			dist += 1 * resFactor;
            if (ray.y < PagingLandScapeData2DManager::getSingleton().getMaxHeight ())
            {
                Vector3 landh = getHeightAt(ray);
                if(ray.y < landh.y)
                {
                    SceneQuery::WorldFragment* frag = new SceneQuery::WorldFragment();
                    fragmentList.push_back(frag);

                    frag->fragmentType = SceneQuery::WFT_SINGLE_INTERSECTION; 
                    frag->singleIntersection = landh;
                    listener->queryResult(frag, dist);
                }
            }
        } 
    }
    else if(mask & RSQ_Entities)// Check for entity contacts
    {
        DefaultRaySceneQuery::execute(listener);
    }
    //DefaultRaySceneQuery::execute(listener);
} 

//----------------------------------------------------------------------------
Vector3 PagingLandScapeRaySceneQuery::getHeightAt(const Vector3& origin)
{

	return Vector3(origin.x, PagingLandScapeData2DManager::getSingleton().getRealWorldHeight(origin.x, origin.z), origin.z);

}

} // namespace Ogre