#include "TileAssembler.h"

Public Member Functions
	GroupModel_Raw ()

	~GroupModel_Raw ()

bool	Read (FILE *f)

Public Attributes
uint32	mogpflags {0}

uint32	GroupWMOID {0}

G3D::AABox	bounds

uint32	liquidflags {0}

std::vector< MeshTriangle >	triangles

std::vector< G3D::Vector3 >	vertexArray

class WmoLiquid *	liquid

Detailed Description

Constructor & Destructor Documentation

◆ GroupModel_Raw()

VMAP::GroupModel_Raw::GroupModel_Raw ( )

inline

77: liquid(nullptr) { }

VMAP::GroupModel_Raw::liquid

class WmoLiquid * liquid

Definition: TileAssembler.h:75

◆ ~GroupModel_Raw()

VMAP::GroupModel_Raw::~GroupModel_Raw ( )

    {
        delete liquid;
    }

References liquid.

Member Function Documentation

◆ Read()

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 = nullptr;
        if (liquidflags & 3)
        {
            READ_OR_RETURN(&blockId, 4);
            CMP_OR_RETURN(blockId, "LIQU");
            READ_OR_RETURN(&blocksize, sizeof(int));
            uint32 liquidType;
            READ_OR_RETURN(&liquidType, sizeof(uint32));
            if (liquidflags & 1)
            {
                WMOLiquidHeader hlq;
                READ_OR_RETURN(&hlq, sizeof(WMOLiquidHeader));
                liquid = new WmoLiquid(hlq.xtiles, hlq.ytiles, Vector3(hlq.pos_x, hlq.pos_y, hlq.pos_z), liquidType);
                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);
            }
            else
            {
                liquid = new WmoLiquid(0, 0, Vector3::zero(), liquidType);
                liquid->GetHeightStorage()[0] = bounds.high().z;
            }
        }
 
        return true;
    }