trpage_geom.cpp

来自「最新osg包」· C++ 代码 · 共 840 行 · 第 1/2 页

/* ************************
   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
   [e-mail]
   Tel: [phone]
   ************************
   */

/* trpage_geom.cpp
	Methods for the trpgGeometry class.
	This includes read and write methods.
	You should only need to change something in here if you want to modify
	 what trpgGeometry contains.
	*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <trpage_geom.h>
#include <trpage_read.h>

#if defined(_WIN32)
#define ALIGNMENT_WORKAROUND    false
#else
#define ALIGNMENT_WORKAROUND    true
#endif

// Constructor
trpgGeometry::trpgGeometry()
{
	primType = Polygons;
	normBind = Overall;
	numPrim = 0;
}
trpgGeometry::~trpgGeometry()
{
}

// Reset function
void trpgGeometry::Reset()
{
	primType = Polygons;
	numPrim = 0;
	primLength.resize(0);
	materials.resize(0);
	vertDataFloat.resize(0);
	vertDataDouble.resize(0);
	normBind = Overall;
	normDataFloat.resize(0);
	normDataDouble.resize(0);
	colors.resize(0);
	texData.resize(0);
	edgeFlags.resize(0);
}

// Set functions
void trpgGeometry::SetPrimType(PrimType type)
{
	primType = type;
}
void trpgGeometry::SetPrimLengths(int num,const int *len)
{
	if (num < 0)
		return;

	numPrim = num;
	for (int i=0;i<num;i++)
		primLength.push_back(len[i]);
}
void trpgGeometry::AddPrimLength(int len)
{
	if (len < 0)
		return;

	numPrim++;
	primLength.push_back(len);
}
void trpgGeometry::AddPrim()
{
	numPrim++;
}
void trpgGeometry::SetNumPrims(int num)
{
	numPrim = num;
}
void trpgGeometry::SetNumMaterial(int no)
{
	if (no < 0)
		return;

	materials.resize(no,-1);
}
void trpgGeometry::SetMaterial(int which,int mat,bool isLocal)
{
	if (which < 0 || which >= (int)materials.size())
		return;

	materials[which] = (isLocal ? -(mat+1) : mat);
}
void trpgGeometry::SetMaterials(int32 num,const int32 *mat)
{
	materials.resize(num);
	for (int i=0;i<num;i++)
		materials[i] = mat[i];
}
int trpgGeometry::AddMaterial(int mat)
{
	materials.push_back(mat);

	return materials.size()-1;
}

// Geometry/color/normal/etc... set functions
void trpgGeometry::SetVertices(int num,const float32 *data)
{
	if (num < 0)
		return;

	vertDataFloat.resize(0);
	vertDataDouble.resize(0);
	for (int i=0;i<3*num;i++)
		vertDataFloat.push_back(data[i]);
}
void trpgGeometry::SetVertices(int num,const float64 *data)
{
	if (num < 0)
		return;

	vertDataFloat.resize(0);
	vertDataDouble.resize(0);
	for (int i=0;i<3*num;i++)
		vertDataDouble.push_back(data[i]);
}
void trpgGeometry::AddVertex(DataType type,trpg3dPoint &pt)
{
	if (type == FloatData) {
        vertDataFloat.push_back(static_cast<float>(pt.x));
        vertDataFloat.push_back(static_cast<float>(pt.y));
        vertDataFloat.push_back(static_cast<float>(pt.z));
	} else {
		vertDataDouble.push_back(pt.x);
		vertDataDouble.push_back(pt.y);
		vertDataDouble.push_back(pt.z);
	}
}
void trpgGeometry::SetNormals(int num,BindType bind,const float32 *data)
{
	if (num < 0)
		return;

	normBind = bind;
	normDataFloat.resize(0);
	normDataDouble.resize(0);
	for (int i=0;i<3*num;i++)
		normDataFloat.push_back(data[i]);
}
void trpgGeometry::SetNormals(int num,BindType bind,const float64 *data)
{
	if (num <0)
		return;

	normBind = bind;
	normDataFloat.resize(0);
	normDataDouble.resize(0);
	for (int i=0;i<3*num;i++)
		normDataDouble.push_back(data[i]);
}
void trpgGeometry::AddNormal(DataType type,trpg3dPoint &pt)
{
	if (type == FloatData) {
        normDataFloat.push_back(static_cast<float>(pt.x));
        normDataFloat.push_back(static_cast<float>(pt.y));
        normDataFloat.push_back(static_cast<float>(pt.z));
	} else {
		normDataDouble.push_back(pt.x);
		normDataDouble.push_back(pt.y);
		normDataDouble.push_back(pt.z);
	}
}
// Constructor
trpgColorInfo::trpgColorInfo()
{
}
trpgColorInfo::~trpgColorInfo()
{
}
void trpgColorInfo::Reset()
{
	bind = 0;
	type = 0;
	data.resize(0);
}
void trpgGeometry::SetColors(int num,ColorType type,BindType bind,const trpgColor *data)
{
	trpgColorInfo ci;

	if (num < 0)
		return;

	// Set up color list
	ci.type = type;
	ci.bind = bind;
	for (int i=0;i<num;i++)
		ci.data.push_back(data[i]);

	colors.push_back(ci);
}
// Constructor
trpgTexData::trpgTexData()
{
}
trpgTexData::~trpgTexData()
{
}
void trpgTexData::set(int num,int in_bind,const float32 *data)
{
	bind = in_bind;
	floatData.resize(0);
	doubleData.resize(0);
	for (int i=0;i<2*num;i++)
		floatData.push_back(data[i]);
}
void trpgTexData::set(int num,int in_bind,const float64 *data)
{
	bind = in_bind;
	floatData.resize(0);
	doubleData.resize(0);
	for (int i=0;i<2*num;i++)
		doubleData.push_back(data[i]);
}
void trpgTexData::Reset()
{
	bind = 0;
	floatData.resize(0);
	doubleData.resize(0);
}

void trpgGeometry::SetTexCoords(int num,BindType bind,const float32 *data)
{
	if (num < 0)
		return;

	trpgTexData td;
	td.set(num,bind,data);
	texData.push_back(td);
}
void trpgGeometry::SetTexCoords(int num,BindType bind,const float64 *data)
{
	if (num < 0)
		return;

	trpgTexData td;
	td.set(num,bind,data);
	texData.push_back(td);
}
void trpgGeometry::AddTexCoord(DataType type,trpg2dPoint &pt, int n)
{
	if ((n<0) || (n >= (int)texData.size()))
		return;
	trpgTexData *td = &texData[n];

	if (type == FloatData) {
        td->floatData.push_back(static_cast<float>(pt.x));
        td->floatData.push_back(static_cast<float>(pt.y));
	} else {
		td->doubleData.push_back(pt.x);
		td->doubleData.push_back(pt.y);
	}
}
void trpgGeometry::AddTexCoord(DataType type,std::vector<trpg2dPoint> &pts)
{
	if (texData.size() != pts.size())
		return;

	for (unsigned int loop = 0; loop < pts.size(); loop++ ) {
		trpgTexData *td = &texData[loop];

		if (type == FloatData) {
            td->floatData.push_back(static_cast<float>(pts[loop].x));
            td->floatData.push_back(static_cast<float>(pts[loop].y));
		} else {
			td->doubleData.push_back(pts[loop].x);
			td->doubleData.push_back(pts[loop].y);
		}
	}
}
void trpgGeometry::AddTexCoords(BindType bind)
{
	trpgTexData td;
	td.bind = bind;
	texData.push_back(td);
}
void trpgGeometry::SetEdgeFlags(int num,const char *flags)
{
	if (num < 0)
		return;

	edgeFlags.resize(0);
	for (int i=0;i<num;i++)
		edgeFlags.push_back(flags[i]);
}

// Get methods
bool trpgGeometry::GetPrimType(PrimType &t) const
{
	if (!isValid()) return false;
	t = (PrimType)primType;
	return true;
}
bool trpgGeometry::GetNumPrims(int &n) const
{
	if (!isValid()) return false;
	n = numPrim;
	return true;
}
bool trpgGeometry::GetPrimLengths(int *ret) const
{
	if (!isValid()) return false;
	for (int i=0;i<numPrim;i++)
		ret[i] = primLength[i];
	return true;
}
bool trpgGeometry::GetNumMaterial(int &n) const
{
	if (!isValid()) return false;
	n = materials.size();
	return true;
}
bool trpgGeometry::GetMaterial(int id,int32 &m,bool &isLocal) const
{
	isLocal = false;
	if (!isValid() || id < 0 || id >= (int)materials.size()) return false;
	m = materials[id];
	if (m < 0) {
	    m = -m - 1;
	    isLocal = true;
	}
	return true;
}
bool trpgGeometry::GetNumVertex(int &v) const
{
	if (!isValid()) return false;
	int nvf = vertDataFloat.size();
	int nvd = vertDataDouble.size();
	v = MAX(nvf,nvd);
	v = v / 3;
	return true;
}
bool trpgGeometry::GetVertices(float32 *v) const
{
	unsigned int i;

	if (!isValid()) return false;
	if (vertDataFloat.size() != 0)
		for (i=0;i<vertDataFloat.size();i++)
			v[i] = vertDataFloat[i];
	else
		for (i=0;i<vertDataDouble.size();i++)
            v[i] = static_cast<float32>(vertDataDouble[i]);
	return true;
}
bool trpgGeometry::GetVertices(float64 *v) const
{
	unsigned int i;

	if (!isValid()) return false;
	if (vertDataFloat.size() != 0)
		for (i=0;i<vertDataFloat.size();i++)
			v[i] = vertDataFloat[i];
	else
		for (i=0;i<vertDataDouble.size();i++)
			v[i] = vertDataDouble[i];
	return true;
}
bool trpgGeometry::GetVertex(int n,trpg3dPoint &pt) const
{
	int id = 3*n;
	int idMax = 3*n+2;
	if (id < 0 || (idMax >= (int)vertDataFloat.size() && idMax >= (int)vertDataDouble.size()))
		return false;
	if (vertDataFloat.size() > vertDataDouble.size()) {
		pt.x = vertDataFloat[id];
		pt.y = vertDataFloat[id+1];
		pt.z = vertDataFloat[id+2];
	} else {
		pt.x = vertDataDouble[id];
		pt.y = vertDataDouble[id+1];
		pt.z = vertDataDouble[id+2];
	}
	return true;
}
bool trpgGeometry::GetNumNormal(int32 &n) const
{
	if (!isValid()) return false;
	if (normDataFloat.size() != 0)
		n = normDataFloat.size();
	if (normDataDouble.size() != 0)
		n = normDataDouble.size();
	n = n / 3;
	return true;
}
bool trpgGeometry::GetNormals(float32 *v) const
{
	unsigned int i;

	if (!isValid()) return false;
	if (normDataFloat.size() != 0)
		for (i=0;i<normDataFloat.size();i++)
			v[i] = normDataFloat[i];
	else
		for (i=0;i<normDataDouble.size();i++)
            v[i] = static_cast<float32>(normDataDouble[i]);