khanat-code-old/code/nel/src/pacs/edge_quad.cpp

636 lines
16 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 "stdpacs.h"
#include "edge_quad.h"
#include "global_retriever.h"
using namespace std;
using namespace NLMISC;
namespace NLPACS
{
// ***************************************************************************
const float CEdgeQuad::_QuadElementSize= 4; // = 4 meters.
// ***************************************************************************
CEdgeQuad::CEdgeQuad()
{
_QuadData= NULL;
_QuadDataLen= 0;
}
// ***************************************************************************
CEdgeQuad::~CEdgeQuad()
{
clear();
}
// ***************************************************************************
CEdgeQuad::CEdgeQuad(const CEdgeQuad &o)
{
_QuadData= NULL;
_QuadDataLen= 0;
*this= o;
}
// ***************************************************************************
CEdgeQuad &CEdgeQuad::operator=(const CEdgeQuad &o)
{
// Alloc good quaddata.
_QuadDataLen= o._QuadDataLen;
delete [] _QuadData;
if(_QuadDataLen>0)
{
_QuadData= (uint8*)new uint8[_QuadDataLen];
// copy contents.
memcpy(_QuadData, o._QuadData, _QuadDataLen);
}
else
_QuadData= NULL;
// copy infos.
_Width= o._Width;
_Height= o._Height;
_X= o._X;
_Y= o._Y;
_EdgeEntries = o._EdgeEntries;
// copy good pointers.
_Quad.clear();
_Quad.resize(o._Quad.size(), NULL);
for(sint i=0; i<(sint)_Quad.size(); i++)
{
if(o._Quad[i])
{
uint32 off= (uint32)(o._Quad[i]-o._QuadData);
_Quad[i]= _QuadData+off;
}
}
return *this;
}
// ***************************************************************************
void CEdgeQuad::clear()
{
delete [] _QuadData;
_QuadData= NULL;
_QuadDataLen= 0;
_Quad.clear();
_EdgeEntries.clear();
_Width = 0;
_Height = 0;
_X = 0;
_Y = 0;
}
// ***************************************************************************
void CEdgeQuad::getGridBounds(sint32 &x0, sint32 &y0, sint32 &x1, sint32 &y1, const CVector &minP, const CVector &maxP) const
{
x0= (sint32)floor(minP.x / _QuadElementSize) - _X;
y0= (sint32)floor(minP.y / _QuadElementSize) - _Y;
x1= (sint32) ceil(maxP.x / _QuadElementSize) - _X;
y1= (sint32) ceil(maxP.y / _QuadElementSize) - _Y;
x0= max(x0, (sint32)0);
y0= max(y0, (sint32)0);
x1= min(x1, (sint32)_Width);
y1= min(y1, (sint32)_Height);
}
// ***************************************************************************
void CEdgeQuad::build(const CExteriorMesh &em,
const CGlobalRetriever &global,
CCollisionSurfaceTemp &cst,
uint32 thisInstance)
{
const std::vector<CExteriorMesh::CEdge> &edges = em.getEdges();
vector< list<uint16> > tempQuad;
sint i, j;
// first, clear any pr-build.
contReset(_Quad);
delete [] _QuadData;
_QuadData= NULL;
_QuadDataLen= 0;
// don't care about the origin of the instance
CVector origin = global.getInstance(thisInstance).getOrigin();
// 0. Find BBox of the grid. Allocate grid.
//=========================================
bool first=true;
CAABBox chainquadBBox;
// run all chains.
for (i=0; i<(sint)edges.size()-1; i++)
{
// enlarge bbox.
if (first)
first= false, chainquadBBox.setCenter(edges[i].Start);
else
chainquadBBox.extend(edges[i].Start);
}
// compute X,Y,Width, Height.
_X= (sint32)floor(chainquadBBox.getMin().x / _QuadElementSize);
_Y= (sint32)floor(chainquadBBox.getMin().y / _QuadElementSize);
_Width= (sint32)ceil(chainquadBBox.getMax().x / _QuadElementSize) - _X;
_Height= (sint32)ceil(chainquadBBox.getMax().y / _QuadElementSize) - _Y;
tempQuad.resize(_Width*_Height);
_Quad.resize(_Width*_Height, NULL);
// 1. For each edge, add them to the quadgrid.
//=========================================
// run all chains.
for (i=0; i<(sint)edges.size()-1; i++)
{
if (edges[i].Link == -2)
continue;
float dnorm = (edges[i+1].Start-edges[i].Start).norm();
uint numStep = (uint)(dnorm/0.1f)+1;
uint step;
CVector pbegin = edges[i].Start+origin,
pend = edges[i+1].Start+origin;
CVector opbegin = edges[i].Start,
opend = edges[i+1].Start;
for (step=0; step<numStep; ++step)
{
float lambda0 = (float)(step)/(float)(numStep);
float lambda1 = (float)(step+1)/(float)(numStep);
CVector p0 = pbegin*(1.0f-lambda0)+pend*(lambda0),
p1 = pbegin*(1.0f-lambda1)+pend*(lambda1);
CVector op0 = opbegin*(1.0f-lambda0)+opend*(lambda0),
op1 = opbegin*(1.0f-lambda1)+opend*(lambda1);
CVector s0, s1,
mins, maxs;
uint prevEdge = (i-1)%(edges.size()-1);
bool prio0 = (edges[i].Link!=-1) || (edges[prevEdge].Link!=-1);
UGlobalPosition gp0 = global.retrievePosition(p0);
global.updateHeight(gp0);
UGlobalPosition gp1 = global.retrievePosition(p1);
global.updateHeight(gp1);
if (!prio0)
{
swap(p0, p1);
swap(op0, op1);
swap(gp0, gp1);
}
if (gp0.InstanceId == -1)
{
swap(p0, p1);
swap(op0, op1);
swap(gp0, gp1);
}
const TCollisionSurfaceDescVector *pcd = global.testCylinderMove(gp0, p1-p0, 0.01f, cst);
if (pcd == NULL)
{
// nlwarning("in CEdgeQuad::build(): testCylinderMove() returned NULL");
continue;
}
TCollisionSurfaceDescVector cd = (*pcd);
if (edges[i].Link != -1 && cd.size() > 0)
{
nlwarning ("In NLPACS::CEdgeQuad::build()");
nlwarning ("ERROR: exterior edge %d with interior link crosses some surfaces", i);
cd.clear ();
}
// add start surface to the collision description
CCollisionSurfaceDesc stcd;
stcd.ContactTime = 0.0f;
stcd.ContactSurface.RetrieverInstanceId = gp0.InstanceId;
stcd.ContactSurface.SurfaceId = gp0.LocalPosition.Surface;
cd.insert(cd.begin(), stcd);
// get the surface, chain ...
sint edgeId = i;
uint16 chainId;
CSurfaceIdent interior;
if (edges[i].Link == -1)
{
interior.RetrieverInstanceId = -1;
interior.SurfaceId = -1;
chainId = 0xFFFF;
}
else
{
interior.RetrieverInstanceId = thisInstance;
interior.SurfaceId = em.getLink(edges[i].Link).SurfaceId;
chainId = em.getLink(edges[i].Link).ChainId;
}
// add end point to the collision description
stcd = cd.back();
stcd.ContactTime = 1.0f;
cd.push_back(stcd);
for (j=0; j<(sint)cd.size()-1; ++j)
{
s0 = op0*(float)(1.0-cd[j].ContactTime) + op1*(float)(cd[j].ContactTime);
s1 = op0*(float)(1.0-cd[j+1].ContactTime) + op1*(float)(cd[j+1].ContactTime);
mins.minof(s0, s1);
maxs.maxof(s0, s1);
// PrecisionPb: extend a little this edge. This is important for special case like borders on zones.
if(mins.x-maxs.x==0)
mins.x-=0.001f, maxs.x+=0.001f;
if(mins.y-maxs.y==0)
mins.y-=0.001f, maxs.y+=0.001f;
// get bounding coordinate of this edge in the quadgrid.
sint32 x0, y0, x1, y1;
sint x, y;
getGridBounds(x0, y0, x1, y1, mins, maxs);
CSurfaceIdent exterior = cd[j].ContactSurface;
uint entry;
for (entry=0; entry<_EdgeEntries.size(); ++entry)
{
if (_EdgeEntries[entry].EdgeId == edgeId &&
_EdgeEntries[entry].Exterior == exterior)
{
if (_EdgeEntries[entry].ChainId != chainId ||
_EdgeEntries[entry].Interior != interior)
{
nlwarning("In NLPACS::CEdgeQuad::build()");
nlerror("exterior edge %d has different interior linkage", edgeId);
}
break;
}
}
// if this entry didn't exist before create a new one...
if (entry == _EdgeEntries.size())
{
_EdgeEntries.push_back(CExteriorEdgeEntry());
_EdgeEntries.back().EdgeId = uint16(edgeId);
_EdgeEntries.back().ChainId = chainId;
_EdgeEntries.back().Interior = interior;
_EdgeEntries.back().Exterior = exterior;
}
// add this edge to all the quadnode it touches.
for(y=y0; y<y1; y++)
{
for(x=x0; x<x1; x++)
{
// check we don't push this entry twice
list<uint16>::iterator it;
for (it=tempQuad[y*_Width+x].begin(); it!=tempQuad[y*_Width+x].end(); ++it)
if (entry == *it)
break;
if (it == tempQuad[y*_Width+x].end())
tempQuad[y*_Width+x].push_back(uint16(entry));
}
}
}
}
}
nlinfo("Built ExteriorEdgeQuad, linked following doors:");
for (i=0; i<(sint)_EdgeEntries.size(); ++i)
{
if (edges[_EdgeEntries[i].EdgeId].Link != -1 &&
(_EdgeEntries[i].Interior.RetrieverInstanceId == -1 || _EdgeEntries[i].Interior.SurfaceId == -1 ||
_EdgeEntries[i].Exterior.RetrieverInstanceId == -1 || _EdgeEntries[i].Exterior.SurfaceId == -1))
{
nlwarning("In NLPACS::CEdgeQuad::build(): exterior door %d has corrupted link", i);
}
else if (edges[_EdgeEntries[i].EdgeId].Link != -1)
{
nlinfo("Inst=%d ExtEdge=%d IntInst=%d IntSurf=%d IntChain=%d ExtInst=%d ExtSurf=%d", thisInstance, _EdgeEntries[i].EdgeId,
_EdgeEntries[i].Interior.RetrieverInstanceId, _EdgeEntries[i].Interior.SurfaceId, _EdgeEntries[i].ChainId,
_EdgeEntries[i].Exterior.RetrieverInstanceId, _EdgeEntries[i].Exterior.SurfaceId);
}
}
// 2. Mem optimisation: Use only 1 block for ALL quads of the grid.
//=========================================
sint memSize= 0;
// run all quads.
for(i=0;i<(sint)tempQuad.size();i++)
{
list<uint16> &quadNode= tempQuad[i];
if(!quadNode.empty())
{
// add an entry for Len.
memSize+= sizeof(uint16);
// add N entry of CEdgeChainEntry.
memSize+= (sint)quadNode.size()*sizeof(uint16);
}
}
// allocate.
_QuadData= (uint8*)new uint8[memSize];
_QuadDataLen= memSize;
// 3. Fill _QuadData with lists.
//=========================================
uint8 *ptr= _QuadData;
for(i=0;i<(sint)tempQuad.size();i++)
{
list<uint16> &srcQuadNode= tempQuad[i];
list<uint16>::iterator it;
if(!srcQuadNode.empty())
{
_Quad[i]= ptr;
// write len.
uint16 len= uint16(srcQuadNode.size());
*((uint16*)ptr)= len;
ptr+= sizeof(uint16);
// add entries.
it= srcQuadNode.begin();
for(j=0; j<len; j++, it++)
{
*((uint16 *)ptr)= *it;
ptr+= sizeof(uint16);
}
}
}
// End.
}
// ***************************************************************************
sint CEdgeQuad::selectEdges(const NLMISC::CAABBox &bbox, CCollisionSurfaceTemp &cst) const
{
sint nRes=0;
sint i;
uint16 *indexLUT = cst.OChainLUT;
// start: no edge found.
cst.ExteriorEdgeIndexes.clear();
// get bounding coordinate of this bbox in the quadgrid.
sint32 x0, y0, x1, y1;
getGridBounds(x0, y0, x1, y1, bbox.getMin(), bbox.getMax());
// run all intersected quads.
for (sint y= y0; y<y1; y++)
{
for (sint x= x0; x<x1; x++)
{
uint8 *quadNode= _Quad[y*_Width+x];
// no edgechain entry??
if(!quadNode)
continue;
// get edgechain entries
sint numExteriorEdgeIndexes= *((uint16*)quadNode);
quadNode+= sizeof(uint16);
uint16 *ptrExteriorEdgeIndex= (uint16*)quadNode;
// For each one, add it to the result list.
for (i=0;i<numExteriorEdgeIndexes;i++)
{
uint16 index = ptrExteriorEdgeIndex[i];
// if ochain not yet inserted.
if (indexLUT[index]==0xFFFF)
{
// inc the list.
indexLUT[index]= uint16(nRes);
cst.ExteriorEdgeIndexes.push_back(index);
nRes++;
}
}
}
}
// reset LUT to 0xFFFF for all ochains selected.
for(i=0;i<nRes;i++)
indexLUT[cst.ExteriorEdgeIndexes[i]]= 0xFFFF;
return nRes;
}
sint CEdgeQuad::selectEdges(CVector start, CVector end, CCollisionSurfaceTemp &cst) const
{
sint nRes=0;
sint i;
uint16 *indexLUT= cst.OChainLUT;
// start: no edge found.
cst.ExteriorEdgeIndexes.clear();
if (end.x < start.x)
swap(start, end);
float minx = _X*_QuadElementSize,
miny = _Y*_QuadElementSize,
maxx = minx + _Width*_QuadElementSize,
maxy = miny + _Height*_QuadElementSize;
if (start.x > maxx || end.x < minx || start.y > maxy || end.y < miny)
return nRes;
if (start.x < minx)
{
start.y = start.y+(end.y-start.y)*(minx-start.x)/(end.x-start.x);
start.x = minx;
}
if (start.y < miny)
{
start.x = start.x+(end.x-start.x)*(miny-start.y)/(end.y-start.y);
start.y = miny;
}
if (end.x > maxx)
{
end.y = start.y+(end.y-start.y)*(minx-start.x)/(end.x-start.x);
end.x = maxx;
}
if (end.y > maxy)
{
end.x = start.x+(end.x-start.x)*(miny-start.y)/(end.y-start.y);
end.y = maxy;
}
sint32 x0, x1, ya, yb;
sint x, y;
float fx, fxa, fxb, fya, fyb;
x0 = (sint32)floor(start.x / _QuadElementSize) - _X;
x1 = (sint32)ceil(end.x / _QuadElementSize) - _X;
fx = (x0+_X)*_QuadElementSize;
for (x=x0; x<x1; ++x)
{
fxa = (fx < start.x) ? start.x : fx;
fxb = (fx+_QuadElementSize > end.x) ? end.x : fx+_QuadElementSize;
fya = start.y+(end.y-start.y)*(fxa-start.x)/(end.x-start.x);
fyb = start.y+(end.y-start.y)*(fxb-start.x)/(end.x-start.x);
if (fya > fyb)
swap (fya, fyb);
ya = (sint32)floor(fya / _QuadElementSize) - _Y;
yb = (sint32)ceil(fyb / _QuadElementSize) - _Y;
fx += _QuadElementSize;
for (y=ya; y<yb; ++y)
{
uint8 *quadNode= _Quad[y*_Width+x];
// no edgechain entry??
if(!quadNode)
continue;
// get edgechain entries
sint numExteriorEdgeIndexes= *((uint16 *)quadNode);
quadNode+= sizeof(uint16);
uint16 *ptrExteriorEdgeIndex = (uint16 *)quadNode;
// For each one, add it to the result list.
for(i=0;i<numExteriorEdgeIndexes;i++)
{
uint16 index = ptrExteriorEdgeIndex[i];
// if ochain not yet inserted.
if(indexLUT[index]==0xFFFF)
{
// inc the list.
indexLUT[index]= uint16(nRes);
cst.ExteriorEdgeIndexes.push_back(ptrExteriorEdgeIndex[i]);
nRes++;
}
}
}
}
// reset LUT to 0xFFFF for all ochains selected.
for(i=0;i<nRes;i++)
indexLUT[cst.ExteriorEdgeIndexes[i]]= 0xFFFF;
return nRes;
}
// ***************************************************************************
void CEdgeQuad::serial(NLMISC::IStream &f)
{
/*
Version 0:
- base version.
*/
(void)f.serialVersion(0);
uint i;
// serial basics.
f.serial(_X, _Y, _Width, _Height, _QuadDataLen);
f.serialCont(_EdgeEntries);
// serial _QuadData.
if(f.isReading())
{
delete [] _QuadData;
if(_QuadDataLen>0)
_QuadData= (uint8*)new uint8[_QuadDataLen];
else
_QuadData= NULL;
}
// Since we have only uint16 (see CEdgeChainEntry), serial them in a single block.
uint16 *ptrQData= (uint16*)_QuadData;
for(i=0;i<_QuadDataLen/2; i++, ptrQData++)
{
f.serial(*ptrQData);
}
// serial _Quad.
std::vector<uint32> offsets;
uint32 len;
uint32 val;
if(f.isReading())
{
// len/resize.
f.serial(len);
offsets.resize(len);
contReset(_Quad);
_Quad.resize(len);
// read offsets -> ptrs.
for(i=0; i<len; i++)
{
f.serial(val);
if(val== 0xFFFFFFFF)
_Quad[i]= NULL;
else
_Quad[i]= _QuadData+val;
}
}
else
{
// len/resize.
len= (uint32)_Quad.size();
f.serial(len);
// write offsets.
for(i=0; i<len; i++)
{
uint8 *ptr= _Quad[i];
if(ptr==NULL)
val= 0xFFFFFFFF;
else
val= (uint32)(ptr-_QuadData);
f.serial(val);
}
}
}
} // NLPACS