trpage_geom.cpp

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

	return true;
}
bool trpgGeometry::GetNormals(float64 *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] = normDataDouble[i];
	return true;
}
bool trpgGeometry::GetNumColorSets(int &n) const
{
	if (!isValid()) return false;
	n = colors.size();
	return true;
}
bool trpgGeometry::GetColorSet(int id,trpgColorInfo *ci) const
{
	if (!isValid() || id < 0 || id >= (int)colors.size()) return false;
	*ci = colors[id];
	return true;
}
bool trpgGeometry::GetNumTexCoordSets(int &n) const
{
	if (!isValid()) return false;
	n = texData.size();
	return true;
}
bool trpgGeometry::GetTexCoordSet(int id,trpgTexData *tx) const
{
	if (!isValid() || id < 0 || id >= (int)texData.size()) return false;
	*tx = texData[id];
	return true;
}
const trpgTexData *trpgGeometry::GetTexCoordSet(int id) const
{
    if (!isValid() || id < 0 || id >= (int)texData.size()) return 0;
    return &(texData[id]);
}
bool trpgGeometry::GetNumEdgeFlag(int &n) const
{
	if (!isValid()) return false;
	n = edgeFlags.size();
	return true;
}
bool trpgGeometry::GetEdgeFlags(char *e) const
{
	if (!isValid()) return false;
	for (unsigned int i=0;i<edgeFlags.size();i++)
		e[i] = edgeFlags[i];
	return true;
}

// Validity check
// Note: maybe I should do this sometime
bool trpgGeometry::isValid() const
{
	return true;
}

// Write geometry fields.
// Order doesn't matter very much for this
bool trpgGeometry::Write(trpgWriteBuffer &buf)
{
	unsigned int i,j;

	if (!isValid())
		return false;

	buf.Begin(TRPG_GEOMETRY);
	/* Primitive info
		Primitive Type
 		Number of primitives
		Primitive array lengths
		*/
	buf.Begin(TRPG_GEOM_PRIM);
 	buf.Add(primType);
	buf.Add(numPrim);
	if (primLength.size() != 0) {
		buf.Add((uint8)1);
		for (i=0;i<(unsigned int)numPrim;i++)
			buf.Add(primLength[i]);
	} else
		buf.Add((uint8)0);
	buf.End();

	/* Material info
		Num materials
		Material indicies
		*/
	if (materials.size() > 0) {
		buf.Begin(TRPG_GEOM_MATERIAL);
		buf.Add((int32)materials.size());
		for (i=0;i<materials.size();i++)
			buf.Add(materials[i]);
		buf.End();
	}

	/* Vertices
		Float and Double should never both be here
		Num vertex
		Vertex data
		*/
	if (vertDataFloat.size() > 0) {
		buf.Begin(TRPG_GEOM_VERT32);
		int32 num = vertDataFloat.size()/3;
		buf.Add(num);
        for (i=0;i<(unsigned int)3*num;i++)
			buf.Add(vertDataFloat[i]);
		buf.End();
	}
	if (vertDataDouble.size() > 0) {
		buf.Begin(TRPG_GEOM_VERT64);
		int32 num = vertDataDouble.size()/3;
		buf.Add(num);
        for (i=0;i<(unsigned int)3*num;i++)
			buf.Add(vertDataDouble[i]);
		buf.End();
	}

	/* Normals
		Normal binding
		Num normals
		Normal data
		*/
	if (normDataFloat.size() > 0) {
		buf.Begin(TRPG_GEOM_NORM32);
		buf.Add((int32)normBind);
		int32 num = normDataFloat.size()/3;
		buf.Add(num);
        for (i=0;i<(unsigned int)3*num;i++)
			buf.Add(normDataFloat[i]);
		buf.End();
	}
	if (normDataDouble.size() > 0) {
		buf.Begin(TRPG_GEOM_NORM64);
		buf.Add((int32)normBind);
		int32 num = normDataDouble.size()/3;
		buf.Add(num);
        for (i=0;i<(unsigned int)3*num;i++)
			buf.Add(normDataDouble[i]);
		buf.End();
	}

	/* Colors
		Color binding
		Num colors
		Colors
		   */
	if (colors.size() > 0) {
		for (i=0;i<colors.size();i++) {
			trpgColorInfo &ci = colors[i];
			if (ci.data.size()) {
				buf.Begin(TRPG_GEOM_COLOR);
				buf.Add((int32)ci.type);
				buf.Add((int32)ci.bind);
				buf.Add((int32)ci.data.size());
				for (j=0;j<ci.data.size();j++)
					buf.Add(ci.data[j]);
				buf.End();
			}
		}
	}

	/* Texture coordinates
		Binding
		Num coords
		Texture coords
		*/
	for (i=0;i<texData.size();i++) {
		trpgTexData &td = texData[i];
		if (td.floatData.size()) {
			buf.Begin(TRPG_GEOM_TEX32);
			buf.Add((int32)td.bind);
			int32 num = td.floatData.size()/2;
			buf.Add(num);
            for (j=0;j<(unsigned int)num*2;j++)
				buf.Add(td.floatData[j]);
			buf.End();
		}
		if (td.doubleData.size()) {
			buf.Begin(TRPG_GEOM_TEX64);
			buf.Add((int32)td.bind);
			int32 num = td.doubleData.size()/2;
			buf.Add(num);
            for (j=0;j<(unsigned int)num*2;j++)
				buf.Add(td.doubleData[j]);
			buf.End();

			float u;
            for (j=0;j<(unsigned int)num*2;j++)
				u = (float)td.doubleData[j];
		}
	}

	// Edge flags (for triangle strips, etc..)
	if (edgeFlags.size() > 0) {
		buf.Begin(TRPG_GEOM_EFLAG);
		buf.Add((int32)edgeFlags.size());
		for (i=0;i<edgeFlags.size();i++)
			buf.Add(edgeFlags[i]);
		buf.End();
	}

	buf.End();

	return true;
}

