NLPACS::CEdgeQuad Class Reference

#include <edge_quad.h>

---

Detailed Description

a quadgrid of list of edge chain.

Author:

Benjamin Legros

Nevrax France

Date:

2001

Definition at line 61 of file edge_quad.h.

Public Member Functions
void	build (const CExteriorMesh &em, const CGlobalRetriever &global, CCollisionSurfaceTemp &cst, uint32 thisInstance)
	build a chain quad, with a list of exterior Edges and the global retriever
	CEdgeQuad (const CEdgeQuad &o)
	Copy Constructor.
	CEdgeQuad ()
	Constructor.
void	clear ()
	clear
const std::vector< CExteriorEdgeEntry > &	getEdgeEntries () const
	Get the whole set of edge entries.
const CExteriorEdgeEntry &	getEdgeEntry (uint entry) const
	Get a single edge entry.
CEdgeQuad &	operator= (const CEdgeQuad &o)
	operator=.
void	removeLinks ()
void	removeLinks (sint32 instanceId)
sint	selectEdges (CVector start, CVector end, CCollisionSurfaceTemp &cst) const
sint	selectEdges (const NLMISC::CAABBox &bbox, CCollisionSurfaceTemp &cst) const
void	serial (NLMISC::IStream &f)
	serial.
	~CEdgeQuad ()
	Destructor.
Private Member Functions
void	getGridBounds (sint32 &x0, sint32 &y0, sint32 &x1, sint32 &y1, const CVector &minP, const CVector &maxP) const
Private Attributes
std::vector< CExteriorEdgeEntry >	_EdgeEntries
	The real exterior edge entries.
uint32	_Height
	Height of the quadgrid.
std::vector< uint8 * >	_Quad
uint8 *	_QuadData
	Single memory block of CExteriorEdgeEntry chains.
uint32	_QuadDataLen
	size (in byte) of _QuadData.
uint32	_Width
	Width of the quadgrid.
sint32	_X
	Postion of the chainquad.
sint32	_Y
	Postion of the chainquad.
Static Private Attributes
const float	_QuadElementSize = 4

---

Constructor & Destructor Documentation

NLPACS::CEdgeQuad::CEdgeQuad (   )

Constructor. Definition at line 44 of file edge_quad.cpp. { _QuadData= NULL; _QuadDataLen= 0; }

NLPACS::CEdgeQuad::CEdgeQuad (  const CEdgeQuad &  o  )

Copy Constructor. Definition at line 55 of file edge_quad.cpp. { _QuadData= NULL; _QuadDataLen= 0; *this= o; }

NLPACS::CEdgeQuad::~CEdgeQuad (   )

Destructor. Definition at line 50 of file edge_quad.cpp. References clear(). { clear(); }

---

Member Function Documentation

void NLPACS::CEdgeQuad::build (  const CExteriorMesh &  em, const CGlobalRetriever &  global, CCollisionSurfaceTemp &  cst, uint32  thisInstance )

build a chain quad, with a list of exterior Edges and the global retriever Definition at line 130 of file edge_quad.cpp. References _EdgeEntries, NLPACS::CCollisionSurfaceDesc::ContactSurface, NLPACS::CCollisionSurfaceDesc::ContactTime, NLMISC::CAABBox::extend(), NLPACS::CExteriorMesh::getEdges(), getGridBounds(), NLPACS::CGlobalRetriever::getInstance(), NLPACS::CExteriorMesh::getLink(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), NLPACS::CRetrieverInstance::getOrigin(), NLPACS::UGlobalPosition::InstanceId, len, NLPACS::UGlobalPosition::LocalPosition, NLMISC::CVector::maxof(), NLMISC::CVector::minof(), nlerror, nlinfo, nlwarning, NLPACS::CGlobalRetriever::retrievePosition(), NLPACS::CSurfaceIdent::RetrieverInstanceId, NLMISC::CAABBox::setCenter(), sint, sint32, NLPACS::ULocalPosition::Surface, NLPACS::CSurfaceIdent::SurfaceId, NLPACS::TCollisionSurfaceDescVector, NLPACS::CGlobalRetriever::testCylinderMove(), uint, uint16, uint32, uint8, NLPACS::CGlobalRetriever::updateHeight(), x, NLMISC::CVector::x, y, and NLMISC::CVector::y. Referenced by NLPACS::CRetrieverInstance::initEdgeQuad(). { 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 = 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(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+= 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= 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. }

void NLPACS::CEdgeQuad::clear (   )

clear Definition at line 100 of file edge_quad.cpp. References _EdgeEntries. Referenced by NLPACS::CRetrieverInstance::reset(), and ~CEdgeQuad(). { delete [] _QuadData; _QuadData= NULL; _QuadDataLen= 0; _Quad.clear(); _EdgeEntries.clear(); _Width = 0; _Height = 0; _X = 0; _Y = 0; }

const std::vector<CExteriorEdgeEntry>& NLPACS::CEdgeQuad::getEdgeEntries (   )  const [inline]

Get the whole set of edge entries. Definition at line 104 of file edge_quad.h. References _EdgeEntries. Referenced by NLPACS::CRetrieverInstance::linkEdgeQuad(). { return _EdgeEntries; }

const CExteriorEdgeEntry& NLPACS::CEdgeQuad::getEdgeEntry (  uint  entry  )  const [inline]

Get a single edge entry. Definition at line 106 of file edge_quad.h. References _EdgeEntries, and uint. Referenced by NLPACS::CRetrieverInstance::testExteriorCollision(). { return _EdgeEntries[entry]; }

void NLPACS::CEdgeQuad::getGridBounds (  sint32 &  x0, sint32 &  y0, sint32 &  x1, sint32 &  y1, const CVector &  minP, const CVector &  maxP )  const [private]

Definition at line 115 of file edge_quad.cpp. References min, sint32, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by build(), and selectEdges(). { 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); }

