char HTriangleMesh::save(ATriangleMesh * tri)
{
int nv = tri->numPoints();
if(!hasNamedAttr(".nv"))
addIntAttr(".nv");
writeIntAttr(".nv", &nv);
int nt = tri->numTriangles();
if(!hasNamedAttr(".ntri"))
addIntAttr(".ntri");
writeIntAttr(".ntri", &nt);
if(!hasNamedData(".p"))
addVector3Data(".p", nv);
writeVector3Data(".p", nv, (Vector3F *)tri->points());
if(!hasNamedData(".a"))
addIntData(".a", nv);
writeIntData(".a", nv, (int *)tri->anchors());
if(!hasNamedData(".v"))
addIntData(".v", nt * 3);
writeIntData(".v", nt * 3, (int *)tri->indices());
return 1;
}
char HPolygonalUV::save(APolygonalUV * poly)
{
int nuv = poly->numCoords();
if(!hasNamedAttr(".nuv"))
addIntAttr(".nuv");
writeIntAttr(".nuv", &nuv);
int nind = poly->numIndices();
if(!hasNamedAttr(".nind"))
addIntAttr(".nind");
writeIntAttr(".nind", &nind);
if(!hasNamedData(".ucoord"))
addFloatData(".ucoord", nuv);
writeFloatData(".ucoord", nuv, (float *)poly->ucoord());
if(!hasNamedData(".vcoord"))
addFloatData(".vcoord", nuv);
writeFloatData(".vcoord", nuv, (float *)poly->vcoord());
if(!hasNamedData(".uvid"))
addIntData(".uvid", nind);
writeIntData(".uvid", nind, (int *)poly->indices());
return 1;
}
bool HAttributeGroup::loadEnum(AEnumAttribute * data)
{
if(!hasNamedAttr(".val")) return false;
int v = 0;
readIntAttr(".val", &v);
data->setValue(v);
int r[2];
r[0] = 0;
r[1] = 1;
readIntAttr(".range", r);
short a = r[0];
short b = r[1];
data->setRange(a, b);
short i;
std::stringstream sst;
for(i=a; i<=b; i++) {
sst.str("");
sst<<i;
std::string fn;
if(hasNamedAttr(sst.str().c_str())) {
readStringAttr(sst.str().c_str(), fn);
data->addField(i, fn);
std::cout<<" field "<<i<<":"<<fn;
}
}
return true;
}
char HNumericBundle::save(const ABundleAttribute * d)
{
if(!hasNamedAttr(".longname"))
addStringAttr(".longname", d->longName().size());
writeStringAttr(".longname", d->longName());
int sz = d->size();
if(!hasNamedAttr(".bundle_sz"))
addIntAttr(".bundle_sz");
writeIntAttr(".bundle_sz", &sz);
int nt = d->numericType();
if(!hasNamedAttr(".bundle_num_typ"))
addIntAttr(".bundle_num_typ");
writeIntAttr(".bundle_num_typ", &nt);
int l = d->dataLength();
if(!hasNamedData(".raw"))
addCharData(".raw", l);
writeCharData(".raw", l, (char *)d->value());
return 1;
}
char HField::save(AField * fld)
{
if(fld->numChannels() < 1) {
std::cout<<"\n field has no channel";
return 0;
}
if(!hasNamedAttr(".fieldType"))
addIntAttr(".fieldType");
int t = fld->fieldType();
writeIntAttr(".fieldType", &t);
std::vector<std::string > names;
fld->getChannelNames(names);
int nc = names.size();
if(!hasNamedAttr(".fieldNumChannels"))
addIntAttr(".fieldNumChannels");
writeIntAttr(".fieldNumChannels", &nc);
std::string combined = SHelper::Combine(names);
if(!hasNamedAttr(".fieldChannelNames"))
addStringAttr(".fieldChannelNames", combined.size());
writeStringAttr(".fieldChannelNames", combined);
std::vector<std::string >::const_iterator it = names.begin();
for(; it!= names.end();++it) saveAChannel(*it, fld->namedChannel(*it));
return 1;
}
void HAttributeGroup::writeEnum(AEnumAttribute * data)
{
short a, b;
int v = data->value(a, b);
if(!hasNamedAttr(".val"))
addIntAttr(".val");
writeIntAttr(".val", &v);
int r[2];
r[0] = a;
r[1] = b;
if(!hasNamedAttr(".range"))
addIntAttr(".range", 2);
writeIntAttr(".range", r);
// std::cout<<" value "<<v;
// std::cout<<" range "<<a<<":"<<b;
short i;
std::stringstream sst;
for(i=a; i<=b; i++) {
std::string fn = data->fieldName(i);
sst.str("");
sst<<i;
if(!hasNamedAttr(sst.str().c_str()))
addStringAttr(sst.str().c_str(), fn.size());
writeStringAttr(sst.str().c_str(), fn);
// std::cout<<" field "<<i<<":"<<fn;
}
}
char HOption::load(RenderOptions * opt)
{
int aas = 4;
if(hasNamedAttr(".aas"))
readIntAttr(".aas", &aas);
opt->setAASample(aas);
int rw = 400;
if(hasNamedAttr(".rw"))
readIntAttr(".rw", &rw);
opt->setRenderImageWidth(rw);
int rh = 300;
if(hasNamedAttr(".rh"))
readIntAttr(".rh", &rh);
opt->setRenderImageHeight(rh);
int msd = 3;
if(hasNamedAttr(".msd"))
readIntAttr(".msd", &msd);
opt->setMaxSubdiv(msd);
int uds = 0;
if(hasNamedAttr(".uds"))
readIntAttr(".uds", &uds);
if(uds == 1) opt->setUseDisplaySize(true);
else opt->setUseDisplaySize(false);
return 1;
}
char HAttributeEntry::verifyType()
{
if(!hasNamedAttr(".attrib_typ"))
return 0;
if(!hasNamedAttr(".def_val"))
return 0;
return 1;
}
char HPolygonalUV::verifyType()
{
if(!hasNamedAttr(".nuv"))
return 0;
if(!hasNamedAttr(".nind"))
return 0;
return 1;
}
char HTriangleMesh::verifyType()
{
if(!hasNamedAttr(".ntri"))
return 0;
if(!hasNamedAttr(".nv"))
return 0;
return 1;
}
char HBaseNTree::verifyType()
{
if(!hasNamedAttr(".nrope") ) return 0;
if(!hasNamedData(".rope") ) return 0;
if(!hasNamedAttr(".nind") ) return 0;
if(!hasNamedData(".ind") ) return 0;
if(!hasNamedAttr(".nleaf") ) return 0;
if(!hasNamedData(".leaf") ) return 0;
if(!hasNamedAttr(".nnode") ) return 0;
if(!hasNamedData(".node") ) return 0;
if(!hasNamedAttr(".bbx") ) return 0;
return 1;
}
char HNumericBundle::verifyType()
{
if(!hasNamedAttr(".bundle_num_typ"))
return 0;
if(!hasNamedAttr(".bundle_sz"))
return 0;
if(!hasNamedAttr(".longname"))
return 0;
return 1;
}
char HField::verifyType()
{
if(!hasNamedAttr(".fieldNumChannels"))
return 0;
if(!hasNamedAttr(".fieldChannelNames"))
return 0;
if(!hasNamedAttr(".fieldType"))
return 0;
return 1;
}
char HAdaptiveField::verifyType()
{
if(!hasNamedAttr(".ncells"))
return 0;
if(!hasNamedAttr(".origin_span"))
return 0;
if(!hasNamedAttr(".max_level"))
return 0;
return HField::verifyType();
}
char HMesh::verifyType()
{
if(!hasNamedAttr(".polyc"))
return 0;
if(!hasNamedAttr(".polyv"))
return 0;
if(!hasNamedAttr(".p"))
return 0;
return 1;
}
char HAdaptiveField::save(AdaptiveField * fld)
{
int nc = fld->numCells();
std::cout<<"\n hadaptivefield save n cells "<<nc;
if(!hasNamedAttr(".ncells"))
addIntAttr(".ncells");
writeIntAttr(".ncells", &nc);
if(!hasNamedAttr(".origin_span"))
addFloatAttr(".origin_span", 4);
float originSpan[4];
originSpan[0] = fld->origin().x;
originSpan[1] = fld->origin().y;
originSpan[2] = fld->origin().z;
originSpan[3] = fld->span();
writeFloatAttr(".origin_span", originSpan);
if(!hasNamedAttr(".max_level"))
addIntAttr(".max_level");
int ml = fld->maxLevel();
writeIntAttr(".max_level", &ml);
BaseBuffer dhash;
dhash.create(nc * 16);
IOCellHash * dst = (IOCellHash *)dhash.data();
sdb::CellHash * c = fld->cells();
c->begin();
while(!c->end()) {
dst->code = c->key();
dst->level = c->value()->level;
dst->visited = c->value()->visited;
dst->index = c->value()->index;
dst++;
c->next();
}
if(!hasNamedData(".cellHash"))
addCharData(".cellHash", nc*16);
writeCharData(".cellHash", nc*16, dhash.data());
return HField::save(fld);
}
char HTriangleMeshGroup::verifyType()
{
if(!hasNamedAttr(".npart"))
return 0;
return HTriangleMesh::verifyType();
}
void HAttributeGroup::writeNumericValueAsInt(ANumericAttribute * data)
{
short va;
int vb;
bool vc;
switch (data->numericType()) {
case ANumericAttribute::TByteNumeric:
va = (static_cast<AByteNumericAttribute *> (data))->value();
vb = va;
break;
case ANumericAttribute::TShortNumeric:
va = (static_cast<AShortNumericAttribute *> (data))->value();
vb = va;
break;
case ANumericAttribute::TIntNumeric:
vb = (static_cast<AIntNumericAttribute *> (data))->value();
break;
case ANumericAttribute::TBooleanNumeric:
vc = (static_cast<ABooleanNumericAttribute *> (data))->value();
vb = vc;
break;
default:
break;
}
if(!hasNamedAttr(".val"))
addIntAttr(".val");
writeIntAttr(".val", &vb);
// std::cout<<" value "<<vb;
}
void HAttributeGroup::writeNumeric(ANumericAttribute * data)
{
int t = data->numericType();
if(t==0) return;
if(!hasNamedAttr(".num_typ"))
addIntAttr(".num_typ");
writeIntAttr(".num_typ", &t);
switch (data->numericType()) {
case ANumericAttribute::TByteNumeric:
case ANumericAttribute::TShortNumeric:
case ANumericAttribute::TIntNumeric:
case ANumericAttribute::TBooleanNumeric:
writeNumericValueAsInt(data);
break;
case ANumericAttribute::TFloatNumeric:
case ANumericAttribute::TDoubleNumeric:
writeNumericValueAsFlt(data);
break;
default:
break;
}
}
char HAttributeGroup::load(AAttributeWrap & wrap)
{
int t = 0;
readIntAttr(".attr_typ", &t);
if(t == AAttribute::aNumeric) {
int tn = 0;
if(hasNamedAttr(".num_typ")) {
readIntAttr(".num_typ", &tn);
loadNumeric( wrap.createNumeric(tn) );
}
}
else if(t == AAttribute::aEnum) {
loadEnum( wrap.createEnum() );
}
else if(t == AAttribute::aString) {
loadString( wrap.createString() );
}
else if(t == AAttribute::aCompound) {
loadCompound( wrap.createCompound() );
}
AAttribute * data = wrap.attrib();
if(!data) return 0;
std::string lnm;
readStringAttr(".longname", lnm);
data->setLongName(lnm);
data->setShortName(lastName());
return 1;
}
char HFlt3AttributeEntry::save(const Vector3F * src)
{
if(!hasNamedAttr(".def_val"))
addFloatAttr(".def_val", 3);
writeFloatAttr(".def_val", (float *)src);
return HAttributeEntry::save();
}
bool HAttributeGroup::readNumericValueAsFlt(ANumericAttribute * data)
{
if(!hasNamedAttr(".val")) return false;
float v;
readFloatAttr(".val", &v);
data->setValue(v);
return true;
}
void HAttributeGroup::writeString(AStringAttribute * data)
{
std::string v = data->value();
if(!hasNamedAttr(".val"))
addStringAttr(".val", v.size());
writeStringAttr(".val", v);
std::cout<<" value "<<v;
}
bool HAttributeGroup::readNumericValueAsInt(ANumericAttribute * data)
{
if(!hasNamedAttr(".val")) return false;
int v = 0;
readIntAttr(".val", &v);
data->setValue(v);
return true;
}
char HFltAttributeEntry::save(float * src)
{
if(!hasNamedAttr(".def_val"))
addFloatAttr(".def_val");
writeFloatAttr(".def_val", src);
return HAttributeEntry::save();
}
char HIntAttributeEntry::save(int * src)
{
if(!hasNamedAttr(".def_val"))
addIntAttr(".def_val");
writeIntAttr(".def_val", src);
return HAttributeEntry::save();
}
char HAnimationCurve::save(AAnimationCurve * curve)
{
if(!hasNamedAttr(".animcurve_type"))
addIntAttr(".animcurve_type");
int t = curve->curveType();
writeIntAttr(".animcurve_type", &t);
if(!hasNamedAttr(".n_keys"))
addIntAttr(".n_keys");
int n = curve->numKeys();
writeIntAttr(".n_keys", &n);
saveKeys(curve, n);
return 1;
}
char HAttributeEntry::save()
{
if(!hasNamedAttr(".attrib_typ"))
addIntAttr(".attrib_typ");
int typasi = attributeType();
writeIntAttr(".attrib_typ", &typasi);
return 1;
}
bool HAttributeGroup::loadString(AStringAttribute * data)
{
if(!hasNamedAttr(".val")) return false;
std::string v;
readStringAttr(".val", v);
data->setValue(v);
std::cout<<" value "<<v;
return true;
}
char HAttributeGroup::save(AAttribute * data)
{
if(!hasNamedAttr(".attr_typ"))
addIntAttr(".attr_typ");
int t = data->attrType();
writeIntAttr(".attr_typ", &t);
// std::cout<<"\nsave attr type "<<data->attrTypeStr();
if(!hasNamedAttr(".longname"))
addStringAttr(".longname", data->longName().size());
writeStringAttr(".longname", data->longName());
// std::cout<<"\nsave attr name "<<data->longName();
if(data->isNumeric()) writeNumeric( static_cast<ANumericAttribute *> (data) );
else if(data->isEnum()) writeEnum( static_cast<AEnumAttribute *> (data) );
else if(data->isString()) writeString( static_cast<AStringAttribute *> (data) );
else if(data->isCompound()) writeCompound( static_cast<ACompoundAttribute *> (data) );
return 1;
}
