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 {0}
	number of tiles in x direction, each
uint32	iTilesY {0}
G3D::Vector3	iCorner
	the lower corner
uint32	iType {0}
	liquid type
float *	iHeight {nullptr}
	(tilesX + 1)*(tilesY + 1) height values
uint8 *	iFlags {nullptr}
	info if liquid tile is used

Detailed Description

Constructor & Destructor Documentation

WmoLiquid() [1/3]

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

WmoLiquid() [2/3]

VMAP::WmoLiquid::WmoLiquid

(

const WmoLiquid &

other

)

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

~WmoLiquid()

VMAP::WmoLiquid::~WmoLiquid

(

)

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

References iFlags, and iHeight.

WmoLiquid() [3/3]

VMAP::WmoLiquid::WmoLiquid ( )

inlineprivate

{ }

Referenced by readFromFile().

Member Function Documentation

GetFileSize()

uint32 VMAP::WmoLiquid::GetFileSize

(

)

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

References iFlags, iTilesX, and iTilesY.

Referenced by VMAP::GroupModel::writeToFile().

GetFlagsStorage()

uint8 * VMAP::WmoLiquid::GetFlagsStorage ( )

inline

{ return iFlags; }

References iFlags.

Referenced by MMAP::TerrainBuilder::loadVMap(), and VMAP::GroupModel_Raw::Read().

GetHeightStorage()

float * VMAP::WmoLiquid::GetHeightStorage ( )

inline

{ return iHeight; }

References iHeight.

Referenced by MMAP::TerrainBuilder::loadVMap(), and VMAP::GroupModel_Raw::Read().

GetLiquidHeight()

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

    {
        // simple case
        if (!iFlags)
        {
            liqHeight = iHeight[0];
            return true;
        }
 
        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 && (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
        */
 
        if (!iHeight)
        {
            return false;
        }
 
        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;
    }

References iCorner, iFlags, iHeight, iTilesX, iTilesY, and LIQUID_TILE_SIZE.

Referenced by VMAP::GroupModel::GetLiquidLevel().

GetPosInfo()

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

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

References iCorner, iTilesX, and iTilesY.

Referenced by MMAP::TerrainBuilder::loadVMap().

GetType()

uint32 VMAP::WmoLiquid::GetType ( ) const

inline

{ return iType; }

References iType.

Referenced by VMAP::GroupModel::GetLiquidType(), and MMAP::TerrainBuilder::loadVMap().

operator=()

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 = 0;
        }
        if (other.iFlags)
        {
            iFlags = new uint8[iTilesX * iTilesY];
            memcpy(iFlags, other.iFlags, iTilesX * iTilesY);
        }
        else
        {
            iFlags = 0;
        }
        return *this;
    }

References iCorner, iFlags, iHeight, iTilesX, iTilesY, and iType.

readFromFile()

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)
        {
            if (liquid->iTilesX && liquid->iTilesY)
            {
                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;
                }
            }
            else
            {
                liquid->iHeight = new float[1];
                result = fread(liquid->iHeight, sizeof(float), 1, rf) == 1;
            }
        }
 
        if (!result)
        {
            delete liquid;
        }
        else
        {
            out = liquid;
        }
 
        return result;
    }

References iCorner, iFlags, iHeight, iTilesX, iTilesY, iType, and WmoLiquid().

Referenced by VMAP::GroupModel::readFromFile().

writeToFile()

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)
        {
            if (iTilesX && iTilesY)
            {
                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;
                }
            }
            else
                result = fwrite(iHeight, sizeof(float), 1, wf) == 1;
        }
 
        return result;
    }

References iCorner, iFlags, iHeight, iTilesX, iTilesY, and iType.

Referenced by VMAP::GroupModel::writeToFile().

Member Data Documentation

iCorner

G3D::Vector3 VMAP::WmoLiquid::iCorner

private

the lower corner

Referenced by GetLiquidHeight(), GetPosInfo(), operator=(), readFromFile(), and writeToFile().

iFlags

uint8* VMAP::WmoLiquid::iFlags {nullptr}

private

info if liquid tile is used

{nullptr};  

Referenced by GetFileSize(), GetFlagsStorage(), GetLiquidHeight(), operator=(), readFromFile(), writeToFile(), and ~WmoLiquid().

iHeight

float* VMAP::WmoLiquid::iHeight {nullptr}

private

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

{nullptr}; 

Referenced by GetHeightStorage(), GetLiquidHeight(), operator=(), readFromFile(), writeToFile(), and ~WmoLiquid().

iTilesX

uint32 VMAP::WmoLiquid::iTilesX {0}

private

number of tiles in x direction, each

{0};       

Referenced by GetFileSize(), GetLiquidHeight(), GetPosInfo(), operator=(), readFromFile(), and writeToFile().

iTilesY

uint32 VMAP::WmoLiquid::iTilesY {0}

private

{0};

Referenced by GetFileSize(), GetLiquidHeight(), GetPosInfo(), operator=(), readFromFile(), and writeToFile().

iType

uint32 VMAP::WmoLiquid::iType {0}

private

liquid type

{0};         

Referenced by GetType(), operator=(), readFromFile(), and writeToFile().

---

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

• azerothcore-wotlk/src/common/Collision/Models/WorldModel.h
• azerothcore-wotlk/src/common/Collision/Models/WorldModel.cpp