/*! Visits a SFFieldContainerPtr (or more specific pointer type) during preWrite. It creates an element for the pointed to container and calls preWrite on it. If the pointed to container is not in the root's id set it is added and thus scheduled for writing. \param[in] fieldId Id of the field in the container of this element. */ void OSBCommonElement::preWritePtrSingleField(const UInt32 fieldId) { OSG_OSB_LOG(("OSBCommonElement::preWritePtrSingleField: " "fieldId: [%u]\n", fieldId)); OSBRootElement *root = editRoot(); FieldContainerPtrSFieldBase::GetHandlePtr sfPtrField = boost::dynamic_pointer_cast<FieldContainerPtrSFieldBase::GetHandle>( getContainer()->getField(fieldId)); if(sfPtrField == NULL || sfPtrField->isValid() == false) return; FieldContainer *refedFC = (*sfPtrField)->getValue(); if(refedFC == NULL) return; UInt32 refedId = refedFC->getId (); const std::string &typeName = refedFC->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) == 0) { OSBElementBase *elem = OSBElementFactory::the()->acquire( typeName, root); root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedFC); elem->preWrite (refedFC); } }
/*! Callback called for each element in an AttachmentMap (this is used by preWriteAttachmentMapField). */ void OSBCommonElement::handleAttachmentMapElementPreWrite( FieldContainer *refedFC) { OSG_OSB_LOG(("OSBCommonElement::handleAttachmentMapElementPreWrite\n")); if(refedFC == NULL) return; Attachment *refedAtt = dynamic_cast<Attachment *>(refedFC); // skip attachments marked as 'internal' if(refedAtt == NULL || refedAtt->getSFInternal()->getValue() == true ) { return; } OSBRootElement *root = editRoot(); UInt32 refedId = refedAtt->getId (); const std::string &typeName = refedAtt->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) > 0) return; OSBElementBase *elem = OSBElementFactory::the()->acquire(typeName, root); root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedAtt); elem->preWrite (refedAtt); }
void OSBChunkBlockElement::postRead(void) { // _mfChunks and _mfSlots have to be kept consistent for ChunkBlock. // Also TextureChunk is split into TextureObjChunk and TextureObjChunk // on load, so the slot info has to be duplicated. // TODO: // It would be better if that handling could be confined to // TextureChunkElement, but I've not found a good way to do that and keep // the information in _mfSlots correct. -- cneumann const OSBRootElement *root = getRoot(); ChunkBlock *chkMat = dynamic_cast<ChunkBlock *>(getContainer()); // No chunks loaded if(_chunksPtrFieldItValid == false) return; PtrFieldInfo::PtrIdStoreConstIt idIt = _chunksPtrFieldIt->getIdStore().begin(); PtrFieldInfo::PtrIdStoreConstIt idEnd = _chunksPtrFieldIt->getIdStore().end (); for(UInt32 i = 0; idIt != idEnd; ++idIt, ++i) { UInt32 uiId = (*idIt) & 0x00FFFFFF; UInt32 uiSlot = ((*idIt) & 0xFF000000) >> 24; OSBRootElement::IdElemMapConstIt mapIt = root->getIdElemMap().find(uiId); if(mapIt == root->getIdElemMap().end()) { continue; } OSBElementBase *chunkElem = mapIt->second; // other chunk StateChunk *chunk = dynamic_cast<StateChunk *>(chunkElem->getContainer()); chkMat->addChunk(chunk, uiSlot); } // pointer mapping is already done here for _mfChunks, clear info _chunksPtrFieldIt->editIdStore ().clear(); _chunksPtrFieldIt->editBindingStore().clear(); }
/*! Collects all containers that are reachable from \a fc and schedules them for writing. For each container an approriate element is created and its preWrite method is called, thus recursively discovering all reachable containers. \param[in] fc FieldContainer that is inspected for reachable containers. */ void OSBRootElement::preWrite(FieldContainer * const fc) { OSG_OSB_LOG(("OSBRootElement::preWrite\n")); if(fc == NULL) return; const std::string &typeName = fc->getType().getName(); OSBElementBase *elem = OSBElementFactory::the()->acquire( typeName, this); editElementList().push_back(elem); elem->setContainer(fc ); elem->setFCIdFile (fc->getId()); elem->preWrite (fc ); }
/*! Visits a MFFieldContainerPtr (or more specific pointer type) during preWrite. It creates elements for the pointed to containers and calls preWrite on them. If the pointed to containers are not in the root's id set they are added and thus scheduled for writing. \param[in] fieldId Id of the field in the container of this element. */ void OSBCommonElement::preWritePtrMultiField(const UInt32 fieldId) { OSG_OSB_LOG(("OSBCommonElement::preWritePtrMultiField: " "fieldId: [%u]\n", fieldId)); OSBRootElement *root = editRoot(); FieldContainerPtrMFieldBase::GetHandlePtr mfPtrField = boost::dynamic_pointer_cast<FieldContainerPtrMFieldBase::GetHandle>( getContainer()->getField(fieldId)); if(mfPtrField == NULL || mfPtrField->isValid() == false) return; FieldContainerPtrMFieldBase::const_iterator fieldIt = (*mfPtrField)->begin(); FieldContainerPtrMFieldBase::const_iterator fieldEnd = (*mfPtrField)->end (); for(; fieldIt != fieldEnd; ++fieldIt) { FieldContainer *refedFC = *fieldIt; if(refedFC == NULL) continue; UInt32 refedId = refedFC->getId (); const std::string &typeName = refedFC->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) > 0) continue; OSBElementBase *elem = OSBElementFactory::the()->acquire( typeName, root); root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedFC); elem->preWrite (refedFC); } }
/*! Callback called for each element in a map field (this is used by preWriteMapField). */ void OSBCommonElement::handleMapElementPreWrite(FieldContainer *refedFC) { if(refedFC == NULL) return; OSBRootElement *root = editRoot(); UInt32 refedId = refedFC->getId (); const std::string &typeName = refedFC->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) > 0) return; OSBElementBase *elem = OSBElementFactory::the()->acquire(typeName, root); root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedFC); elem->preWrite (refedFC); }
/*! Reads from the stream set by a preceding call to initialiseRead. Since the root element is the first one created it reads the file header and creates the elements to read the data following the header. \param[in] typeName The argument is ignored. */ void OSBRootElement::read(const std::string &/*typeName*/) { OSG_OSB_LOG(("OSBRootElement::read\n")); BinaryReadHandler *rh = getReadHandler(); std::string headerMarker; rh->getValue(headerMarker); if(headerMarker == OSGOSB_HEADER_ID_1) { OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n", OSGOSBHeaderVersion100)); setHeaderVersion(OSGOSBHeaderVersion100); } else if(headerMarker == OSGOSB_HEADER_ID_2) { OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n", OSGOSBHeaderVersion200)); setHeaderVersion(OSGOSBHeaderVersion200); } // else if(headerMarker == OSGOSB_HEADER_ID_201) // { // OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n", // OSGOSBHeaderVersion201)); // setHeaderVersion(OSGOSBHeaderVersion201); // } else { FWARNING(("OSBRootElement::read: Unrecognized file header, could not " "load file.\n")); return; } std::string headerName; rh->getValue(headerName); std::string headerOptions; rh->getValue(headerOptions); UInt64 fileSize; rh->getValue(fileSize); OSG_OSB_LOG(("OSBRootElement::read: headerName: [%s]\n", headerName.c_str())); OSG_OSB_LOG(("OSBRootElement::read: headerOptions: [%s]\n", headerOptions.c_str())); OSG_OSB_LOG(("OSBRootElement::read: fileSize: [%" PRISize "]\n", fileSize)); std::string fcTypeName; UInt32 fcIdFile; // id used in the file UInt32 fcIdSystem; // id used in the system OSBElementBase *elem; while(true) { if(!readFieldContainerHeader(fcTypeName, fcIdFile)) break; OSG_OSB_LOG(("OSBRootElement::read: fcTypeName [%s] fcIdFile: [%u]\n", fcTypeName.c_str(), fcIdFile)); elem = OSBElementFactory::the()->acquire(fcTypeName, this); elem->setFCIdFile(fcIdFile ); elem->read (fcTypeName); if(elem->getContainer() != NULL) { fcIdSystem = elem->getContainer()->getId(); OSG_OSB_LOG(("OSBRootElement::read: fcIdFile: [%u] fcIdSystem: [%u]\n", fcIdFile, fcIdSystem)); editIdMap().insert( FieldContainerIdMap::value_type(fcIdFile, fcIdSystem)); if(getContainer() == NULL) { setContainer(elem->getContainer()); } editElementList().push_back(elem ); editIdElemMap ().insert (std::make_pair(fcIdFile, elem)); } } }
void OSBGeometryElement::preWrite(FieldContainer * const fc) { OSG_OSB_LOG(("OSBGeometryElement::preWrite\n")); OSBRootElement *root = editRoot(); UInt32 fieldCount = fc->getType().getNumFieldDescs(); UInt8 quanResPositions = root->getOptions().quantizePositions(); UInt8 quanResNormals = root->getOptions().quantizeNormals (); UInt8 quanResTexCoords = root->getOptions().quantizeTexCoords(); bool packIndices = root->getOptions().packIndices (); // go through all fields and find those refering to other FCs for(UInt32 fieldId = 1; fieldId <= fieldCount; ++fieldId) { const FieldDescriptionBase *fieldDesc = fc->getFieldDescription(fieldId); const FieldType &fieldType = fieldDesc->getFieldType(); const std::string &fieldName = fieldDesc->getName (); // skip internal fields if(fieldDesc->isInternal()) { OSG_OSB_LOG(("OSBGeometryElement::preWrite: " "Skipping internal field: [%s]\n", fieldName.c_str())); continue; } if(fieldName == "properties") { // "properties" might be quantized FieldContainerPtrMFieldBase::GetHandlePtr fP = boost::dynamic_pointer_cast< FieldContainerPtrMFieldBase::GetHandle>( getContainer()->getField(fieldId)); if(fP == NULL || fP->isValid() == false) continue; FieldContainerPtrMFieldBase::const_iterator fieldIt = (*fP)->begin(); FieldContainerPtrMFieldBase::const_iterator fieldEnd = (*fP)->end (); for(UInt32 i = 0; fieldIt != fieldEnd; ++fieldIt, ++i) { FieldContainer *refedFC = *fieldIt; if(refedFC == NULL) continue; UInt32 refedId = refedFC->getId (); const std::string typeName = refedFC->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) > 0) continue; OSBElementBase *elem = OSBElementFactory::the()->acquire(typeName, root); OSBGeoVectorPropertyElement *propElem = dynamic_cast<OSBGeoVectorPropertyElement *>(elem); if((propElem != 0) && (i == Geometry::PositionsIndex)) { propElem->setQuantizeResolution(quanResPositions); } else if((propElem != 0) && (i == Geometry::NormalsIndex)) { propElem->setQuantizeResolution(quanResNormals); } else if((propElem != 0) && (i >= Geometry::TexCoordsIndex) && (i <= Geometry::TexCoords7Index) ) { propElem->setQuantizeResolution(quanResTexCoords); } root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedFC); elem->preWrite (refedFC); } } else if(fieldName == "propIndices") { // "propIndices" might be packed FieldContainerPtrMFieldBase::GetHandlePtr fP = boost::dynamic_pointer_cast< FieldContainerPtrMFieldBase::GetHandle>( getContainer()->getField(fieldId)); if(fP == NULL || fP->isValid() == false) continue; FieldContainerPtrMFieldBase::const_iterator fieldIt = (*fP)->begin(); FieldContainerPtrMFieldBase::const_iterator fieldEnd = (*fP)->end (); for(UInt32 i = 0; fieldIt != fieldEnd; ++fieldIt, ++i) { FieldContainer *refedFC = *fieldIt; if(refedFC == NULL) continue; UInt32 refedId = refedFC->getId (); const std::string typeName = refedFC->getType().getName(); // only schedule a container once if(root->getIdSet().count(refedId) > 0) continue; OSBElementBase *elem = OSBElementFactory::the()->acquire(typeName, root); OSBGeoIntegralPropertyElement *propElem = dynamic_cast<OSBGeoIntegralPropertyElement *>(elem); if((propElem != 0) && (packIndices == true)) { propElem->setPackData(true); } root->editIdSet ().insert (refedId); root->editElementList().push_back(elem ); elem->setContainer(refedFC); elem->preWrite (refedFC); } } else if(fieldName == "attachments") { preWriteAttachmentMapField(fieldId); } else { // check if field refers to another FC, i.e. its a field holding // FieldContainerPtr or an FieldContainerAttachmentMap if(fieldType.getContentType().isDerivedFrom( FieldTraits<FieldContainer *>::getType()) == true) { if(fieldType.getCardinality() == FieldType::SingleField) { preWritePtrSingleField(fieldId); } else if(fieldType.getCardinality() == FieldType::MultiField) { preWritePtrMultiField(fieldId); } } } } }