359 lines
7.5 KiB
C++
359 lines
7.5 KiB
C++
/* ************************
|
|
Copyright Terrain Experts Inc.
|
|
Terrain Experts Inc (TERREX) reserves all rights to this source code
|
|
unless otherwise specified in writing by the President of TERREX.
|
|
This copyright may be updated in the future, in which case that version
|
|
supercedes this one.
|
|
-------------------
|
|
Terrex Experts Inc.
|
|
4400 East Broadway #314
|
|
Tucson, AZ 85711
|
|
info@terrex.com
|
|
Tel: (520) 323-7990
|
|
************************
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/* trpage_header.cpp
|
|
Source for trpgHeader methods.
|
|
The only reason to change this is if you want to add something
|
|
to the header definition.
|
|
*/
|
|
|
|
#include <trpage_geom.h>
|
|
#include <trpage_read.h>
|
|
|
|
/* Write Header class
|
|
Fill it in and write it out.
|
|
*/
|
|
|
|
// Constructor
|
|
trpgHeader::trpgHeader()
|
|
{
|
|
Reset();
|
|
}
|
|
trpgHeader::~trpgHeader()
|
|
{
|
|
}
|
|
|
|
// Validity check
|
|
bool trpgHeader::isValid() const
|
|
{
|
|
// We also need to check that this is a 'master' archive here.
|
|
if((verMajor>=TRPG_NOMERGE_VERSION_MAJOR) && (verMinor>=TRPG_NOMERGE_VERSION_MINOR))
|
|
{
|
|
return true;
|
|
}
|
|
else {
|
|
if (numLods <= 0)
|
|
{
|
|
strcpy(errMess, "Number of LOD <= 0");
|
|
return false;
|
|
}
|
|
if (sw.x == ne.x && sw.y == ne.y)
|
|
{
|
|
strcpy(errMess, "Mbr is invalid");
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Reset contents
|
|
void trpgHeader::Reset()
|
|
{
|
|
// Initialize to a default state
|
|
verMinor = TRPG_VERSION_MINOR;
|
|
verMajor = TRPG_VERSION_MAJOR;
|
|
dbVerMinor = 0;
|
|
dbVerMajor = 0;
|
|
origin = trpg3dPoint(0,0,0);
|
|
sw = ne = trpg2dPoint(0,0);
|
|
tileType = DatabaseLocal;
|
|
|
|
numLods = 0;
|
|
lodSizes.resize(0);
|
|
lodRanges.resize(0);
|
|
tileSize.resize(0);
|
|
maxGroupID = -1;
|
|
flags = 0;
|
|
errMess[0] = '\0';
|
|
cols = -1;
|
|
rows = -1;
|
|
}
|
|
|
|
// Set functions
|
|
void trpgHeader::SetVersion(int32 vmaj,int32 vmin)
|
|
{
|
|
verMinor = vmin;
|
|
verMajor = vmaj;
|
|
}
|
|
void trpgHeader::SetDbVersion(int32 vmaj,int32 vmin)
|
|
{
|
|
dbVerMinor = vmin;
|
|
dbVerMajor = vmaj;
|
|
}
|
|
void trpgHeader::SetTileSize(int id,const trpg2dPoint &pt)
|
|
{
|
|
if (id < 0 || id >= (int)tileSize.size()) return;
|
|
tileSize[id] = pt;
|
|
}
|
|
void trpgHeader::SetOrigin(const trpg3dPoint &pt)
|
|
{
|
|
origin = pt;
|
|
}
|
|
void trpgHeader::SetExtents(const trpg2dPoint &in_sw,const trpg2dPoint &in_ne)
|
|
{
|
|
sw = in_sw;
|
|
ne = in_ne;
|
|
}
|
|
void trpgHeader::SetTileOriginType(trpgTileType type)
|
|
{
|
|
tileType = type;
|
|
}
|
|
void trpgHeader::SetNumLods(int no)
|
|
{
|
|
if (no < 0) return;
|
|
numLods = no;
|
|
|
|
lodSizes.resize(no);
|
|
lodRanges.resize(no);
|
|
}
|
|
void trpgHeader::SetLodSize(int no,const trpg2iPoint &pt)
|
|
{
|
|
if (no < 0 || no >= numLods)
|
|
return;
|
|
|
|
lodSizes[no] = pt;
|
|
}
|
|
void trpgHeader::SetLodSize(const trpg2iPoint *pt)
|
|
{
|
|
for (int i=0;i<numLods;i++)
|
|
lodSizes[i] = pt[i];
|
|
}
|
|
void trpgHeader::SetLodRange(int no,float64 r)
|
|
{
|
|
if (no < 0 || no >= numLods)
|
|
return;
|
|
|
|
lodRanges[no] = r;
|
|
}
|
|
void trpgHeader::SetLodRange(const float64 *r)
|
|
{
|
|
for (int i=0;i<numLods;i++)
|
|
lodRanges[i] = r[i];
|
|
}
|
|
void trpgHeader::AddLod(const trpg2iPoint &pt,const trpg2dPoint &sz,float64 r)
|
|
{
|
|
lodRanges.push_back(r);
|
|
lodSizes.push_back(pt);
|
|
tileSize.push_back(sz);
|
|
numLods++;
|
|
}
|
|
void trpgHeader::SetLod(const trpg2iPoint &pt,const trpg2dPoint &sz,float64 r,unsigned int lod)
|
|
{
|
|
if (lodRanges.size()<=lod)
|
|
lodRanges.resize(lod+1);
|
|
lodRanges[lod]=r;
|
|
if (lodSizes.size()<=lod)
|
|
lodSizes.resize(lod+1);
|
|
lodSizes[lod]=pt;
|
|
if (tileSize.size()<=lod)
|
|
tileSize.resize(lod+1);
|
|
tileSize[lod]=sz;
|
|
if (numLods<=static_cast<int>(lod))
|
|
numLods=lod+1;
|
|
}
|
|
void trpgHeader::SetMaxGroupID(int id)
|
|
{
|
|
maxGroupID = id;
|
|
}
|
|
int trpgHeader::AddGroupID(void)
|
|
{
|
|
maxGroupID++;
|
|
return maxGroupID;
|
|
}
|
|
|
|
// Write out to a buffer
|
|
bool trpgHeader::Write(trpgWriteBuffer &buf)
|
|
{
|
|
|
|
if (!isValid())
|
|
return false;
|
|
|
|
buf.Begin(TRPGHEADER);
|
|
buf.Add((int32)verMajor);
|
|
buf.Add((int32)verMinor);
|
|
buf.Add((int32)dbVerMajor);
|
|
buf.Add((int32)dbVerMinor);
|
|
buf.Add(origin);
|
|
buf.Add(sw);
|
|
buf.Add(ne);
|
|
buf.Add((uint8)tileType);
|
|
|
|
buf.Add((int32)numLods);
|
|
|
|
buf.Begin(TRPGHEAD_LODINFO);
|
|
for (int i=0;i<numLods;i++) {
|
|
buf.Add(lodSizes[i]);
|
|
buf.Add(lodRanges[i]);
|
|
buf.Add(tileSize[i]);
|
|
}
|
|
buf.End();
|
|
|
|
buf.Add(maxGroupID);
|
|
|
|
if((verMajor >= TRPG_NOMERGE_VERSION_MAJOR) && (verMinor >=TRPG_NOMERGE_VERSION_MINOR)) {
|
|
buf.Add(flags);
|
|
buf.Add(rows);
|
|
buf.Add(cols);
|
|
}
|
|
|
|
buf.End();
|
|
|
|
return true;
|
|
}
|
|
|
|
/* ********
|
|
Read Header class.
|
|
*/
|
|
|
|
// Get Functions
|
|
bool trpgHeader::GetVersion(int32 &vmaj,int32 &vmin) const
|
|
{
|
|
if (!isValid()) return false;
|
|
vmin = verMinor;
|
|
vmaj = verMajor;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetDbVersion(int32 &vmaj,int32 &vmin) const
|
|
{
|
|
if (!isValid()) return false;
|
|
vmaj = dbVerMajor;
|
|
vmin = dbVerMinor;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetTileSize(int id,trpg2dPoint &pt) const
|
|
{
|
|
if (!isValid()) return false;
|
|
if (id < 0 || id >= (int)tileSize.size()) return false;
|
|
pt = tileSize[id];
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetOrigin(trpg3dPoint &pt) const
|
|
{
|
|
if (!isValid()) return false;
|
|
pt = origin;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetTileOriginType(trpgTileType &type) const
|
|
{
|
|
if (!isValid()) return false;
|
|
type = tileType;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetNumLods(int32 &no) const
|
|
{
|
|
if (!isValid()) return false;
|
|
no = numLods;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetLodSize(int32 id,trpg2iPoint &pt) const
|
|
{
|
|
if (!isValid() || (id < 0 || id >= numLods)) return false;
|
|
pt = lodSizes[id];
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetLodRange(int32 id,float64 &range) const
|
|
{
|
|
if (!isValid() || (id < 0 || id >= numLods)) return false;
|
|
range = lodRanges[id];
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetExtents(trpg2dPoint &osw,trpg2dPoint &one) const
|
|
{
|
|
if (!isValid()) return false;
|
|
osw = sw;
|
|
one = ne;
|
|
return true;
|
|
}
|
|
bool trpgHeader::GetMaxGroupID(int &id) const
|
|
{
|
|
id = maxGroupID;
|
|
return true;
|
|
}
|
|
|
|
// Read in the header
|
|
bool trpgHeader::Read(trpgReadBuffer &buf)
|
|
{
|
|
uint8 i8;
|
|
trpgToken tok;
|
|
bool status;
|
|
int32 len;
|
|
|
|
try {
|
|
buf.Get(verMajor);
|
|
buf.Get(verMinor);
|
|
buf.Get(dbVerMajor);
|
|
buf.Get(dbVerMinor);
|
|
buf.Get(origin);
|
|
buf.Get(sw);
|
|
buf.Get(ne);
|
|
buf.Get(i8); tileType = (trpgTileType)i8;
|
|
buf.Get(numLods);
|
|
if (numLods < 0) throw 1;
|
|
|
|
// Read in the LOD range info
|
|
buf.GetToken(tok,len);
|
|
if (tok != TRPGHEAD_LODINFO) throw 1;
|
|
buf.PushLimit(len);
|
|
status = ReadLodInfo(buf);
|
|
buf.PopLimit();
|
|
if (!status) throw 1;
|
|
|
|
// Added after the first version (but still in 1.0)
|
|
buf.Get(maxGroupID);
|
|
if((verMajor >= TRPG_NOMERGE_VERSION_MAJOR) && (verMinor >=TRPG_NOMERGE_VERSION_MINOR)) {
|
|
buf.Get(flags);
|
|
buf.Get(rows);
|
|
buf.Get(cols);
|
|
}
|
|
}
|
|
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return isValid();
|
|
}
|
|
|
|
// Read the LOD info (separate token)
|
|
bool trpgHeader::ReadLodInfo(trpgReadBuffer &buf)
|
|
{
|
|
float64 range;
|
|
trpg2iPoint pt;
|
|
trpg2dPoint sz;
|
|
|
|
try {
|
|
for (int i=0;i<numLods;i++) {
|
|
buf.Get(pt);
|
|
buf.Get(range);
|
|
buf.Get(sz);
|
|
lodSizes.push_back(pt);
|
|
lodRanges.push_back(range);
|
|
tileSize.push_back(sz);
|
|
}
|
|
}
|
|
catch (...) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|