CEdgeQuad & NLPACS::CEdgeQuad::operator= (  const CEdgeQuad &  o  )

operator=. Definition at line 62 of file edge_quad.cpp. References _EdgeEntries, _Height, _Quad, _QuadData, _QuadDataLen, _Width, _X, _Y, sint, uint32, and uint8. { // 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 NLPACS::CEdgeQuad::removeLinks (   )  [inline]

Definition at line 127 of file edge_quad.h. References _EdgeEntries, and uint. { uint i; for (i=0; i<_EdgeEntries.size(); ++i) { _EdgeEntries[i].Exterior.RetrieverInstanceId = -1; _EdgeEntries[i].Exterior.SurfaceId = -1; } }

void NLPACS::CEdgeQuad::removeLinks (  sint32  instanceId  )  [inline]

Definition at line 113 of file edge_quad.h. References _EdgeEntries, sint32, and uint. Referenced by NLPACS::CRetrieverInstance::resetLinks(). { uint i; for (i=0; i<_EdgeEntries.size(); ++i) { if (_EdgeEntries[i].Exterior.RetrieverInstanceId == instanceId) { _EdgeEntries[i].Exterior.RetrieverInstanceId = -1; _EdgeEntries[i].Exterior.SurfaceId = -1; } } }

sint NLPACS::CEdgeQuad::selectEdges (  CVector  start, CVector  end, CCollisionSurfaceTemp &  cst )  const

look in the quad to select a list of chain from a line. NB: The outpout do not contains any redundant edge. An edge appears only one time in the result. Parameters: start  the starting point of the selection segment. end  the ending point of the selection segment. cst  the array of CExteriorEdgeEntry to fill. contain also OChainLUT, an array for internal use. In: must be filled with 0xFFFF. Out: still filled with 0xFFFF. Returns: number of exterioredge found. stored in cst.ExteriorEdgeEntries (array cleared first). Definition at line 465 of file edge_quad.cpp. References NLPACS::CCollisionSurfaceTemp::ExteriorEdgeIndexes, index, NLPACS::CCollisionSurfaceTemp::OChainLUT, sint, sint32, uint16, uint8, x, NLMISC::CVector::x, y, and NLMISC::CVector::y. { 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]= 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; }

sint NLPACS::CEdgeQuad::selectEdges (  const NLMISC::CAABBox &  bbox, CCollisionSurfaceTemp &  cst )  const

look in the quad to select a list of chain from a bbox. NB: The outpout do not contains any redundant edge. An edge appears only one time in the result. Parameters: bbox  the area of interest. cst  the array of CExteriorEdgeEntry to fill. contain also OChainLUT, an array for internal use. In: must be filled with 0xFFFF. Out: still filled with 0xFFFF. Returns: number of exterioredge found. stored in cst.ExteriorEdgeEntries (array cleared first). Definition at line 410 of file edge_quad.cpp. References NLPACS::CCollisionSurfaceTemp::ExteriorEdgeIndexes, getGridBounds(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), index, NLPACS::CCollisionSurfaceTemp::OChainLUT, sint, sint32, uint16, uint8, x, and y. Referenced by NLPACS::CRetrieverInstance::testExteriorCollision(). { 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]= 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; }

void NLPACS::CEdgeQuad::serial (  NLMISC::IStream &  f  )

serial. Definition at line 571 of file edge_quad.cpp. References _EdgeEntries, NLMISC::IStream::isReading(), len, NLMISC::IStream::serial(), NLMISC::IStream::serialCont(), NLMISC::IStream::serialVersion(), uint, uint16, uint32, and uint8. { /* 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= _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); } } }

---

Field Documentation

std::vector<CExteriorEdgeEntry> NLPACS::CEdgeQuad::_EdgeEntries [private]

The real exterior edge entries. Definition at line 145 of file edge_quad.h. Referenced by build(), clear(), getEdgeEntries(), getEdgeEntry(), operator=(), removeLinks(), and serial().

uint32 NLPACS::CEdgeQuad::_Height [private]

Height of the quadgrid. Definition at line 149 of file edge_quad.h. Referenced by operator=().

std::vector<uint8*> NLPACS::CEdgeQuad::_Quad [private]

W*H pointers on array of CExteriorEdgeEntry indexes. NULL if no edge in this quad. Each array is 1xuint16(LEN) + LEN*CExteriorEdgeEntryIndex(16 bits). Definition at line 143 of file edge_quad.h. Referenced by operator=().

uint8* NLPACS::CEdgeQuad::_QuadData [private]

Single memory block of CExteriorEdgeEntry chains. Definition at line 153 of file edge_quad.h. Referenced by operator=().

uint32 NLPACS::CEdgeQuad::_QuadDataLen [private]

size (in byte) of _QuadData. Definition at line 155 of file edge_quad.h. Referenced by operator=().

const float NLPACS::CEdgeQuad::_QuadElementSize = 4 [static, private]

Definition at line 40 of file edge_quad.cpp.

uint32 NLPACS::CEdgeQuad::_Width [private]

Width of the quadgrid. Definition at line 147 of file edge_quad.h. Referenced by operator=().

sint32 NLPACS::CEdgeQuad::_X [private]

Postion of the chainquad. Definition at line 151 of file edge_quad.h. Referenced by operator=().

sint32 NLPACS::CEdgeQuad::_Y [private]

Postion of the chainquad. Definition at line 151 of file edge_quad.h. Referenced by operator=().

---

The documentation for this class was generated from the following files:

• edge_quad.h
• edge_quad.cpp

---