VMAP::WmoLiquid Class Reference

#include <WorldModel.h>

Public Member Functions
	WmoLiquid (uint32 width, uint32 height, const G3D::Vector3 &corner, uint32 type)
	WmoLiquid (const WmoLiquid &other)
	~WmoLiquid ()
WmoLiquid &	operator= (const WmoLiquid &other)
bool	GetLiquidHeight (const G3D::Vector3 &pos, float &liqHeight) const
uint32	GetType () const
float *	GetHeightStorage ()
uint8 *	GetFlagsStorage ()
uint32	GetFileSize ()
bool	writeToFile (FILE *wf)
void	getPosInfo (uint32 &tilesX, uint32 &tilesY, G3D::Vector3 &corner) const

Static Public Member Functions
static bool	readFromFile (FILE *rf, WmoLiquid *&liquid)

Private Member Functions
	WmoLiquid ()

Private Attributes
uint32	iTilesX
	number of tiles in x direction, each More...
uint32	iTilesY
G3D::Vector3	iCorner
	the lower corner More...
uint32	iType
	liquid type More...
float *	iHeight
	(tilesX + 1)*(tilesY + 1) height values More...
uint8 *	iFlags
	info if liquid tile is used More...

Constructor & Destructor Documentation

VMAP::WmoLiquid::WmoLiquid	(	uint32	width,
		uint32	height,
		const G3D::Vector3 &	corner,
		uint32	type
	)

 :
 iTilesX(width), iTilesY(height), iCorner(corner), iType(type)
 {
 iHeight = new float[(width+1)*(height+1)];
 iFlags = new uint8[width*height];
 }

VMAP::WmoLiquid::WmoLiquid

(

const WmoLiquid &

other

)

 : iHeight(nullptr), iFlags(nullptr)
 {
 *this = other; // use assignment operator...
 }

VMAP::WmoLiquid::~WmoLiquid

(

)

 {
 delete[] iHeight;
 delete[] iFlags;
 }

VMAP::WmoLiquid::WmoLiquid ( )

inlineprivate

: iTilesX(0), iTilesY(0), iCorner(), iType(0), iHeight(NULL), iFlags(NULL) { }

Here is the caller graph for this function:

Member Function Documentation

uint32 VMAP::WmoLiquid::GetFileSize

(

)

 {
 return 2 * sizeof(uint32) +
 sizeof(Vector3) +
 (iTilesX + 1)*(iTilesY + 1) * sizeof(float) +
 iTilesX * iTilesY;
 }

Here is the caller graph for this function:

uint8* VMAP::WmoLiquid::GetFlagsStorage ( )

inline

{ return iFlags; }

Here is the caller graph for this function:

float* VMAP::WmoLiquid::GetHeightStorage ( )

inline

{ return iHeight; }

Here is the caller graph for this function:

bool VMAP::WmoLiquid::GetLiquidHeight	(	const G3D::Vector3 &	pos,
		float &	liqHeight
	)		const

 {
 float tx_f = (pos.x - iCorner.x)/LIQUID_TILE_SIZE;
 uint32 tx = uint32(tx_f);
 if (tx_f < 0.0f || tx >= iTilesX)
 return false;
 float ty_f = (pos.y - iCorner.y)/LIQUID_TILE_SIZE;
 uint32 ty = uint32(ty_f);
 if (ty_f < 0.0f || ty >= iTilesY)
 return false;

 // check if tile shall be used for liquid level
 // checking for 0x08 *might* be enough, but disabled tiles always are 0x?F:
 if ((iFlags[tx + ty*iTilesX] & 0x0F) == 0x0F)
 return false;

 // (dx, dy) coordinates inside tile, in [0, 1]^2
 float dx = tx_f - (float)tx;
 float dy = ty_f - (float)ty;

 /* Tesselate tile to two triangles (not sure if client does it exactly like this)

 ^ dy
 |
 1 x---------x (1, 1)
 | (b) / |
 | / |
 | / |
 | / (a) |
 x---------x---> dx
 0 1
 */

 const uint32 rowOffset = iTilesX + 1;
 if (dx > dy) // case (a)
 {
 float sx = iHeight[tx+1 + ty * rowOffset] - iHeight[tx + ty * rowOffset];
 float sy = iHeight[tx+1 + (ty+1) * rowOffset] - iHeight[tx+1 + ty * rowOffset];
 liqHeight = iHeight[tx + ty * rowOffset] + dx * sx + dy * sy;
 }
 else // case (b)
 {
 float sx = iHeight[tx+1 + (ty+1) * rowOffset] - iHeight[tx + (ty+1) * rowOffset];
 float sy = iHeight[tx + (ty+1) * rowOffset] - iHeight[tx + ty * rowOffset];
 liqHeight = iHeight[tx + ty * rowOffset] + dx * sx + dy * sy;
 }
 return true;
 }

