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; }