NeL: NL3D::CPrimitiveBlock class Reference

00081 {
00082         setNumLine(getNumLine()+1);
00083         setLine(getNumLine()-1, vidx0, vidx1);
00084 }

00212 {
00213         setNumQuad(getNumQuad()+1);
00214         setQuad(getNumQuad()-1, vidx0, vidx1, vidx2, vidx3);
00215 }

00139 {
00140         setNumTri(getNumTri()+1);
00141         setTri(getNumTri()-1, vidx0, vidx1, vidx2);
00142 }

00083 {return _LineCapacity;}

00131 { return _QuadCapacity; }

00104 {return _TriCapacity;}

00047 {
00048         if(_Line.begin()==_Line.end())
00049                 return NULL;
00050         else
00051                 return(&(*_Line.begin()));
00052 }

00039 {
00040         if(_Line.begin()==_Line.end())
00041                 return NULL;
00042         else
00043                 return(&(*_Line.begin()));
00044 }

00087 {return _NbLines;}

00141 { return _NbQuads; }

00108 {return _NbTris;}

00161         {
00162                 // Return number of triangles in this primitive block
00163                 return _NbTris+2*_NbQuads+_NbLines;
00164         }

00158 {
00159         if(_Quad.begin()==_Quad.end())
00160                 return NULL;
00161         else
00162                 return(&(*_Quad.begin()));
00163 }

00150 {
00151         if(_Quad.begin()==_Quad.end())
00152                 return NULL;
00153         else
00154                 return(&(*_Quad.begin()));
00155 }

00100 {
00101         if(_Tri.begin()==_Tri.end())
00102                 return NULL;
00103         else
00104                 return(&(*_Tri.begin()));
00105 }

00092 {
00093         if(_Tri.begin()==_Tri.end())
00094                 return NULL;
00095         else
00096                 return(&(*_Tri.begin()));
00097 }

00057 {
00058         _Line.resize(n*2);
00059         _LineCapacity= n;
00060 }

00171 {
00172         _Quad.resize(n*4);
00173         _QuadCapacity = n;
00174 }

00110 {
00111         _Tri.resize(n*3);
00112         _TriCapacity= n;
00113 }

00220 {
00221         (void)f.serialVersion(0);
00222 
00223         f.serial(_NbLines, _LineCapacity);
00224         f.serialCont(_Line);
00225         f.serial(_NbTris, _TriCapacity);
00226         f.serialCont(_Tri);
00227         f.serial(_NbQuads, _QuadCapacity);
00228         f.serialCont(_Quad);
00229 
00230 }

00070 {
00071         uint32* ptr;
00072 
00073         ptr=(uint32*)(&_Line[lineIdx*2]);
00074         *ptr=vidx0;
00075         ptr++;
00076         *ptr=vidx1;
00077 }

00062 {
00063         if(_LineCapacity<n)
00064         {
00065                 reserveLine(n);
00066         }
00067         _NbLines= n;
00068 }

00181 {
00182         if(_QuadCapacity<n)
00183         {
00184                 reserveQuad(n);
00185         }
00186         _NbQuads = n;
00187 }

00115 {
00116         if(_TriCapacity<n)
00117         {
00118                 reserveTri(n);
00119         }
00120         _NbTris= n;
00121 }

00194 {
00195         uint32* ptr;
00196 
00197         ptr = (uint32*)(&_Quad[quadIdx*4]);
00198         *ptr = vidx0;
00199         ptr++;
00200         *ptr = vidx1;
00201         ptr++;
00202         *ptr = vidx2;
00203         ptr++;
00204         *ptr = vidx3;
00205 }

00123 {
00124         #ifdef NL_DEBUG
00125                 nlassert((sint) triIdx <= ((sint) _Tri.size() - 3));
00126         #endif
00127         uint32* ptr;
00128 
00129         ptr=(uint32*)(&_Tri[triIdx*3]);
00130         *ptr=vidx0;
00131         ptr++;
00132         *ptr=vidx1;
00133         ptr++;
00134         *ptr=vidx2;
00135 }


Public Member Functions
void	addLine (uint32 vidx0, uint32 vidx1)
	Apend a line at getNumLine() (then resize +1 the numline).
void	addQuad (uint32 vidx0, uint32 vidx1, uint32 vidx2, uint32 vidx3)
	Apend a quad at getNumQuad() (then resize +1 the numquad).
void	addTri (uint32 vidx0, uint32 vidx1, uint32 vidx2)
	Apend a triangle at getNumTri() (then resize +1 the numtri).
uint32	capacityLine () const
	Return the number of Line reserved.
uint32	capacityQuad ()
uint32	capacityTri ()
	Return the number of triangles reserved.
	CPrimitiveBlock (void)
const uint32 *	getLinePointer (void) const
uint32 *	getLinePointer (void)
uint32	getNumLine (void) const
	Get the number of active Lineangles.
uint32	getNumQuad (void) const
uint32	getNumTri (void) const
	Get the number of active triangles.
uint32	getNumTriangles ()
	return total number of triangle in this primitive block
const uint32 *	getQuadPointer (void) const
	return the quad buffer, const version
uint32 *	getQuadPointer (void)
const uint32 *	getTriPointer (void) const
uint32 *	getTriPointer (void)
void	reserveLine (uint32 n)
	reserve space for nLines Line. You are allowed to write your Line indices on this space.
void	reserveQuad (uint32 n)
void	reserveTri (uint32 n)
	reserve space for nTris triangles. You are allowed to write your triangles indices on this space.
void	serial (NLMISC::IStream &f)
void	setLine (uint lineIdx, uint32 vidx0, uint32 vidx1)
	Build a Lineangle.
void	setNumLine (uint32 n)
	Set the number of active Line. It enlarge Line capacity, if needed.
void	setNumQuad (uint32 n)
void	setNumTri (uint32 n)
	Set the number of active triangles. It enlarge Tri capacity, if needed.
void	setQuad (uint quadIdx, uint32 vidx0, uint32 vidx1, uint32 vidx2, uint32 vidx3)
void	setTri (uint triIdx, uint32 vidx0, uint32 vidx1, uint32 vidx2)
	Build a triangle.
	~CPrimitiveBlock (void)
Private Attributes
uint32 *	_Fan
uint32	_FanIdx
std::vector< uint32 >	_Line
uint32	_LineCapacity
uint32	_NbLines
uint32	_NbQuads
uint32	_NbTris
std::vector< uint32 >	_Quad
uint32	_QuadCapacity
uint32 *	_Strip
uint32	_StripIdx
std::vector< uint32 >	_Tri
uint32	_TriCapacity

NL3D::CPrimitiveBlock Class Reference

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation