From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02379.html | 472 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 472 insertions(+) create mode 100644 docs/doxygen/nel/a02379.html (limited to 'docs/doxygen/nel/a02379.html') diff --git a/docs/doxygen/nel/a02379.html b/docs/doxygen/nel/a02379.html new file mode 100644 index 00000000..9e652c79 --- /dev/null +++ b/docs/doxygen/nel/a02379.html @@ -0,0 +1,472 @@ + + +NeL: NLPACS::CCollisionMeshBuild class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLPACS::CCollisionMeshBuild Class Reference

#include <collision_mesh_build.h> +

+

Detailed Description

+The collision intermediate mesh, used to build the real collision meshes.
Author:
Benjamin Legros

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 107 of file collision_mesh_build.h. + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

NLMISC::CVector computeTrivialTranslation () const
void link (bool linkInterior, std::vector< std::string > &errors)
void serial (NLMISC::IStream &f)
void transform (const NLMISC::CMatrix &tranfo)
void translate (const NLMISC::CVector &translation)

Data Fields

std::vector< CCollisionFace > Faces
 The faces of the mesh.

std::vector< NLMISC::CVector > Vertices
 The vertices of the mesh.


Private Types

typedef TLinkRelloc::iterator ItTLinkRelloc
typedef std::map< CEdgeKey,
+ CEdgeInfo, CEdgeKey > 		TLinkRelloc
+

Member Typedef Documentation

+

