653 lines
19 KiB
C++
653 lines
19 KiB
C++
// 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
|