/****************************************************************************
Copyright (c) 2011-2013,WebJet Business Division,CYOU
 
http://www.genesis-3d.com.cn

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "stdneb.h"
#include "math/intersection.h"
#include "apputil/intersectutil.h"
#include "graphicfeature/components/cameracomponent.h"
#include "graphicfeature/graphicsfeature.h"
#include "graphicfeature/components/meshrendercomponent.h"
#include "appframework/actormanager.h"
#include "vegetation/VegetationObejct.h"
#include "vegetation/InstanceMap.h"
#include "graphicfeature/components/lightcomponent.h"
namespace AppUtil
{
	using namespace App;
	using namespace Math;
	using namespace Resources;
	using namespace RenderBase;

	//------------------------------------------------------------------------
	bool 
	IntersectUtil::ComputeDefaultWorldMouseRay( const App::Actor* cameraActor, const Math::float2& mouseScreenPos , Math::Ray& rayout )
	{
		if ( !GraphicsFeature::HasInstance() )
		{
			return false;
		}
		if (NULL == cameraActor)
		{
			if ( GraphicsFeature::HasInstance() )
			{
				cameraActor = GraphicsFeature::Instance()->GetDefaultCameraActor().get_unsafe();
			}
			else
			{
				return false;
			}

		}
		// get the attribute of camera
		if ( !cameraActor)
		{
			return false;
		}

		GPtr<CameraComponent> pCamera = cameraActor->FindComponent<CameraComponent>();
		n_assert(pCamera.isvalid());

		Math::matrix44 invViewM = pCamera->GetActorTransform();

		float nearWidth, nearHeight, nearPlaneDis, farPlaneDis;
		pCamera->GetProjParam( &nearWidth , &nearHeight , &nearPlaneDis , &farPlaneDis );

		rayout = AppUtil::MouseRayUtil::ComputeWorldMouseRay(mouseScreenPos, invViewM, nearWidth, nearHeight, nearPlaneDis, pCamera->GetViewType());
		return true;
	}
	//------------------------------------------------------------------------
	bool 
	IntersectUtil::ComputeDefaultWorldMouseLine(const App::Actor* cameraActor,const Math::float2& mouseScreenPos , Math::line& lineout, float length)
	{
		if ( !GraphicsFeature::HasInstance() )
		{
			return false;
		}

		if (NULL == cameraActor)
		{
			cameraActor = GraphicsFeature::Instance()->GetDefaultCameraActor().get_unsafe();
		}
		// get the attribute of camera
		if ( !cameraActor)
		{
			return false;
		}

		const GPtr<Component> obj = cameraActor->FindComponent( CameraComponent::RTTI );
		if( !obj.isvalid() )
			return false;
		GPtr<CameraComponent> pCamera = obj.downcast<CameraComponent>();

		const Math::matrix44& viewM = pCamera->GetViewMat();
		Math::matrix44 invViewM = Math::matrix44::inverse(viewM);

		const Math::matrix44& projM = pCamera->GetProjMat();
		Math::matrix44 invProjM = Math::matrix44::inverse(projM);

		float nearWidth, nearHeight, nearPlaneDis, farPlaneDis;
		pCamera->GetProjParam( &nearWidth , &nearHeight , &nearPlaneDis , &farPlaneDis );
		lineout = AppUtil::MouseRayUtil::ComputeWorldMouseRay(mouseScreenPos, length, invViewM, invProjM, nearPlaneDis);
		return true;
	}
	//------------------------------------------------------------------------
	// @Todo: use spatial tree to manage actor 
	bool 
	IntersectUtil::IntersectWorld( const Math::Ray& worldRay, SelectMark selectMask, bool onlyUseBBox, IntersectResultList& result , Math::scalar fTolerance /* = N_TINY */,IntersectTriangle *triAngle /* = NULL */)
	{
		if ( !ActorManager::HasInstance() )
		{
			return false;
		}

		ActorManager* pActorMgr = ActorManager::Instance();
		
		IndexT intersectCount = 0;

		SizeT actorSize = pActorMgr->GetActiveActorCount();
		for ( IndexT i = 0; i < actorSize; ++i )
		{
			const GPtr<Actor>& pActor = pActorMgr->GetActiveActor(i);
			n_assert( pActor.isvalid() );
			scalar fout;

			if( IntersectActor(worldRay,  pActor, selectMask, onlyUseBBox, fout, fTolerance, triAngle ) )
			{
				++intersectCount;
				result.Append( IntersectResult(pActor, fout ) );
			}
		}

		return intersectCount != 0 ;
	}

	//------------------------------------------------------------------------
	bool 
	IntersectUtil::IntersectActor(const Math::Ray& worldRay, const GPtr<App::Actor>& actor, SelectMark selectMask, bool onlyUseBBox, Math::scalar& fout, Math::scalar fTolerance /* = N_TINY */,IntersectTriangle *triAngle /* = NULL */)
	{
		if ( !actor.isvalid() )
		{
			return false;
		}
		else if (0 == (actor->GetCullMark() & selectMask))
		{
			return false;
		}

		const Math::bbox& worldBB = actor->GetWorldBoundingBox();

		scalar fOut1, fOut2;
		if ( Math::Intersection::Intersect(worldRay, worldBB, fOut1, fOut2 ) )
		{
			if ( fOut1 < 0.0f && fOut2 < 0.0f )
			{
				return false;	//	all behind the ray
			}

			fout = N_INFINITY;
			if ( fOut1 >= 0.0f )
			{
				fout = n_min( fOut1, fout );
			}
			if ( fOut2 >= 0.0f )
			{
				fout = n_min( fOut2, fout );
			}

			if ( onlyUseBBox )
			{
				return true;
			}
			else
			{
				const GPtr<Component> obj = actor->FindComponent( MeshRenderComponent::RTTI );
				const GPtr<Component> terrainObj = actor->FindComponent( TerrainRenderComponent::RTTI );
				const GPtr<Component> lightObj = actor->FindComponent( LightComponent::RTTI );
				const GPtr<Component> cameraObj = actor->FindComponent( CameraComponent::RTTI );

				// some code add meshrendercomponent to terrain. Ignore this , only picked it up by terrain
				if ( obj.isvalid() && !terrainObj )
				{
					GPtr<MeshRenderComponent> pMeshComponent = obj.downcast<MeshRenderComponent>();
					const GPtr<PrimitiveResInfo>& pri = pMeshComponent->GetPrimtiveResInfo();
					if (!pri||!pri->GetRes())
					{
						return false;
					}
					const GPtr<Resources::MeshRes>& mesh = pri->GetRes().downcast<Resources::MeshRes>();
						

					const matrix44& worldM = actor->GetWorldTransform();
					matrix44 invWorldM = Math::matrix44::inverse( worldM );

					Ray localRay = worldRay.Tramsform( invWorldM );
					
					scalar meshOut = 0;
					if ( IntersectMesh(localRay, mesh, meshOut, fTolerance, triAngle ) )
					{
						// transform meshOut to world space
						if ( n_fequal(meshOut, 0.0, N_TINY  ) )
						{
							fout = n_max(meshOut,0.0f);
						}
						else if( meshOut > 0.0f )
						{
							// meshOut
							float3 localInterPoint = localRay.PointAt( meshOut );
							float3 worldInterPoint = localInterPoint.transformPoint( worldM );

							float3 pdiff = worldInterPoint - worldRay.Start();
							scalar l = pdiff.length();
							fout = l ;
						}
						else
						{
							return false;	//	must not be impl
						}

						return true;
					}
					else
					{
						return false;
					}
				}
				//else if		like terrain component
				else if (terrainObj.isvalid())
				{
					GPtr<TerrainRenderComponent> pTRComponent = terrainObj.downcast<TerrainRenderComponent>();
					const matrix44& worldM = actor->GetWorldTransform();
					matrix44 invWorldM = Math::matrix44::inverse( worldM );
					Ray localRay = worldRay.Tramsform( invWorldM );

					scalar meshOut = 0;
					if ( IntersectTerrain(localRay, pTRComponent, meshOut, fTolerance, triAngle ) )
					{
						// transform meshOut to world space
						if ( n_fequal(meshOut, 0.0, N_TINY  ) )
						{
							fout = n_max(meshOut,0.0f);
						}
						else if( meshOut > 0.0f )
						{
							// meshOut
							float3 localInterPoint = localRay.PointAt( meshOut );
							float3 worldInterPoint = localInterPoint.transformPoint( worldM );

							float3 pdiff = worldInterPoint - worldRay.Start();
							scalar l = pdiff.length();
							fout = l ;
						}
						else
						{
							return false;	//	must not be impl
						}

						return true;
					}
					else
					{
						return false;
					}
				}
				// for the actor with indicator(like light and camera), when it don't add rendercomponent, 
				// for the purpose of picking indicator precisely, recalculate the picking bounding box.
				else if( (cameraObj.isvalid()||lightObj.isvalid())  && !obj && !terrainObj )
				{
					Math::bbox worldBB = actor->GetLocalBoundingBox();
					Math::quaternion rotQuat = actor->GetWorldRotation();
					Math::vector vScale(1.f,1.f,1.f);
					Math::vector vPos = actor->GetWorldPosition();

					const Math::matrix44 mat44 = Math::matrix44::transformation(vScale,rotQuat,vPos);
					worldBB.transform(mat44);

					scalar fOut1, fOut2;
					if ( Math::Intersection::Intersect(worldRay, worldBB, fOut1, fOut2 ) )
					{
						if ( fOut1 < 0.0f && fOut2 < 0.0f )
						{
							return false;	//	all behind the ray
						}

						fout = N_INFINITY;
						if ( fOut1 >= 0.0f )
						{
							fout = n_min( fOut1, fout );
						}
						if ( fOut2 >= 0.0f )
						{
							fout = n_min( fOut2, fout );
						}

						return true;
					}else
					{
						return false;
					}
				}
				else
				{
					return true;
				}
			}
		}
		return false;
	}

	//------------------------------------------------------------------------
	// get the point in the world space that ray intersects with terrain.
	bool 
	IntersectUtil::IntersectTerrainPos( const Math::Ray& worldRay,  const GPtr<App::Actor>& actor,
		App::LayerID selectLayers, App::TagID selectTags , bool onlyUseBBox, Math::scalar& fout,
		Math::float3& pos, Math::scalar fTolerance, IntersectTriangle*triAngle /*= NULL*/ )
	{
		if ( !actor.isvalid() )
		{
			return false;
		}

		if (actor->GetLayerID() == 0)
		{
		}
		else
		{
			if ( (actor->GetLayerID() & selectLayers) == 0 )
			{
				return false;
			}
		}
		

		if ( onlyUseBBox )
		{
			return true;
		}
		else
		{
			const GPtr<Component> terrainObj = actor->FindComponent( TerrainRenderComponent::RTTI );
			
			if (terrainObj.isvalid())
			{
				GPtr<TerrainRenderComponent> pTRComponent = terrainObj.downcast<TerrainRenderComponent>();
				const matrix44& worldM = actor->GetWorldTransform();
				matrix44 invWorldM = Math::matrix44::inverse( worldM );
				Ray localRay = worldRay.Tramsform( invWorldM );

				scalar meshOut = 0;
				if ( IntersectTerrain(localRay, pTRComponent, meshOut, fTolerance, triAngle ) )
				{
					if ( n_fequal(meshOut, 0.0, N_TINY  ) )
					{
						fout = n_max(meshOut,0.0f);
					}
					else if( meshOut > 0.0f )
					{
						// meshOut
						float3 localInterPoint = localRay.PointAt( meshOut );
						float3 worldInterPoint = localInterPoint.transformPoint( worldM );
						pos = worldInterPoint;
					}
					else
					{
						return false;	//	must not be impl
					}

					return true;
				}
				else
				{
					return false;
				}
			}
			else
			{
				return true;
			}
			
		}
		
		return false;
	}
	//------------------------------------------------------------------------
	bool IntersectUtil::IntersectTerrainNode_Visbile(const Math::Ray& localRay, RenderBase::PrimitiveTopology::Code type, App::TerrainNode* node, Math::scalar& fout, Math::scalar fTolerance, IntersectTriangle*triAngle /*= NULL*/ )
	{
		if ( !node || node->GetNodeDrawMode() != eNodeDrawSelf ) 
		{
			return  false;
		}

		// pick itself 
		scalar interPoint = N_INFINITY;
		const Resources::PositionData::value_type* verteies = node->GetPositionData();
		const Resources::Index16Container::value_type* indicies16 = node->GetIndexData();
		SizeT indexCount = node->GetIndexDataCount();
		if (verteies && indicies16)
		{
			scalar f = 0.0f;
			if( IntersectPrimitive(localRay, type, verteies, indicies16, indexCount, f,  fTolerance, triAngle ) )
			{
				interPoint = n_min( interPoint, f );
			}
		}

		if ( interPoint != N_INFINITY )
		{
			fout = interPoint;
			return true;
		}
		else
		{
			return false;
		}
	}
	//------------------------------------------------------------------------
	bool IntersectUtil::IntersectTerrainNode(const Math::Ray& localRay, RenderBase::PrimitiveTopology::Code type, App::TerrainNode* node, Math::scalar& fout, Math::scalar fTolerance,IntersectTriangle*triAngle /*= NULL*/ )
	{
		if ( node == NULL )
		{
			return false;
		}

		// pick the bounding box
		const Math::bbox& bb = node->GetLocalBoundingBox();
		Math::scalar fOut1, fOut2;
		if ( !Math::Intersection::Intersect(localRay, bb, fOut1, fOut2 ) )
		{
			return false;
		}

		scalar interPoint = N_INFINITY;

		// recursivly pick the children node, find the nearest point
		for ( IndexT i = eLeftUpChild; i < eChildCount; ++i)
		{
			TerrainNode* child = node->GetChildNode(i);
			if ( !child )
			{		
				continue;					
			}
			scalar f = 0.0f;
			bool bSucc = IntersectTerrainNode(localRay, type, child, f, fTolerance,triAngle);
			if(bSucc)
			{
				interPoint = n_min( interPoint, f );
			}
			
		}

		if ( node->GetNodeDrawMode() == eNodeDrawSelf )
		{
			scalar f = 0.0f;
			bool bSucc = IntersectTerrainNode_Visbile(localRay, type, node, f, fTolerance,triAngle) ;
			if ( bSucc )
			{
				interPoint = n_min( interPoint, f );
			}
		}

		if ( interPoint != N_INFINITY )
		{
			fout = interPoint;
			return true;
		}
		else
		{
			return false;
		}
	
	}
	//------------------------------------------------------------------------------
	bool 
	IntersectUtil::IntersectTerrain(const Math::Ray& localRay, const GPtr<TerrainRenderComponent>& TRComponent,Math::scalar& fout, Math::scalar fTolerance, IntersectTriangle* triAngle /* = NULL*/)
	{
		if (!TRComponent.isvalid())
		{
			return false;
		}

		const PrimitiveTopology::Code type = TRComponent->GetPrimitiveTopology();
		
		TerrainNode* root = TRComponent->GetRootNode();
		if ( !root )
		{
			return false;
		}

		return IntersectTerrainNode(localRay,type,root,fout,fTolerance,triAngle);
	}

	//------------------------------------------------------------------------
	bool 
	IntersectUtil::IntersectMesh(const Math::Ray& localRay, const GPtr<Resources::MeshRes>& mesh,Math::scalar& fout, Math::scalar fTolerance, IntersectTriangle* triAngle )
	{
		if ( !mesh.isvalid() )
		{
			return false;
		}

		PrimitiveTopology::Code type = mesh->GetTopologyType();

		SizeT vertexCount = mesh->GetVertexCount();
		const Resources::PositionData::value_type* verteies = mesh->GetVertexData<Resources::PositionData>(0);

		SizeT subMeshCount = mesh->GetSubMeshCount();

		SizeT indexCount = mesh->GetIndexCount();
		bool useIndex16 = mesh->IsUseIndex16();
		const Resources::Index16Container::value_type* indicies16 = mesh->GetIndex16();
		const Resources::Index32Container::value_type* indicies32 = mesh->GetIndex32();

		if ( vertexCount == 0 )
		{
			return false;
		}

		if ( indicies16 == NULL && indicies32 == NULL )
		{
			return false;
		}


		scalar interPoint = N_INFINITY;
		if ( subMeshCount > 0 )
		{
			for ( IndexT index = 0; index < subMeshCount; ++index )
			{
				const SubMesh* subMesh = mesh->GetSubMesh(index);
				if( !subMesh )
					continue;

				if ( useIndex16 )
				{
					// use 16 bits index
					n_assert( indicies16 );
					scalar f;
					const Index16Container::value_type* beginIndex = indicies16 + subMesh->FirstIndex;
					if ( IntersectPrimitive(localRay, type, verteies, beginIndex, subMesh->numIndex, f,  fTolerance, triAngle))
					{
						interPoint = n_min( interPoint, f );
					}
				}
				else
				{
					// use 32 bits index
					n_assert( indicies32 );
					scalar f;
					const Index32Container::value_type* beginIndex = indicies32 + subMesh->FirstIndex;
					if ( IntersectPrimitive(localRay, type, verteies, beginIndex, subMesh->numIndex, f, fTolerance, triAngle ))
					{
						interPoint = n_min( interPoint, f );
					}
				}
			}

		}
		else
		{
			if ( indexCount > 0 )
			{
				if ( useIndex16 )
				{
					// use 16 bits index
					n_assert( indicies16 );
					scalar f;
					if ( IntersectPrimitive(localRay, type, verteies, indicies16, indexCount, f,  fTolerance, triAngle ))
					{
						interPoint = n_min( interPoint, f );
					}
				}
				else
				{
					// use 32 bits index
					n_assert( indicies32 );
					scalar f;
					if ( IntersectPrimitive(localRay, type, verteies, indicies32, indexCount, f, fTolerance, triAngle ))
					{
						interPoint = n_min( interPoint, f );
					}
				}
			}
			else if( indexCount == 0 ) 
			{
				scalar f;
				if ( IntersectPrimitive( localRay, type,verteies, vertexCount, f, fTolerance, triAngle ))
				{
					interPoint = n_min( interPoint, f );
				}				
			}
		}


		if ( interPoint != N_INFINITY )
		{
			fout = interPoint;
			return true;
		}
		else
		{
			return false;
		}

	}
	//------------------------------------------------------------------------
	bool 
	IntersectUtil::IntersectPrimitive(const Math::Ray& localRay,
		RenderBase::PrimitiveTopology::Code type, 
		const Resources::PositionData::value_type* verticies,
		SizeT numVertex, 
		Math::scalar& fout, 
		Math::scalar fTolerance,
		IntersectTriangle* triAngle /* = NULL */)
	{
		if ( verticies == NULL )
		{
			return false;
		}

		scalar interPoint = N_INFINITY;

		switch (type)
		{
		case PrimitiveTopology::PointList:
			{
				for ( IndexT i = 0; i < numVertex; ++i)
				{
					if ( Intersection::Intersect(localRay, verticies[i], fTolerance )  )
					{
						float3 diff = verticies[i] - localRay.Start();
						if(triAngle != NULL && diff.length() < interPoint)
						{
							triAngle->point0 = verticies[i];
							triAngle->point1 = verticies[i];
							triAngle->point2 = verticies[i];
						}
						interPoint = n_min( interPoint, diff.length() );
					}
				}
			}
			break;
		case PrimitiveTopology::LineList:
			{
				for ( IndexT i = 0; i < numVertex ; )
				{
					scalar f;
					if ( Intersection::Intersect(localRay, verticies[i], verticies[i+1], f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[i];
							triAngle->point1 = verticies[i+1];
							triAngle->point2 = verticies[i];
						}
						interPoint = n_min( interPoint, f );
					}

					i += 2;
				}
			}
			break;
		case PrimitiveTopology::LineStrip:
			{
				SizeT size = numVertex - 1;
				for ( IndexT i = 0; i < size ; ++i)
				{
					scalar f;
					if ( Intersection::Intersect(localRay, verticies[i], verticies[i+1], f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[i];
							triAngle->point1 = verticies[i+1];
							triAngle->point2 = verticies[i];
						}
						interPoint = n_min( interPoint, f );
					}
				}
			}
			break;
		case PrimitiveTopology::TriangleList:
			{
				for ( IndexT i = 0; i < numVertex ; )
				{
					scalar f;
					if ( Intersection::Intersect(localRay, verticies[i], verticies[i+1], verticies[i+2], f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[i];
							triAngle->point1 = verticies[i+1];
							triAngle->point2 = verticies[i+2];
						}
						interPoint = n_min( interPoint, f );
					}

					i += 3;
				}
			}
			break;
		case PrimitiveTopology::TriangleStrip:
			{
				SizeT size = numVertex - 1;
				for ( IndexT i = 0; i < size ; ++i)
				{
					scalar f;
					if ( Intersection::Intersect(localRay, verticies[i], verticies[i+1],verticies[i+2],  f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[i];
							triAngle->point1 = verticies[i+1];
							triAngle->point2 = verticies[i+2];
						}
						interPoint = n_min( interPoint, f );
					}
				}
			}
			break;
		default:
			break;
		}

		if ( interPoint != N_INFINITY )
		{
			fout = interPoint;
			return true;
		}
		else
		{
			return false;
		}
	}
	//------------------------------------------------------------------------
	template<typename Index_type>
	bool 
	IntersectPrimitiveImpl(const Math::Ray& localRay,  
		RenderBase::PrimitiveTopology::Code type,
		const Resources::PositionData::value_type* verticies,
		const Index_type* indicies,
		SizeT indexCount, 
		Math::scalar& fout, 
		Math::scalar fTolerance,
		IntersectTriangle* triAngle = NULL)
	{
		if ( verticies == NULL || indicies == NULL )
		{
			return false;
		}

		scalar interPoint = N_INFINITY;

		// hack : for the point and line, tolerance is bigger. More reasonable algorithm is letting the line
		// and point project on the screen to judge. Because at present only editor's indicators need this, we
		// think that there are a bigger tolerance is going to be
		const Math::scalar ToleranceForLine = Math::scalar(0.01);

		switch (type)
		{
		case PrimitiveTopology::PointList:
			{
				for ( IndexT i = 0; i < indexCount; ++i)
				{
					Index_type index = indicies[i];
					if ( Intersection::Intersect(localRay, verticies[index], ToleranceForLine )  )
					{
						float3 diff = verticies[index] - localRay.Start();
						if(triAngle != NULL && diff.length() < interPoint)
						{
							triAngle->point0 = verticies[index];
							triAngle->point1 = verticies[index];
							triAngle->point2 = verticies[index];
						}
						interPoint = n_min( interPoint, diff.length() );
					}
				}
			}
			break;
		case PrimitiveTopology::LineList:
			{
				for ( IndexT i = 0; i < indexCount ; )
				{
					scalar f;
					Index_type index0 = indicies[i];
					Index_type index1 = indicies[i+1];
					if ( Intersection::Intersect(localRay, verticies[index0], verticies[index1], f, ToleranceForLine ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[index0];
							triAngle->point1 = verticies[index1];
							triAngle->point2 = verticies[index0];
						}
						interPoint = n_min( interPoint, f );
					}

					i += 2;
				}
			}
			break;
		case PrimitiveTopology::LineStrip:
			{
				SizeT size = indexCount - 1;
				for ( IndexT i = 0; i < size ; ++i)
				{
					scalar f;
					Index_type index0 = indicies[i];
					Index_type index1 = indicies[i+1];
					if ( Intersection::Intersect(localRay, verticies[index0], verticies[index1], f, ToleranceForLine ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[index0];
							triAngle->point1 = verticies[index1];
							triAngle->point2 = verticies[index0];
						}
						interPoint = n_min( interPoint, f );
					}
				}
			}
			break;
		case PrimitiveTopology::TriangleList:
			{
				for ( IndexT i = 0; i < indexCount ; )
				{
					scalar f;
					Index_type index0 = indicies[i];
					Index_type index1 = indicies[i+1];
					Index_type index2 = indicies[i+2];
					if ( Intersection::Intersect(localRay, verticies[index0], verticies[index1], verticies[index2], f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[index0];
							triAngle->point1 = verticies[index1];
							triAngle->point2 = verticies[index2];
						}
						interPoint = n_min( interPoint, f );
					}

					i += 3;
				}
			}
			break;
		case PrimitiveTopology::TriangleStrip:
			{
				SizeT size = indexCount - 1;
				for ( IndexT i = 0; i < size ; ++i)
				{
					scalar f;
					Index_type index0 = indicies[i];
					Index_type index1 = indicies[i+1];
					Index_type index2 = indicies[i+2];

					if ( Intersection::Intersect(localRay, verticies[index0], verticies[index1],verticies[index2],  f, fTolerance ) )
					{
						if(triAngle != NULL && f < interPoint)
						{
							triAngle->point0 = verticies[index0];
							triAngle->point1 = verticies[index1];
							triAngle->point2 = verticies[index2];
						}
						interPoint = n_min( interPoint, f );
					}
				}
			}
			break;
		default:
			break;
		}

		if ( interPoint != N_INFINITY )
		{
			fout = interPoint;
			return true;
		}
		else
		{
			return false;
		}
	}
	//------------------------------------------------------------------------
	// intersect primitive index by 16 bit
	bool 
	IntersectUtil::IntersectPrimitive(const Math::Ray& localRay,  
		RenderBase::PrimitiveTopology::Code type,
		const Resources::PositionData::value_type* verticies,
		const Resources::Index16Container::value_type* indicies,
		SizeT indexCount, 
		Math::scalar& fout, 
		Math::scalar fTolerance,
		IntersectTriangle* triAngle /* = NULL */)
	{
		return IntersectPrimitiveImpl(localRay, type, verticies, indicies, indexCount, fout, fTolerance, triAngle );
	}

	// intersect primitive index by 32 bit 
	bool 
	IntersectUtil::IntersectPrimitive(const Math::Ray& localRay,  
		RenderBase::PrimitiveTopology::Code type,
		const Resources::PositionData::value_type* verticies,
		const Resources::Index32Container::value_type* indicies,
		SizeT indexCount, 
		Math::scalar& fout, 
		Math::scalar fTolerance,
		IntersectTriangle* triAngle /* = NULL */)
	{
		return IntersectPrimitiveImpl(localRay, type, verticies, indicies, indexCount, fout, fTolerance, triAngle );
	}
}