+ + + + +
+ + +
typedef TLinkRelloc::iterator NLPACS::CCollisionMeshBuild::ItTLinkRelloc [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 135 of file collision_mesh_build.h. +

+Referenced by link().

+

+ + + + +
+ + +
typedef std::map<CEdgeKey, CEdgeInfo, CEdgeKey> NLPACS::CCollisionMeshBuild::TLinkRelloc [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 134 of file collision_mesh_build.h. +

+Referenced by link().

+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
NLMISC::CVector NLPACS::CCollisionMeshBuild::computeTrivialTranslation (   )  const [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 169 of file collision_mesh_build.h. +

+References NLMISC::CAABBox::extend(), NLMISC::CAABBox::getCenter(), NLMISC::CAABBox::setCenter(), and uint. +

+Referenced by NLPACS::computeRetriever(). +

+

00170         {
+00171                 uint    i;
+00172                 NLMISC::CAABBox bbox;
+00173 
+00174                 if (!Vertices.empty())
+00175                 {
+00176                         bbox.setCenter(Vertices[0]);
+00177                         for (i=1; i<Vertices.size(); ++i)
+00178                                 bbox.extend(Vertices[i]);
+00179                 }
+00180 
+00181                 return -bbox.getCenter();
+00182         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLPACS::CCollisionMeshBuild::link ( bool  linkInterior,
std::vector< std::string > &  errors
)  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 185 of file collision_mesh_build.h. +

+References ItTLinkRelloc, NLPACS::CCollisionFace::Material, sint32, NLPACS::CCollisionFace::Surface, TLinkRelloc, uint, uint32, NLPACS::CCollisionFace::V, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. +

+Referenced by NLPACS::computeRetriever(). +

+

00186         {
+00187                 uint                    i, j;
+00188                 TLinkRelloc             relloc;
+00189 
+00190 
+00191                 // check each edge of each face
+00192                 for (i=0; i<Faces.size(); ++i)
+00193                 {
+00194                         if (Faces[i].Surface == CCollisionFace::ExteriorSurface && linkInterior ||
+00195                                 Faces[i].Surface >= CCollisionFace::InteriorSurfaceFirst && !linkInterior)
+00196                                 continue;
+00197 
+00198                         for (j=0; j<3; ++j)
+00199                         {
+00200                                 Faces[i].Edge[j] = -1;
+00201 
+00202                                 uint    edge = (j+2)%3;
+00203                                 uint32  va = Faces[i].V[j],
+00204                                                 vb = Faces[i].V[(j+1)%3];
+00205 
+00206                                 ItTLinkRelloc   it;
+00207                                 if ((it = relloc.find(CEdgeKey(va, vb))) != relloc.end())
+00208                                 {
+00209                                         CCollisionFace  &left0 = Faces[(*it).second.Left];
+00210                                         CCollisionFace  &left1 = Faces[i];
+00211                                         // in this case, the left triangle of the edge has already been found.
+00212                                         // should throw an error
+00213                                         NLMISC::CVector eva = Vertices[va], evb = Vertices[vb];
+00214                                         static char     buf[512];
+00215                                         sprintf(buf, "Edge issue: (%.2f,%.2f,%.2f)-(%.2f,%.2f,%.2f) [left face already found]\n"
+00216                                                                  "left.0:%d: v0:(%.2f,%.2f) v1:(%.2f,%.2f), v2:(%.2f,%.2f) surf=%d material=%d\n"
+00217                                                                  "left.1:%d: v0:(%.2f,%.2f) v1:(%.2f,%.2f), v2:(%.2f,%.2f) surf=%d material=%d",
+00218                                                                         eva.x, eva.y, eva.z, evb.x, evb.y, evb.z,
+00219                                                                         (*it).second.Left, Vertices[left0.V[0]].x, Vertices[left0.V[0]].y, Vertices[left0.V[1]].x, Vertices[left0.V[1]].y, Vertices[left0.V[2]].x, Vertices[left0.V[2]].y, Faces[(*it).second.Left].Surface, Faces[(*it).second.Left].Material, 
+00220                                                                         i,                 Vertices[left1.V[0]].x, Vertices[left1.V[0]].y, Vertices[left1.V[1]].x, Vertices[left1.V[1]].y, Vertices[left1.V[2]].x, Vertices[left1.V[2]].y, Faces[i].Surface, Faces[i].Material);
+00221                                         errors.push_back(std::string(buf));
+00222                                         continue;
+00223 /*                                      nlerror("On face %d, edge %d: left side of edge (%d,%d) already linked to face %d",
+00224                                                         i, edge, va, vb, (*it).second.Left);*/
+00225                                 }
+00226                                 else if ((it = relloc.find(CEdgeKey(vb, va))) != relloc.end())
+00227                                 {
+00228                                         // in this case, we must check the right face has been set yet
+00229                                         if ((*it).second.Right != -1)
+00230                                         {
+00231                                                 CCollisionFace  &right0 = Faces[(*it).second.Right];
+00232                                                 CCollisionFace  &right1 = Faces[i];
+00233                                                 NLMISC::CVector eva = Vertices[va], evb = Vertices[vb];
+00234                                                 static char     buf[512];
+00235                                                 sprintf(buf, "Edge issue: (%.2f,%.2f,%.2f)-(%.2f,%.2f,%.2f) [right face already found]\n"
+00236                                                                          "right.0:%d: v0:(%.2f,%.2f) v1:(%.2f,%.2f), v2:(%.2f,%.2f)\n"
+00237                                                                          "right.1:%d: v0:(%.2f,%.2f) v1:(%.2f,%.2f), v2:(%.2f,%.2f)",
+00238                                                                                 eva.x, eva.y, eva.z, evb.x, evb.y, evb.z,
+00239                                                                                 (*it).second.Right, Vertices[right0.V[0]].x, Vertices[right0.V[0]].y, Vertices[right0.V[1]].x, Vertices[right0.V[1]].y, Vertices[right0.V[2]].x, Vertices[right0.V[2]].y,
+00240                                                                                 i,                  Vertices[right1.V[0]].x, Vertices[right1.V[0]].y, Vertices[right1.V[1]].x, Vertices[right1.V[1]].y, Vertices[right1.V[2]].x, Vertices[right1.V[2]].y);
+00241                                                 errors.push_back(std::string(buf));
+00242                                                 continue;
+00243 /*                                              nlerror("On face %d, edge %d: right side of edge (%d,%d) already linked to face %d",
+00244                                                                 i, edge, vb, va, (*it).second.Right);*/
+00245                                         }
+00246 
+00247                                         (*it).second.Right = i;
+00248                                         (*it).second.RightEdge = edge;
+00249                                 }
+00250                                 else
+00251                                 {
+00252                                         // if the edge wasn't present yet, create it and set it up.
+00253                                         relloc.insert(std::make_pair(CEdgeKey(va, vb), CEdgeInfo(i, edge, -1, -1)));
+00254                                 }
+00255                         }
+00256                 }
+00257 
+00258                 // for each checked edge, update the edge info inside the faces
+00259                 ItTLinkRelloc   it;
+00260                 for (it=relloc.begin(); it!=relloc.end(); ++it)
+00261                 {
+00262                         sint32  left, leftEdge;
+00263                         sint32  right, rightEdge;
+00264 
+00265                         // get the link info on the edge
+00266                         left = (*it).second.Left;
+00267                         leftEdge = (*it).second.LeftEdge;
+00268                         right = (*it).second.Right;
+00269                         rightEdge = (*it).second.RightEdge;
+00270 
+00271                         // update both faces
+00272                         if (left != -1)
+00273                                 Faces[left].Edge[leftEdge] = right;
+00274                         if (right != -1)
+00275                                 Faces[right].Edge[rightEdge] = left;
+00276                 }
+00277         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLPACS::CCollisionMeshBuild::serial ( NLMISC::IStream &  f  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 149 of file collision_mesh_build.h. +

+References NLMISC::IStream::serialCont(). +

+

00150         {
+00151                 f.serialCont(Vertices);
+00152                 f.serialCont(Faces);
+00153         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLPACS::CCollisionMeshBuild::transform ( const NLMISC::CMatrix &  tranfo  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 162 of file collision_mesh_build.h. +

+References uint. +

+

00163         {
+00164                 uint    i;
+00165                 for (i=0; i<Vertices.size(); ++i)
+00166                         Vertices[i] = tranfo * Vertices[i];
+00167         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLPACS::CCollisionMeshBuild::translate ( const NLMISC::CVector &  translation  )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 155 of file collision_mesh_build.h. +

+References uint. +

+Referenced by NLPACS::computeRetriever(). +

+

00156         {
+00157                 uint    i;
+00158                 for (i=0; i<Vertices.size(); ++i)
+00159                         Vertices[i] += translation;
+00160         }
+
+

Field Documentation

+

+ + + + +
+ + +
std::vector<CCollisionFace> NLPACS::CCollisionMeshBuild::Faces +
+
+ + + + + +
+   + + +

+The faces of the mesh. +

+ +

+Definition at line 145 of file collision_mesh_build.h. +

+Referenced by NLPACS::buildExteriorMesh(), NLPACS::buildSnapping(), NLPACS::computeSurfaceBorders(), NLPACS::computeSurfaceQuadTree(), NLPACS::floodFillSurfaces(), NLPACS::followBorder(), NLPACS::CInteriorSurface::getFace(), NLPACS::CInteriorSurface::getNeighbor(), and NLPACS::resetEdgeFlags().

+

+ + + + +
+ + +
std::vector<NLMISC::CVector> NLPACS::CCollisionMeshBuild::Vertices +
+
+ + + + + +
+   + + +

+The vertices of the mesh. +

+ +

+Definition at line 142 of file collision_mesh_build.h. +

+Referenced by NLPACS::buildExteriorMesh(), NLPACS::buildSnapping(), NLPACS::computeSurfaceCenter(), NLPACS::computeSurfaceQuadTree(), and NLPACS::followBorder().

+

The documentation for this class was generated from the following file: +
Generated on Tue Mar 16 14:10:12 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1