khanat-code-old/code/nel/src/3d/visual_collision_entity.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "std3d.h"

#include "nel/3d/u_visual_collision_entity.h"

#include "nel/3d/visual_collision_entity.h"
#include "nel/3d/landscape.h"
#include "nel/3d/dru.h"
#include "nel/3d/driver.h"
#include "nel/3d/tile_bank.h"
#include "nel/misc/hierarchical_timer.h"


using namespace std;
using namespace NLMISC;


namespace NL3D
{


// ***************************************************************************
// should be at least 2 meters.
const	float	CVisualCollisionEntity::BBoxRadius= 10;
const	float	CVisualCollisionEntity::BBoxRadiusZ= 20;
const	uint32	CVisualCollisionEntity::_StartPatchQuadBlockSize= 64;	// 256 octets per entity minimum.
vector<CPatchBlockIdent>		CVisualCollisionEntity::_TmpBlockIds;
vector<CPatchQuadBlock*>		CVisualCollisionEntity::_TmpPatchQuadBlocks;


// ***************************************************************************
CVisualCollisionEntity::CVisualCollisionEntity(CVisualCollisionManager *owner) : _LandscapeQuadGrid(owner)
{
	_Owner= owner;
	_PatchQuadBlocks.reserve(_StartPatchQuadBlockSize);

	_CurrentBBoxValidity.setHalfSize(CVector::Null);

	_GroundMode= true;
	_CeilMode= false;
	_SnapToRenderedTesselation= true;

	_LastGPTValid= false;
}


// ***************************************************************************
CVisualCollisionEntity::~CVisualCollisionEntity()
{
	// delete the _PatchQuadBlocks.
	for(sint i=0; i<(sint)_PatchQuadBlocks.size(); i++)
	{
		_Owner->deletePatchQuadBlock(_PatchQuadBlocks[i]);
	}
	_PatchQuadBlocks.clear();

	// delete the quadgrid.
	_LandscapeQuadGrid.clear();
}


// ***************************************************************************
bool		CVisualCollisionEntity::snapToGround(CVector &pos)
{
	CVector		normal;
	// Not optimized, but doesn't matter (one cross product is negligible).
	return snapToGround(pos, normal);
}


// ***************************************************************************
CTrianglePatch		*CVisualCollisionEntity::getPatchTriangleUnderUs(const CVector &pos, CVector &res)
{
	// verify if landscape (refptr) is here.
	if(_Owner->_Landscape==NULL)
	{
		_LastGPTValid= false;
		return NULL;
	}


	// Test GPT cache.
	//==================
	// If last call was valid, and if same pos (input or output), return cached information
	if(_LastGPTValid && (pos==_LastGPTPosInput || pos==_LastGPTPosOutput) )
	{
		// copy from cache.
		res= _LastGPTPosOutput;
		/* don't modify _LastGPTPosInput cache, for best cache behavior in all cases.
			1/ this is not necessary (here, if pos!=_LastGPTPosInput, THEN pos==_LastGPTPosOutput, no other possibilities)
			2/ it causes problems when getPatchTriangleUnderUs() is called randomly with the unsnapped or snapped position:
				1st Time: zin:9.0  =>  zout:9.5	cache fail (ok, 1st time...)
				2nd Time: zin:9.0  =>  zout:9.5	cache OK (_LastGPTPosInput.z==zin)
				3rd Time: zin:9.5  =>  zout:9.5	cache OK (_LastGPTPosOutput.z==zin)
				4th Time: zin:9.0  =>  zout:9.5	cache FAILS (_LastGPTPosInput.z= 9.5 => !=zin)
		*/
		// and return ptr on cache.
		return &_LastGPTTrianglePatch;
	}


	// update the cache of tile info near this position.
	// =================
	testComputeLandscape(pos);


	// find possible faces under the entity.
	// =================
	CVisualTileDescNode		*ptr= _LandscapeQuadGrid.select(pos);


	// find the better face under the entity.
	// =================
	float	sqrBestDist= sqr(1000.f);
	CVector	hit;
	// build the vertical ray.
	CVector		segP0= pos - CVector(0,0,100);
	CVector		segP1= pos + CVector(0,0,100);


	// triangles builded from this list.
	static	vector<CTrianglePatch>		testTriangles;
	// NB: not so many reallocation here, because static.
	testTriangles.clear();
	sint	bestTriangle= 0;


	// For all the faces in this quadgrid node.
	while(ptr)
	{
		// what is the quad block of this tile Id.
		sint				qbId= ptr->PatchQuadBlocId;
		nlassert(qbId>=0 && qbId<(sint)_PatchQuadBlocks.size());
		CPatchQuadBlock		&qb= *_PatchQuadBlocks[qbId];

		// Build the 2 triangles of this tile Id.
		sint	idStart= (sint)testTriangles.size();
		testTriangles.resize(idStart+2);
		qb.buildTileTriangles((uint8)ptr->QuadId, &testTriangles[idStart]);

		// Test the 2 triangles.
		for(sint i=0; i<2; i++)
		{
			CTrianglePatch	&tri= testTriangles[idStart+i];
			// test if the ray intersect.
			// NB: triangleIntersect() is faster than CTriangle::intersect().
			if(triangleIntersect(tri, segP0, segP1, hit))
			{
				// find the nearest triangle.
				float sqrdist= (hit-pos).sqrnorm();
				if(sqrdist<sqrBestDist)
				{
					bestTriangle= idStart+i;
					res= hit;
					sqrBestDist= sqrdist;
				}
			}
		}


		// Next in the list.
		ptr= ptr->Next;
	}


	// found ??
	if(sqrBestDist<sqr(1000))
	{
		// copy into cache
		_LastGPTValid= true;
		_LastGPTTrianglePatch= testTriangles[bestTriangle];
		_LastGPTPosInput= pos;
		_LastGPTPosOutput= res;
		// and return ptr on cache.
		return &_LastGPTTrianglePatch;
	}
	else
	{
		_LastGPTValid= false;
		return NULL;
	}

}


// ***************************************************************************
bool		CVisualCollisionEntity::snapToGround(CVector &pos, CVector &normal)
{
	// Get Patch Triangle Under Us
	CVector		res;
	CTrianglePatch	*tri= getPatchTriangleUnderUs(pos, res);

	// result. NB: if not found, dot not modify.
	if( tri )
	{
		if(_SnapToRenderedTesselation)
		{
			// snap the position to the nearest tesselation.
			pos= res;

			// snap the position to the current rendered tesselation.
			snapToLandscapeCurrentTesselation(pos, *tri);
		}
		else
		{
			// just snap to the accurate tile tesselation.
			pos= res;
		}


		// compute the normal.
		normal= (tri->V1-tri->V0)^(tri->V2-tri->V0);
		normal.normalize();

		return true;
	}
	else
		return false;
}


// ***************************************************************************
void		CVisualCollisionEntity::computeUvForPos(const CTrianglePatch &tri, const CVector &pos, CUV &uv)
{
	// compute UV gradients.
	CVector		Gu;
	CVector		Gv;
	tri.computeGradient(tri.Uv0.U, tri.Uv1.U, tri.Uv2.U, Gu);
	tri.computeGradient(tri.Uv0.V, tri.Uv1.V, tri.Uv2.V, Gv);
	// interpolate
	uv.U= tri.Uv0.U + Gu*(pos-tri.V0);
	uv.V= tri.Uv0.V + Gv*(pos-tri.V0);
}


// ***************************************************************************
void		CVisualCollisionEntity::snapToLandscapeCurrentTesselation(CVector &pos, const CTrianglePatch &tri)
{
	// compute UV for position.
	CUV		uv;
	computeUvForPos(tri, pos, uv);

	// Ask pos to landscape.
	CVector		posLand;
	posLand= _Owner->_Landscape->getTesselatedPos(tri.PatchId, uv);

	// just keep Z.
	pos.z= posLand.z;
}


// ***************************************************************************
// TestYoyo. For Precision problem.
/*static bool	testLine(CVector &p1, CVector &p0, const CVector &pos0)
{
	float	epsilon=	0.1f;

	float		a,b,c;		// 2D cartesian coefficients of line in plane X/Y.
	float		norm;
	// Line p0-p1.
	a= -(p1.y-p0.y);
	b= (p1.x-p0.x);
	norm= sqrtf(sqr(a) + sqr(b));
	a/= norm;
	b/= norm;
	c= -(p0.x*a + p0.y*b);
	if( (a*pos0.x + b*pos0.y + c) < -epsilon)
		return false;
	else
		return true;
}*/


// ***************************************************************************
bool		CVisualCollisionEntity::triangleIntersect2DGround(CTriangle &tri, const CVector &pos0)
{
	CVector		&p0= tri.V0;
	CVector		&p1= tri.V1;
	CVector		&p2= tri.V2;

	// TestYoyo. Test for precision problems.
	/*if( testLine(p1, p0, pos0) && testLine(p2, p1, pos0) && testLine(p0, p2, pos0) )
	{
		nlinfo("Found Tri For Pos: %.07f, %.07f\n   P0: %.07f, %.07f\n   P1: %.07f, %.07f\n   P2: %.07f, %.07f",
			pos0.x, pos0.y, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y);
	}*/

	// Test if the face enclose the pos in X/Y plane.
	// NB: compute and using a BBox to do a rapid test is not a very good idea, since it will
	// add an overhead which is NOT negligeable compared to the following test.
	float		a,b,c;		// 2D cartesian coefficients of line in plane X/Y.
	// Line p0-p1.
	a= -(p1.y-p0.y);
	b= (p1.x-p0.x);
	c= -(p0.x*a + p0.y*b);
	if( (a*pos0.x + b*pos0.y + c) < 0)	return false;
	// Line p1-p2.
	a= -(p2.y-p1.y);
	b= (p2.x-p1.x);
	c= -(p1.x*a + p1.y*b);
	if( (a*pos0.x + b*pos0.y + c) < 0)	return false;
	// Line p2-p0.
	a= -(p0.y-p2.y);
	b= (p0.x-p2.x);
	c= -(p2.x*a + p2.y*b);
	if( (a*pos0.x + b*pos0.y + c) < 0)	return false;

	return true;
}

// ***************************************************************************
bool		CVisualCollisionEntity::triangleIntersect2DCeil(CTriangle &tri, const CVector &pos0)
{
	CVector		&p0= tri.V0;
	CVector		&p1= tri.V1;
	CVector		&p2= tri.V2;

	// Test if the face enclose the pos in X/Y plane.
	// NB: compute and using a BBox to do a rapid test is not a very good idea, since it will
	// add an overhead which is NOT negligeable compared to the following test.
	float		a,b,c;		// 2D cartesian coefficients of line in plane X/Y.
	// Line p0-p1.
	a= -(p1.y-p0.y);
	b= (p1.x-p0.x);
	c= -(p0.x*a + p0.y*b);
	if( (a*pos0.x + b*pos0.y + c) > 0)	return false;
	// Line p1-p2.
	a= -(p2.y-p1.y);
	b= (p2.x-p1.x);
	c= -(p1.x*a + p1.y*b);
	if( (a*pos0.x + b*pos0.y + c) > 0)	return false;
	// Line p2-p0.
	a= -(p0.y-p2.y);
	b= (p0.x-p2.x);
	c= -(p2.x*a + p2.y*b);
	if( (a*pos0.x + b*pos0.y + c) > 0)	return false;

	return true;
}

// ***************************************************************************
bool		CVisualCollisionEntity::triangleIntersect(CTriangle &tri, const CVector &pos0, const CVector &pos1, CVector &hit)
{
	CVector		&p0= tri.V0;
	CVector		&p1= tri.V1;
	CVector		&p2= tri.V2;

	bool	ok= false;
	if( _GroundMode && triangleIntersect2DGround(tri, pos0) )
		ok= true;
	if(!ok && _CeilMode && triangleIntersect2DCeil(tri, pos0) )
		ok= true;
	if(!ok)
		return false;


	// Compute the possible height.
	CVector		tmp;
	// build the plane
	CPlane plane;
	plane.make (p0, p1, p2);
	// intersect the vertical line with the plane.
	tmp= plane.intersect(pos0, pos1);

	float		h= tmp.z;
	// Test if it would fit in the wanted field.
	if(h>pos1.z)	return false;
	if(h<pos0.z)	return false;

	// OK!!
	// For cache completness, ensure that X and Y don't move, take same XY than pos0
	hit.x= pos0.x;
	hit.y= pos0.y;
	hit.z= h;
	return true;
}

// ***************************************************************************
void		CVisualCollisionEntity::testComputeLandscape(const CVector &pos)
{
	// if new position is out of the bbox surounding the entity.
	if(_CurrentBBoxValidity.getHalfSize()==CVector::Null || !_CurrentBBoxValidity.include(pos))
	{
		// must recompute the data around the entity.
		doComputeLandscape(pos);
	}
}

// ***************************************************************************
void		CVisualCollisionEntity::doComputeLandscape(const CVector &pos)
{
	sint	i;

	// setup new bbox.
	//==================
	// compute the bbox which must includes the patchQuadBlocks
	CAABBox		bboxToIncludePatchs;
	bboxToIncludePatchs.setCenter(pos);
	bboxToIncludePatchs.setHalfSize(CVector(BBoxRadius, BBoxRadius, BBoxRadiusZ));
	// setup the _CurrentBBoxValidity with same values, but BBoxRadiusZ/2
	_CurrentBBoxValidity.setCenter(pos);
	_CurrentBBoxValidity.setHalfSize(CVector(BBoxRadius, BBoxRadius, BBoxRadiusZ/2));


	// Search landscape blocks which are in the bbox.
	//==================
	_Owner->_Landscape->buildPatchBlocksInBBox(bboxToIncludePatchs, _TmpBlockIds);



	// Recompute PatchQuadBlockcs.
	//==================
	// This parts try to keeps old patch blocks so they are not recomputed if they already here.

	// sort PatchBlockIdent.
	sort(_TmpBlockIds.begin(), _TmpBlockIds.end());

	// Copy old array of ptr (ptr copy only).
	_TmpPatchQuadBlocks= _PatchQuadBlocks;

	// allocate dest array.
	_PatchQuadBlocks.resize(_TmpBlockIds.size());

	// Traverse all current patchBlocks, deleting old ones no longer needed, and creating new ones.
	// this algorithm suppose both array are sorted.
	uint	iOld=0;
	// parse until dest is filled.
	for(i=0; i<(sint)_PatchQuadBlocks.size();)
	{
		// get requested new BlockIdent.
		CPatchBlockIdent	newBi= _TmpBlockIds[i];

		// get requested old BlockIdent in the array.
		bool				oldEnd= false;
		CPatchBlockIdent	oldBi;
		if(iOld==_TmpPatchQuadBlocks.size())
			oldEnd= true;
		else
			oldBi= _TmpPatchQuadBlocks[iOld]->PatchBlockId;

		// if no more old blocks, or if new Block is < than current, we must create a new block, and insert it.
		if(oldEnd || newBi < oldBi)
		{
			// allocate the patch block.
			_PatchQuadBlocks[i]= _Owner->newPatchQuadBlock();
			// fill the patch block.
			_PatchQuadBlocks[i]->PatchBlockId= _TmpBlockIds[i];
			_Owner->_Landscape->fillPatchQuadBlock(*_PatchQuadBlocks[i]);

			// next new patch block.
			i++;
		}
		// else if current new Block is same than old block, just copy ptr.
		else if(newBi==oldBi)
		{
			// just copy ptr with the old one.
			_PatchQuadBlocks[i]= _TmpPatchQuadBlocks[iOld];

			// next new and old patch block.
			i++;
			iOld++;
		}
		// else, this old block is no longer used, delete it.
		else
		{
			_Owner->deletePatchQuadBlock(_TmpPatchQuadBlocks[iOld]);
			// next old patch block.
			iOld++;
		}
	}
	// Here, must delete old blocks not yet processed.
	for(;iOld<_TmpPatchQuadBlocks.size(); iOld++)
	{
		_Owner->deletePatchQuadBlock(_TmpPatchQuadBlocks[iOld]);
	}
	_TmpPatchQuadBlocks.clear();


	// Compute the quadGrid.
	//==================

	// Compute a delta so elt position for CLandscapeCollisionGrid are positive, and so fastFloor() used will work.
	CVector		delta;
	// center the position on 0.
	// floor may be important for precision when the delta is applied.
	delta.x= (float)floor(-pos.x);
	delta.y= (float)floor(-pos.y);
	delta.z= 0;
	// We must always have positive values for patchBlocks vertices.
	float	val= (float)ceil(BBoxRadius + 256);
	// NB: 256 is a security. Because of size of patchs, a value of 32 at max should be sufficient (64 for bigger patch (gfx))
	// we are large because doesn't matter, the CLandscapeCollisionGrid tiles.
	delta.x+= val;
	delta.y+= val;

	// rebuild the quadGrid.
	_LandscapeQuadGrid.build(_PatchQuadBlocks, delta);

}


// ***************************************************************************
bool		CVisualCollisionEntity::getStaticLightSetup(NLMISC::CRGBA sunAmbient, const CVector &pos,
	std::vector<CPointLightInfluence> &pointLightList, uint8 &sunContribution, NLMISC::CRGBA &localAmbient)
{
	// Get Patch Triangle Under Us
	CVector		res;
	CTrianglePatch	*tri= getPatchTriangleUnderUs(pos, res);

	// For now, no special ambient support on landscape => take sunAmbient
	localAmbient= sunAmbient;

	// result. NB: if not found, dot not modify.
	if( tri )
	{
		// compute UV for position.
		CUV		uv;
		computeUvForPos(*tri, pos, uv);

		// get the sunContribution
		sunContribution= _Owner->_Landscape->getLumel(tri->PatchId, uv);
		// see getStaticLightSetup.
		sunContribution= _Owner->_SunContributionLUT[sunContribution];

		// append any lights of interest.
		_Owner->_Landscape->appendTileLightInfluences(tri->PatchId, uv, pointLightList);

		return true;
	}
	else
	{
		// Suppose full Sun Contribution, and don't add any pointLight
		sunContribution= 255;

		return false;
	}
}


// ***************************************************************************
bool		CVisualCollisionEntity::getSurfaceInfo(const CVector &pos, CSurfaceInfo &surfaceInfo)
{
	H_AUTO( NL3D_CVisualCollisionEntity_getSurfaceInfo )
	// Get Patch Triangle Under Us
	CVector		res;
	CTrianglePatch	*tri= getPatchTriangleUnderUs(pos, res);

	// result. NB: if not found, dot not modify.
	if( tri )
	{
		// compute UV for position.
		CUV		uv;
		computeUvForPos(*tri, pos, uv);

		// get the tileelement
		CTileElement *tileElm = _Owner->_Landscape->getTileElement(tri->PatchId, uv);
		if (tileElm)
		{
			// Valid tile ?
			uint16 tileId = tileElm->Tile[0];
			if (tileId != NL_TILE_ELM_LAYER_EMPTY)
			{
				// The tilebank
				CTileBank &tileBank = _Owner->_Landscape->TileBank;

				// Get xref info for this tile
				int tileSet;
				int number;
				CTileBank::TTileType type;
				tileBank.getTileXRef ((int)tileId, tileSet, number, type);

				// Get the tileset from layer 0
				const CTileSet* tileSetPtr = tileBank.getTileSet (tileSet);

				// Fill the surface
				surfaceInfo.UserSurfaceData = tileSetPtr->SurfaceData;

				// Ok
				return true;
			}
		}
	}
	return false;
}


// ***************************************************************************
void		CVisualCollisionEntity::displayDebugGrid(IDriver &drv) const
{
	// static to not reallocate each frame
	static	CMaterial	mat;
	static	bool		inited= false;
	if(!inited)
	{
		inited= true;
		mat.initUnlit();
	}
	static	vector<CLine>	lineList;
	lineList.clear();

	// Build lines for all patch quad blocks.
	for(uint i=0;i<_PatchQuadBlocks.size();i++)
	{
		CPatchQuadBlock		&pqb= *_PatchQuadBlocks[i];
		// Parse all quads of this patch block.
		CPatchBlockIdent	&pbid= pqb.PatchBlockId;
		for(uint t= pbid.T0; t<pbid.T1; t++)
		{
			for(uint s= pbid.S0; s<pbid.S1; s++)
			{
				// compute quad coordinate in pqb.
				uint	sd0= (s-pbid.S0);
				uint	td0= (t-pbid.T0);
				uint	sd1= sd0+1;
				uint	td1= td0+1;
				// get 4 vertex coord of quad
				const CVector	&p0= pqb.Vertices[sd0 + td0*NL_PATCH_BLOCK_MAX_VERTEX];
				const CVector	&p1= pqb.Vertices[sd0 + td1*NL_PATCH_BLOCK_MAX_VERTEX];
				const CVector	&p2= pqb.Vertices[sd1 + td1*NL_PATCH_BLOCK_MAX_VERTEX];
				const CVector	&p3= pqb.Vertices[sd1 + td0*NL_PATCH_BLOCK_MAX_VERTEX];

				// build the 5 lines
				lineList.push_back(CLine(p0, p1));
				lineList.push_back(CLine(p1, p2));
				lineList.push_back(CLine(p2, p3));
				lineList.push_back(CLine(p3, p0));
				lineList.push_back(CLine(p0, p2));
			}
		}
	}

	// Display the lines.
	CDRU::drawLinesUnlit(lineList, mat, drv);
}



} // NL3D