Here is the caller graph for this function:

void VMAP::WmoLiquid::getPosInfo	(	uint32 &	tilesX,
		uint32 &	tilesY,
		G3D::Vector3 &	corner
	)		const

 {
 tilesX = iTilesX;
 tilesY = iTilesY;
 corner = iCorner;
 }

Here is the caller graph for this function:

uint32 VMAP::WmoLiquid::GetType ( ) const

inline

{ return iType; }

Here is the caller graph for this function:

WmoLiquid & VMAP::WmoLiquid::operator=

(

const WmoLiquid &

other

)

 {
 if (this == &other)
 return *this;
 iTilesX = other.iTilesX;
 iTilesY = other.iTilesY;
 iCorner = other.iCorner;
 iType = other.iType;
 delete iHeight;
 delete iFlags;
 if (other.iHeight)
 {
 iHeight = new float[(iTilesX+1)*(iTilesY+1)];
 memcpy(iHeight, other.iHeight, (iTilesX+1)*(iTilesY+1)*sizeof(float));
 }
 else
 iHeight = nullptr;
 if (other.iFlags)
 {
 iFlags = new uint8[iTilesX * iTilesY];
 memcpy(iFlags, other.iFlags, iTilesX * iTilesY);
 }
 else
 iFlags = nullptr;
 return *this;
 }

bool VMAP::WmoLiquid::readFromFile ( FILE *  rf, WmoLiquid *&  liquid  )

static

 {
 bool result = false;
 WmoLiquid* liquid = new WmoLiquid();

 if (fread(&liquid->iTilesX, sizeof(uint32), 1, rf) == 1 &&
 fread(&liquid->iTilesY, sizeof(uint32), 1, rf) == 1 &&
 fread(&liquid->iCorner, sizeof(Vector3), 1, rf) == 1 &&
 fread(&liquid->iType, sizeof(uint32), 1, rf) == 1)
 {
 uint32 size = (liquid->iTilesX + 1) * (liquid->iTilesY + 1);
 liquid->iHeight = new float[size];
 if (fread(liquid->iHeight, sizeof(float), size, rf) == size)
 {
 size = liquid->iTilesX * liquid->iTilesY;
 liquid->iFlags = new uint8[size];
 result = fread(liquid->iFlags, sizeof(uint8), size, rf) == size;
 }
 }

 if (!result)
 delete liquid;
 else
 out = liquid;

 return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool VMAP::WmoLiquid::writeToFile

(

FILE *

wf

)

 {
 bool result = false;
 if (fwrite(&iTilesX, sizeof(uint32), 1, wf) == 1 &&
 fwrite(&iTilesY, sizeof(uint32), 1, wf) == 1 &&
 fwrite(&iCorner, sizeof(Vector3), 1, wf) == 1 &&
 fwrite(&iType, sizeof(uint32), 1, wf) == 1)
 {
 uint32 size = (iTilesX + 1) * (iTilesY + 1);
 if (fwrite(iHeight, sizeof(float), size, wf) == size)
 {
 size = iTilesX*iTilesY;
 result = fwrite(iFlags, sizeof(uint8), size, wf) == size;
 }
 }

 return result;
 }

Here is the caller graph for this function:

Member Data Documentation

G3D::Vector3 VMAP::WmoLiquid::iCorner

private

the lower corner

uint8* VMAP::WmoLiquid::iFlags

private

info if liquid tile is used

float* VMAP::WmoLiquid::iHeight

private

(tilesX + 1)*(tilesY + 1) height values

uint32 VMAP::WmoLiquid::iTilesX

private

number of tiles in x direction, each

uint32 VMAP::WmoLiquid::iTilesY

private

uint32 VMAP::WmoLiquid::iType

private

liquid type

---

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

• src/common/Collision/Models/WorldModel.h
• src/common/Collision/Models/WorldModel.cpp