VMAP::GroupModel_Raw Struct Reference

#include <TileAssembler.h>

Public Member Functions
	GroupModel_Raw ()
	~GroupModel_Raw ()
bool	Read (FILE *f)

Public Attributes
uint32	mogpflags
uint32	GroupWMOID
G3D::AABox	bounds
uint32	liquidflags
std::vector< MeshTriangle >	triangles
std::vector< G3D::Vector3 >	vertexArray
class WmoLiquid *	liquid

Constructor & Destructor Documentation

VMAP::GroupModel_Raw::GroupModel_Raw ( )

inline

 : mogpflags(0), GroupWMOID(0), liquidflags(0),
 liquid(NULL) { }

VMAP::GroupModel_Raw::~GroupModel_Raw

(

)

 {
 delete liquid;
 }

Member Function Documentation

bool VMAP::GroupModel_Raw::Read

(

FILE *

f

)

 {
 char blockId[5];
 blockId[4] = 0;
 int blocksize;
 int readOperation = 0;

 READ_OR_RETURN(&mogpflags, sizeof(uint32));
 READ_OR_RETURN(&GroupWMOID, sizeof(uint32));


 Vector3 vec1, vec2;
 READ_OR_RETURN(&vec1, sizeof(Vector3));

 READ_OR_RETURN(&vec2, sizeof(Vector3));
 bounds.set(vec1, vec2);

 READ_OR_RETURN(&liquidflags, sizeof(uint32));

 // will this ever be used? what is it good for anyway??
 uint32 branches;
 READ_OR_RETURN(&blockId, 4);
 CMP_OR_RETURN(blockId, "GRP ");
 READ_OR_RETURN(&blocksize, sizeof(int));
 READ_OR_RETURN(&branches, sizeof(uint32));
 for (uint32 b=0; b<branches; ++b)
 {
 uint32 indexes;
 // indexes for each branch (not used jet)
 READ_OR_RETURN(&indexes, sizeof(uint32));
 }

 // ---- indexes
 READ_OR_RETURN(&blockId, 4);
 CMP_OR_RETURN(blockId, "INDX");
 READ_OR_RETURN(&blocksize, sizeof(int));
 uint32 nindexes;
 READ_OR_RETURN(&nindexes, sizeof(uint32));
 if (nindexes >0)
 {
 uint16 *indexarray = new uint16[nindexes];
 READ_OR_RETURN_WITH_DELETE(indexarray, nindexes*sizeof(uint16));
 triangles.reserve(nindexes / 3);
 for (uint32 i=0; i<nindexes; i+=3)
 triangles.push_back(MeshTriangle(indexarray[i], indexarray[i+1], indexarray[i+2]));

 delete[] indexarray;
 }

 // ---- vectors
 READ_OR_RETURN(&blockId, 4);
 CMP_OR_RETURN(blockId, "VERT");
 READ_OR_RETURN(&blocksize, sizeof(int));
 uint32 nvectors;
 READ_OR_RETURN(&nvectors, sizeof(uint32));

 if (nvectors >0)
 {
 float *vectorarray = new float[nvectors*3];
 READ_OR_RETURN_WITH_DELETE(vectorarray, nvectors*sizeof(float)*3);
 for (uint32 i=0; i<nvectors; ++i)
 vertexArray.push_back( Vector3(vectorarray + 3*i) );

 delete[] vectorarray;
 }
 // ----- liquid
 liquid = 0;
 if (liquidflags& 1)
 {
 WMOLiquidHeader hlq;
 READ_OR_RETURN(&blockId, 4);
 CMP_OR_RETURN(blockId, "LIQU");
 READ_OR_RETURN(&blocksize, sizeof(int));
 READ_OR_RETURN(&hlq, sizeof(WMOLiquidHeader));
 liquid = new WmoLiquid(hlq.xtiles, hlq.ytiles, Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), hlq.type);
 uint32 size = hlq.xverts*hlq.yverts;
 READ_OR_RETURN(liquid->GetHeightStorage(), size*sizeof(float));
 size = hlq.xtiles*hlq.ytiles;
 READ_OR_RETURN(liquid->GetFlagsStorage(), size);
 }

 return true;
 }

Here is the call graph for this function:

Member Data Documentation

G3D::AABox VMAP::GroupModel_Raw::bounds

uint32 VMAP::GroupModel_Raw::GroupWMOID

class WmoLiquid* VMAP::GroupModel_Raw::liquid

uint32 VMAP::GroupModel_Raw::liquidflags

uint32 VMAP::GroupModel_Raw::mogpflags

std::vector<MeshTriangle> VMAP::GroupModel_Raw::triangles

std::vector<G3D::Vector3> VMAP::GroupModel_Raw::vertexArray

---

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

• src/common/Collision/Maps/TileAssembler.h
• src/common/Collision/Maps/TileAssembler.cpp