// Geometry class is made up of individual tokens.
class geomCB : public trpgr_Callback {
public:
	void *Parse(trpgToken,trpgReadBuffer &buf);
	trpgGeometry *geom;
};

void *geomCB::Parse(trpgToken tok,trpgReadBuffer &buf)
{
	int32 *iData;
	int32 num,primType,bind,type;
	float32 *fData;
	float64 *dData;
	trpgColor *cData;
	char *charData;
	uint8 hasPrimLen;

	try {
		switch (tok) {
		case TRPG_GEOM_PRIM:
			buf.Get(primType);
			geom->SetPrimType((trpgGeometry::PrimType)primType);
			buf.Get(num);
			if (num < 0) throw 1;
			geom->SetNumPrims(num);
			buf.Get(hasPrimLen);
			if (hasPrimLen) {
				buf.GetArray(num,&iData);
                if (ALIGNMENT_WORKAROUND)
                {
                    int32 *aligned;
                    aligned = (int32 *)calloc (num, sizeof(int32));
                    memcpy (aligned, iData, num * sizeof(int32));
                    geom->SetPrimLengths(num, aligned);
                    free (aligned);
                }
                else
				    geom->SetPrimLengths(num,iData);
			}
			break;
		case TRPG_GEOM_MATERIAL:
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(num,&iData);
            if (ALIGNMENT_WORKAROUND)
            {
                int32 *aligned;
                aligned = (int32 *)calloc (num, sizeof(int32));
                memcpy (aligned, iData, num * sizeof(int32));
                geom->SetMaterials(num,aligned);
                free (aligned);
            }
            else
			    geom->SetMaterials(num,iData);
			break;
		case TRPG_GEOM_VERT32:
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(3*num,&fData);
            if (ALIGNMENT_WORKAROUND)
            {
                float32 *aligned;
                aligned = (float32 *)calloc (3*num, sizeof(float32));
                memcpy (aligned, fData, 3*num * sizeof(float32));
                geom->SetVertices(num,aligned);
                free (aligned);
            }
            else
			    geom->SetVertices(num,fData);
			break;
		case TRPG_GEOM_VERT64:
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(3*num,&dData);
            if (ALIGNMENT_WORKAROUND)
            {
                float64 *aligned;
                aligned = (float64 *)calloc (3*num, sizeof(float64));
                memcpy (aligned, dData, 3*num * sizeof(float64));
                geom->SetVertices(num,aligned);
                free (aligned);
            }
            else
			    geom->SetVertices(num,dData);
			break;
		case TRPG_GEOM_NORM32:
			buf.Get(bind);
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(3*num,&fData);
			if (ALIGNMENT_WORKAROUND)
            {
                float32 *aligned;
                aligned = (float32 *)calloc (3*num, sizeof(float32));
                memcpy (aligned, fData, 3*num * sizeof(float32));
                geom->SetNormals(num,(trpgGeometry::BindType)bind,aligned);
                free (aligned);
            }
            else
			    geom->SetNormals(num,(trpgGeometry::BindType)bind,fData);
			break;
		case TRPG_GEOM_NORM64:
			buf.Get(bind);
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(3*num,&dData);
            if (ALIGNMENT_WORKAROUND)
            {
                float64 *aligned;
                aligned = (float64 *)calloc (3*num, sizeof(float64));
                memcpy (aligned, dData, 3*num * sizeof(float64));
                geom->SetNormals(num,(trpgGeometry::BindType)bind,aligned);
                free (aligned);
            }
            else
			    geom->SetNormals(num,(trpgGeometry::BindType)bind,dData);
			break;
		case TRPG_GEOM_COLOR:
			buf.Get(num);
			if (num < 0) throw 1;
			buf.Get(type);
			buf.Get(bind);
			buf.GetArray(num,&cData);
            if (ALIGNMENT_WORKAROUND)
            {
                trpgColor *aligned;
                aligned = (trpgColor *)calloc (num, sizeof(trpgColor));
                memcpy (aligned, cData, num * sizeof(trpgColor));
                geom->SetColors(num,(trpgGeometry::ColorType)type,(trpgGeometry::BindType)bind,aligned);
                free (aligned);
            }
            else
			    geom->SetColors(num,(trpgGeometry::ColorType)type,(trpgGeometry::BindType)bind,cData);
			break;
		case TRPG_GEOM_TEX32:
			buf.Get(bind);
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(2*num,&fData);
            if (ALIGNMENT_WORKAROUND)
            {
                float32 *aligned;
                aligned = (float32 *)calloc (2*num, sizeof(float32));
                memcpy (aligned, fData, 2*num * sizeof(float32));
                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,aligned);
                free (aligned);
            }
            else
			    geom->SetTexCoords(num,(trpgGeometry::BindType)bind,fData);
			break;
		case TRPG_GEOM_TEX64:
			buf.Get(bind);
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(2*num,&dData);
            if (ALIGNMENT_WORKAROUND)
            {
                float64 *aligned;
                aligned = (float64 *)calloc (2*num, sizeof(float64));
                memcpy (aligned, dData, 2*num * sizeof(float64));
                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,aligned);
                free (aligned);
            }
            else
			    geom->SetTexCoords(num,(trpgGeometry::BindType)bind,dData);
			break;
		case TRPG_GEOM_EFLAG:
			buf.Get(num);
			if (num < 0) throw 1;
			buf.GetArray(num,&charData);
			geom->SetEdgeFlags(num,charData);
			break;
		default:
			// Skip
			break;
		}
	}
	catch (...) {
		return NULL;
	}

	return geom;
}

// Read Geometry
bool trpgGeometry::Read(trpgReadBuffer &buf)
{
	trpgr_Parser parse;
	geomCB gcb;

	gcb.geom = this;
	parse.AddCallback(TRPG_GEOM_PRIM,&gcb,false);
	parse.AddCallback(TRPG_GEOM_MATERIAL,&gcb,false);
	parse.AddCallback(TRPG_GEOM_VERT32,&gcb,false);
	parse.AddCallback(TRPG_GEOM_VERT64,&gcb,false);
	parse.AddCallback(TRPG_GEOM_NORM32,&gcb,false);
	parse.AddCallback(TRPG_GEOM_NORM64,&gcb,false);
	parse.AddCallback(TRPG_GEOM_COLOR,&gcb,false);
	parse.AddCallback(TRPG_GEOM_TEX32,&gcb,false);
	parse.AddCallback(TRPG_GEOM_TEX64,&gcb,false);
	parse.AddCallback(TRPG_GEOM_EFLAG,&gcb,false);
	parse.Parse(buf);

	return isValid();
}