void test() { IServiceManager* servmgr; IStaticServiceHandler* handler; IMonikerService* monikers; IObject* test; IObject* obj; servmgr = XPLC::getServiceManager(); ASSERT(servmgr != 0, "could not obtain service manager"); obj = servmgr->getObject(XPLC::staticServiceHandler); ASSERT(obj != 0, "could not obtain static service handler"); handler = mutate<IStaticServiceHandler>(obj); ASSERT(handler != 0, "static service handler does not have the IStaticServiceHandler interface"); test = new TestObject; ASSERT(test != 0, "could not create TestObject"); test->addRef(); handler->addObject(TestObject_CID, test); VERIFY(servmgr->getObject(TestObject_CID) == test, "adding the test object did not work"); VERIFY(test->release() == 2, "incorrect refcount on test object"); obj = servmgr->getObject(XPLC::monikers); ASSERT(obj != 0, "could not obtain moniker component"); monikers = mutate<IMonikerService>(obj); ASSERT(monikers != 0, "moniker service does not have the IMoniker interface"); monikers->registerObject("moniker", XPLC::monikers); monikers->registerObject("testobject", TestObject_CID); obj = monikers->resolve("testobject"); ASSERT(obj != 0, "resolving the test object returned nothing"); ASSERT(obj == test, "the testobject moniker resolved to something else than the test object"); VERIFY(obj->release() == 2, "refcount is wrong on the test object"); obj = monikers->resolve("moniker:testobject"); ASSERT(obj != 0, "resolving the test object indirectly returned nothing"); ASSERT(obj == test, "the testobject moniker indirectly resolved to something else than the test object"); VERIFY(obj->release() == 2, "refcount is wrong on the test object"); obj = monikers->resolve("moniker:"); VERIFY(obj == 0, "resolving an empty sub-moniker returned something"); VERIFY(monikers->release() == 1, "incorrect refcount on moniker service"); VERIFY(handler->release() == 2, "incorrect refcount on static service handler"); servmgr->shutdown(); VERIFY(servmgr->release() == 0, "service manager has non-zero refcount after shutdown/release"); VERIFY(test->release() == 0, "refcount is wrong on the test object"); }
bool CVisitNodeDWORD::Visit(IComponent *component, bool bVisitEnter) { IObject *theObject; IHashString *objName; theObject = dynamic_cast<IObject *>(component); // if the object is invalid if (!theObject) { // log error return false; } // get the name of the object objName = theObject->GetName(); // add name to set m_DWORDSet->Add(objName); return true; }
DWORD CObjectCubeMapManager::PumpHandler(DWORD size, void *data, IHashString *name, IHashString *compType, MSGFUNCTION msgFunction) { MODELTOCUBETEXTUREMAP::iterator startIter; MODELTOCUBETEXTUREMAP::iterator endIter; DWORD retval = MSG_NOT_HANDLED; // specific object if (name != NULL) { startIter = m_ModelCubeTexturesMap.lower_bound(name->GetUniqueID()); endIter = m_ModelCubeTexturesMap.upper_bound(name->GetUniqueID()); } // pump through everything if no name is specified else { startIter = m_ModelCubeTexturesMap.begin(); endIter = m_ModelCubeTexturesMap.end(); } for (; startIter != endIter; startIter++) { IObject *object = startIter->second; if ((compType == NULL) || (object->IsKindOf(compType))) { retval = (object->*msgFunction)(size, data); if (retval == MSG_HANDLED_STOP) { return retval; } } } return retval; }
//-***************************************************************************** Box3d getBounds( IObject iObj ) { Box3d bnds; bnds.makeEmpty(); M44d xf = getFinalMatrix( iObj ); if ( IPolyMesh::matches( iObj.getMetaData() ) ) { IPolyMesh mesh( iObj, kWrapExisting ); IPolyMeshSchema ms = mesh.getSchema(); V3fArraySamplePtr positions = ms.getValue().getPositions(); size_t numPoints = positions->size(); for ( size_t i = 0 ; i < numPoints ; ++i ) { bnds.extendBy( (*positions)[i] ); } } else if ( ISubD::matches( iObj.getMetaData() ) ) { ISubD mesh( iObj, kWrapExisting ); ISubDSchema ms = mesh.getSchema(); V3fArraySamplePtr positions = ms.getValue().getPositions(); size_t numPoints = positions->size(); for ( size_t i = 0 ; i < numPoints ; ++i ) { bnds.extendBy( (*positions)[i] ); } } bnds.extendBy( Imath::transform( bnds, xf ) ); g_bounds.extendBy( bnds ); return bnds; }
void test() { MyTestObject* test = 0; IObject* iobj = 0; IFoo* ifoo = 0; IBar* ibar = 0; test = MyTestObject::create(); ASSERT(test, "could not instantiate test object"); iobj = static_cast<IFoo*>(test)->getInterface(IObject::IID); VERIFY(iobj, "getInterface(IObject::IID) failed on test object"); VERIFY(reinterpret_cast<void*>(iobj) == reinterpret_cast<void*>(test), "identity test failed"); ifoo = get<IFoo>(iobj); VERIFY(ifoo, "get<IFoo> failed on test object"); ibar = get<IBar>(ifoo); VERIFY(ibar, "get<IBar> failed on test object"); ifoo->setFoo(10); ibar->setBar(20); VERIFY(ifoo->getFoo() == 10, "test object has unexpected behavior"); VERIFY(ibar->getBar() == 20, "test object has unexpected behavior"); VERIFY(iobj->addRef() == 4, "incorrect refcount"); VERIFY(ifoo->addRef() == 5, "incorrect refcount"); VERIFY(ibar->addRef() == 6, "incorrect refcount"); VERIFY(iobj->release() == 5, "incorrect refcount"); VERIFY(ifoo->release() == 4, "incorrect refcount"); VERIFY(ibar->release() == 3, "incorrect refcount"); VERIFY(iobj->release() == 2, "incorrect refcount"); VERIFY(ifoo->release() == 1, "incorrect refcount"); VERIFY(ibar->release() == 0, "incorrect refcount"); }
void scopingTest(bool useOgawa) { { OObject top; { OArchive archive; if (useOgawa) { archive = CreateArchiveWithInfo( Alembic::AbcCoreOgawa::WriteArchive(), "archiveScopeTest.abc", "Alembic test", "", MetaData() ); } else { archive = CreateArchiveWithInfo( Alembic::AbcCoreHDF5::WriteArchive(), "archiveScopeTest.abc", "Alembic test", "", MetaData() ); } top = archive.getTop(); } OObject childA( top, "a"); OObject childB( top, "b"); ODoubleProperty prop(top.getProperties(), "prop", 0); TESTING_ASSERT(prop.getObject().getArchive().getName() == "archiveScopeTest.abc"); } { IObject top; { AbcF::IFactory factory; AbcF::IFactory::CoreType coreType; IArchive archive = factory.getArchive("archiveScopeTest.abc", coreType); TESTING_ASSERT( (useOgawa && coreType == AbcF::IFactory::kOgawa) || (!useOgawa && coreType == AbcF::IFactory::kHDF5) ); top = archive.getTop(); double start, end; GetArchiveStartAndEndTime( archive, start, end ); TESTING_ASSERT( start == DBL_MAX && end == -DBL_MAX ); } TESTING_ASSERT(top.getNumChildren() == 2 ); TESTING_ASSERT(top.getChildHeader("a") != NULL); TESTING_ASSERT(top.getChildHeader("b") != NULL); TESTING_ASSERT( ! top.getParent().valid() ); TESTING_ASSERT( top.getArchive().getName() == "archiveScopeTest.abc"); IScalarProperty prop(top.getProperties(), "prop"); TESTING_ASSERT(prop.valid()); TESTING_ASSERT(prop.getObject().getArchive().getName() == "archiveScopeTest.abc"); } }
ELAPI _Impl_CheckClsId( /* [in] */ PInterface serverObj, /* [in] */ const ClassID* classiD, /* [out] */ PInterface* outServerObj) { IObject* object; char str[80]; ClassID clsid; clsid.mUunm = str; object = (IObject*)serverObj->Probe(EIID_IObject); if (NULL == object) return E_INVALID_ARGUMENT; object->GetClassID(&clsid); while (*(EMuid *)&clsid != *(EMuid *)classiD) { object = (IObject*)object->Probe(EIID_SUPER_OBJECT); if (NULL == object) return E_INVALID_ARGUMENT; object->GetClassID(&clsid); } *outServerObj = object; // don't AddRef, Caller don't Release either. return NOERROR; }
//-***************************************************************************** void visitObject( IObject iObj, std::string iIndent ) { // Object has a name, a full name, some meta data, // and then it has a compound property full of properties. std::string path = iObj.getFullName(); if ( path != "/" ) { std::cout << "Object " << "name=" << path << std::endl; } // Get the properties. ICompoundProperty props = iObj.getProperties(); visitProperties( props, iIndent ); // now the child objects for ( size_t i = 0 ; i < iObj.getNumChildren() ; i++ ) { visitObject( IObject( iObj, iObj.getChildHeader( i ).getName() ), iIndent ); } }
virtual VkBool32 objectBindDrawIndexedRecursive(const IObject& object, const ICommandBuffersSP& cmdBuffer, const SmartPointerVector<IGraphicsPipelineSP>& allGraphicsPipelines, const uint32_t bufferIndex) const { if (viewFrustum) { if (viewFrustum->isVisible(object.getRootNode()->getBoundingSphere())) { return VK_TRUE; } return VK_FALSE; } return VK_TRUE; }
//-***************************************************************************** void ICompoundProperty::init ( const IObject & iObject, const Argument &iArg0, const Argument &iArg1 ) { getErrorHandler().setPolicy( GetErrorHandlerPolicy( iObject, iArg0, iArg1 ) ); ALEMBIC_ABC_SAFE_CALL_BEGIN( "ICompoundProperty::init( IObject )" ); m_property = iObject.getProperties().getPtr(); ALEMBIC_ABC_SAFE_CALL_END_RESET(); }
void DataNode::GetValueRaw(IObject& object) const { struct helper { static void ReadObject(void* object, const ObjectType& type, const DataNode& node) { for (auto baseType : type.GetBaseTypes()) { const ObjectType* baseObjectType = dynamic_cast<const ObjectType*>(baseType.type); if (!baseObjectType) continue; void* baseObject = (*baseType.dynamicCastUpFunc)(object); ReadObject(baseObject, *baseObjectType, node); } for (auto field : type.GetFields()) { auto srlzAttribute = field->GetAttribute<SerializableAttribute>(); if (srlzAttribute) { auto fldNode = node.GetNode(field->GetName()); if (fldNode) field->DeserializeFromObject(object, *fldNode); } } } }; const ObjectType& type = dynamic_cast<const ObjectType&>(object.GetType()); void* objectPtr = type.DynamicCastFromIObject(const_cast<IObject*>(&object)); helper::ReadObject(objectPtr, type, *this); if (object.GetType().IsBasedOn(TypeOf(ISerializable))) ((ISerializable&)object).OnDeserialized(*this); }
DWORD CCoordinateToolManager::OnDeleteObject(DWORD size, void *param) { // This message has its priority raised so that it gets called before the // parent entity's delete object. We MUST to remove coordinate tool // for entity, before its deletion. Otherwise physics will crash. // Is there any better solution, except to catch all DeleteObject messages? VERIFY_MESSAGE_SIZE(sizeof(DELETEOBJECTPARAMS), size); DELETEOBJECTPARAMS* dop = (DELETEOBJECTPARAMS*)param; IObject * object = FindByParent(dop->name); if (object != NULL) { // Remove coordinate tool for this parent object. DELETEOBJECTPARAMS dop; dop.name = object->GetName(); static DWORD msgHash_DeleteObject = CHashString(_T("DeleteObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_DeleteObject, sizeof(DELETEOBJECTPARAMS), &dop); m_CoordinateToolName = NULL; } return MSG_HANDLED_PROCEED; }
void readFlatHierarchy(const std::string &archiveName) { // Open an existing archive for reading. Indicate that we want // Alembic to throw exceptions on errors. AbcF::IFactory factory; factory.setPolicy( ErrorHandler::kThrowPolicy ); AbcF::IFactory::CoreType coreType; IArchive archive = factory.getArchive(archiveName, coreType); IObject archiveTop = archive.getTop(); // Determine the number of (top level) children the archive has const int numChildren = archiveTop.getNumChildren(); ABCA_ASSERT( numChildren == 10, "Expected 10 children, found " << numChildren ); std::cout << "The archive has " << numChildren << " children:" << std::endl; // Iterate through them, print out their names for (int ii=0; ii<numChildren; ii++) { IObject child( archiveTop, archiveTop.getChildHeader(ii).getName() ); std::cout << " " << child.getName(); const unsigned int children = child.getNumChildren(); std::cout << " has " << children << " children" << std::endl; ABCA_ASSERT( children == 0, "Expected no children, found " << children ); } // Done - the archive closes itself }
//-***************************************************************************** void pruneTest() { std::string fileName = "objectPrune1.abc"; std::string fileName2 = "objectPrune2.abc"; { OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName ); OObject child( archive.getTop(), "child" ); OObject childCool( child, "cool" ); OObject childGuy( child, "guy" ); OObject childA( archive.getTop(), "childA" ); OObject childAA( childA, "A" ); OObject childB( archive.getTop(), "childB" ); OObject childBB( childB, "B" ); } { MetaData md; Alembic::AbcCoreLayer::SetPrune( md, true ); OArchive archive( Alembic::AbcCoreOgawa::WriteArchive(), fileName2 ); OObject child( archive.getTop(), "child" ); OObject childGuy( child, "guy", md ); OObject childA( archive.getTop(), "childA" ); OObject childAA( childA, "A", md ); OObject childAB( childA, "B", md ); OObject childB( archive.getTop(), "childB", md ); } { std::vector< std::string > files; files.push_back( fileName ); files.push_back( fileName2 ); Alembic::AbcCoreFactory::IFactory factory; IArchive archive = factory.getArchive( files ); // child, childA, childB TESTING_ASSERT( archive.getTop().getNumChildren() == 2 ); IObject child = archive.getTop().getChild("child"); TESTING_ASSERT( child.getNumChildren() == 1 ); TESTING_ASSERT( child.getChild("cool").valid() ); TESTING_ASSERT( child.getChild("cool").getNumChildren() == 0 ); IObject childA = archive.getTop().getChild("childA"); TESTING_ASSERT( childA.getNumChildren() == 0 ); } }
/** * Return a random point in a generic shape limited by a bounding box. * @param object an object in which the point is generated * @param rng a random number generator * @param box a box restricting the point's volume * @param maxAttempts number of attempts to find a suitable point * @return a point or none if maxAttempts was exceeded */ boost::optional<Kernel::V3D> bounded(const IObject &object, Kernel::PseudoRandomNumberGenerator &rng, const BoundingBox &box, size_t maxAttempts) { boost::optional<Kernel::V3D> point{boost::none}; if (box.isNull()) { throw std::invalid_argument( "Invalid bounding box. Cannot generate random point."); } for (size_t attempts{0}; attempts < maxAttempts; ++attempts) { const double r1 = rng.nextValue(); const double r2 = rng.nextValue(); const double r3 = rng.nextValue(); auto pt = box.generatePointInside(r1, r2, r3); if (object.isValid(pt)) { point = pt; break; } }; return point; }
void IGeom::setupWithObject(IObject object) { size_t numChildren = object.getNumChildren(); for (size_t i = 0; i < numChildren; ++i) { const ObjectHeader &ohead = object.getChildHeader(i); ofPtr<IGeom> dptr; if (Alembic::AbcGeom::IPolyMesh::matches(ohead)) { Alembic::AbcGeom::IPolyMesh pmesh(object, ohead.getName()); if (pmesh) { dptr.reset(new ofxAlembic::IPolyMesh(pmesh)); } } else if (Alembic::AbcGeom::IPoints::matches(ohead)) { Alembic::AbcGeom::IPoints points(object, ohead.getName()); if (points) { dptr.reset(new ofxAlembic::IPoints(points)); } } else if (Alembic::AbcGeom::ICurves::matches(ohead)) { Alembic::AbcGeom::ICurves curves(object, ohead.getName()); if (curves) { dptr.reset(new ofxAlembic::ICurves(curves)); } } else if (Alembic::AbcGeom::INuPatch::matches(ohead)) { ofLogError("ofxAlembic") << "INuPatch not implemented"; assert(false); // Alembic::AbcGeom::INuPatch nuPatch(object, ohead.getName()); // if ( nuPatch ) // { // dptr.reset( new INuPatchDrw( nuPatch ) ); // } } else if (Alembic::AbcGeom::IXform::matches(ohead)) { Alembic::AbcGeom::IXform xform(object, ohead.getName()); if (xform) { dptr.reset(new ofxAlembic::IXform(xform)); } } else if (Alembic::AbcGeom::ISubD::matches(ohead)) { ofLogError("ofxAlembic") << "ISubD not implemented"; assert(false); // Alembic::AbcGeom::ISubD subd(object, ohead.getName()); // if ( subd ) // { // dptr.reset( new ISubDDrw( subd ) ); // } } else if (Alembic::AbcGeom::ICamera::matches(ohead)) { Alembic::AbcGeom::ICamera camera(object, ohead.getName()); if (camera) { dptr.reset(new ofxAlembic::ICamera(camera)); } } else { ofLogError("ofxAlembic") << "unknown object type: " << ohead.getFullName(); } if (dptr && dptr->valid()) { dptr->index = m_children.size(); m_children.push_back(dptr); m_minTime = std::min(m_minTime, dptr->m_minTime); m_maxTime = std::max(m_maxTime, dptr->m_maxTime); } } }
void BIF_ObjInvoke(ExprTokenType &aResultToken, ExprTokenType *aParam[], int aParamCount) { int invoke_type; IObject *obj; ExprTokenType *obj_param; // Since ObjGet/ObjSet/ObjCall are not publicly accessible as functions, Func::mName // (passed via aResultToken.marker) contains the actual flag rather than a name. invoke_type = (int)(INT_PTR)aResultToken.marker; // Set default return value; ONLY AFTER THE ABOVE. aResultToken.symbol = SYM_STRING; aResultToken.marker = _T(""); obj_param = *aParam; // aParam[0]. Load-time validation has ensured at least one parameter was specified. ++aParam; --aParamCount; // The following is used in place of TokenToObject to bypass #Warn UseUnset: if (obj_param->symbol == SYM_OBJECT) obj = obj_param->object; else if (obj_param->symbol == SYM_VAR && obj_param->var->HasObject()) obj = obj_param->var->Object(); else obj = NULL; if (obj) { bool param_is_var = obj_param->symbol == SYM_VAR; if (param_is_var) // Since the variable may be cleared as a side-effect of the invocation, call AddRef to ensure the object does not expire prematurely. // This is not necessary for SYM_OBJECT since that reference is already counted and cannot be released before we return. Each object // could take care not to delete itself prematurely, but it seems more proper, more reliable and more maintainable to handle it here. obj->AddRef(); obj->Invoke(aResultToken, *obj_param, invoke_type, aParam, aParamCount); if (param_is_var) obj->Release(); } // Invoke meta-functions of g_MetaObject. else if (INVOKE_NOT_HANDLED == g_MetaObject.Invoke(aResultToken, *obj_param, invoke_type | IF_META, aParam, aParamCount)) { // Since above did not handle it, check for attempts to access .base of non-object value (g_MetaObject itself). if ( invoke_type != IT_CALL // Exclude things like "".base(). && aParamCount > (invoke_type == IT_SET ? 2 : 0) // SET is supported only when an index is specified: "".base[x]:=y && !_tcsicmp(TokenToString(*aParam[0]), _T("base")) ) { if (aParamCount > 1) // "".base[x] or similar { // Re-invoke g_MetaObject without meta flag or "base" param. ExprTokenType base_token; base_token.symbol = SYM_OBJECT; base_token.object = &g_MetaObject; g_MetaObject.Invoke(aResultToken, base_token, invoke_type, aParam + 1, aParamCount - 1); } else // "".base { // Return a reference to g_MetaObject. No need to AddRef as g_MetaObject ignores it. aResultToken.symbol = SYM_OBJECT; aResultToken.object = &g_MetaObject; } } else { // Since it wasn't handled (not even by g_MetaObject), maybe warn at this point: if (obj_param->symbol == SYM_VAR) obj_param->var->MaybeWarnUninitialized(); } } }
bool CWorldVisitor::Visit( IComponent * component, bool bVisitEnter ) { IObject *theObject; IHashString *name; IHashString *parentName; IHashString *type; StdString parentType; StdString childType; std::string str; theObject = dynamic_cast<IObject *>(component); // This shouldn't happen but it does for some odd reason.... assert(theObject); if( theObject == NULL ) { return false; } name = theObject->GetName(); parentName = theObject->GetParentName(); type = theObject->GetComponentType(); //Check to see if it is a valid object (for object exclusion) if( !CheckObject( type->GetString() ) ) { return true; } else { if ( name == NULL ) { name = &CHashString(_T("NULL")); } if( bVisitEnter == true ) { //if( (m_pArchiver != NULL) && ( _tcscmp( type->GetString(), _T("CPhysicsObject") ) != 0 ) ) if( (m_pArchiver != NULL) ) { // Start the Node m_pArchiver->StartClass( type->GetString() ); // Write out the Unique ID aka Name m_pArchiver->Write( name->GetString(), _T("Name") ); theObject->Serialize( *m_pArchiver ); } // Removal of CPhysShape and changes to CPhysicsObject if( _tcscmp( type->GetString(), _T("CPhysicsObject") ) == 0 ) { CPhysObjectStruct tmpCPhysObject; StdString CPhyShapeFile; StdString CPhyShapeFileOld; // if it's parent is not a CTerrainSector Object if( _tcsstr( name->GetString(), _T("Terrain") ) == NULL ) { static DWORD msgHash_GetModelFileName = CHashString(_T("GetModelFileName")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_GetModelFileName, sizeof(StdString*), &CPhyShapeFile, parentName, NULL ); CPhyShapeFile += _T(".psl"); } // CTerrainSector Object else { CPhyShapeFile = _T("maps\\terrain.psl"); } IArchive *PhysObjectIn; IArchive *PhysObjectRead; CHashString memTypePhysObjectIn(_T("Memory")); int PhysObjectInMemSize = 1024 * 1024 * sizeof(char); char* PhysObjectInMemChunk = new char[PhysObjectInMemSize]; memset( PhysObjectInMemChunk, 0, PhysObjectInMemSize ); CREATEARCHIVE caPhysObjectIn; caPhysObjectIn.mode = STREAM_MODE_READ; caPhysObjectIn.streamData = PhysObjectInMemChunk; caPhysObjectIn.streamSize = PhysObjectInMemSize; caPhysObjectIn.streamType = &memTypePhysObjectIn; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObjectIn) != MSG_HANDLED) { return true; } PhysObjectIn = caPhysObjectIn.archive; CREATESTREAM csPhysObjectIn; csPhysObjectIn.streamData = caPhysObjectIn.streamData; csPhysObjectIn.streamSize = caPhysObjectIn.streamSize; csPhysObjectIn.mode = STREAM_MODE_WRITE; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObjectIn) != MSG_HANDLED) { return true; } PhysObjectIn->Init(csPhysObjectIn.openStream); SERIALIZEOBJECTPARAMS sop; sop.name = name; sop.archive = PhysObjectIn; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); PhysObjectIn->Close(); CREATEARCHIVE caPhysObjectRead; caPhysObjectRead.mode = STREAM_MODE_WRITE; caPhysObjectRead.streamData = PhysObjectInMemChunk; caPhysObjectRead.streamSize = PhysObjectInMemSize; caPhysObjectRead.streamType = &memTypePhysObjectIn; if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObjectRead) != MSG_HANDLED) { return true; } PhysObjectRead = caPhysObjectRead.archive; CREATESTREAM csPhysObjectRead; csPhysObjectRead.streamData = caPhysObjectRead.streamData; csPhysObjectRead.streamSize = caPhysObjectRead.streamSize; csPhysObjectRead.mode = STREAM_MODE_READ; if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObjectRead) != MSG_HANDLED) { return true; } PhysObjectRead->Init(csPhysObjectRead.openStream); PhysObjectRead->Read( tmpCPhysObject.vPosition, _T("pos") ); PhysObjectRead->Read( tmpCPhysObject.vRotation, _T("rot") ); PhysObjectRead->Read( tmpCPhysObject.vScale, _T("scale") ); PhysObjectRead->Read( tmpCPhysObject.fMass, _T("mass") ); PhysObjectRead->Read( tmpCPhysObject.szDynamic, _T("dynamics") ); PhysObjectRead->Read( CPhyShapeFileOld, _T("shapeFile") ); PhysObjectRead->Close(); // Archive the Data Back In IArchive *MemArchivePhysObject; CHashString memTypePhysObject(_T("Memory")); //int sizePhysObject = 1024 * 1024; //char* memchunkPhysObject = new char[sizePhysObject]; CREATEARCHIVE caPhysObject; caPhysObject.mode = STREAM_MODE_WRITE; caPhysObject.streamData = PhysObjectInMemChunk; caPhysObject.streamSize = PhysObjectInMemSize; caPhysObject.streamType = &memTypePhysObject; if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caPhysObject) != MSG_HANDLED) { return true; } MemArchivePhysObject = caPhysObject.archive; MemArchivePhysObject->Write( tmpCPhysObject.vPosition, _T("pos") ); MemArchivePhysObject->Write( tmpCPhysObject.vRotation, _T("rot") ); MemArchivePhysObject->Write( tmpCPhysObject.vScale, _T("scale") ); MemArchivePhysObject->Write( tmpCPhysObject.fMass, _T("mass") ); MemArchivePhysObject->Write( tmpCPhysObject.szDynamic, _T("dynamics") ); MemArchivePhysObject->Write( CPhyShapeFile, _T("shapeFile") ); CREATESTREAM csPhysObject; csPhysObject.streamData = caPhysObject.streamData; csPhysObject.streamSize = caPhysObject.streamSize; csPhysObject.mode = STREAM_MODE_READ; if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csPhysObject) != MSG_HANDLED) { return true; } MemArchivePhysObject->Init(csPhysObject.openStream); SERIALIZEOBJECTPARAMS sopPhysObject; sopPhysObject.name = name; sopPhysObject.archive = MemArchivePhysObject; m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sopPhysObject, NULL, NULL); MemArchivePhysObject->Close(); //delete [] memchunkPhysObject; //memchunkPhysObject = NULL; delete [] PhysObjectInMemChunk; PhysObjectInMemChunk = NULL; } // Model Rename Changes if( (m_pReporter != NULL) && ( _tcscmp( type->GetString(), _T("CV3ORenderObject") ) == 0 ) ) { IArchive *MemArchive; IArchive *MemArchive2; CHashString memType(_T("Memory")); memset( m_pMemChunk, '\0', m_iMemSize ); CREATEARCHIVE ca; ca.mode = STREAM_MODE_READ; ca.streamData = m_pMemChunk; ca.streamSize = m_iMemSize; ca.streamType = &memType; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca) != MSG_HANDLED) { return true; } MemArchive = ca.archive; CREATESTREAM cs; cs.streamData = ca.streamData; cs.streamSize = ca.streamSize; cs.mode = STREAM_MODE_WRITE; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs) != MSG_HANDLED) { return true; } MemArchive->Init(cs.openStream); SERIALIZEOBJECTPARAMS sop; sop.name = name; sop.archive = MemArchive; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sop, NULL, NULL); MemArchive->Close(); CREATEARCHIVE ca2; ca2.mode = STREAM_MODE_WRITE; ca2.streamData = m_pMemChunk; ca2.streamSize = m_iMemSize; ca2.streamType = &memType; if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &ca2) != MSG_HANDLED) { return true; } MemArchive2 = ca2.archive; CREATESTREAM cs2; cs2.streamData = ca2.streamData; cs2.streamSize = ca2.streamSize; cs2.mode = STREAM_MODE_READ; if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &cs2) != MSG_HANDLED) { return true; } MemArchive2->Init(cs2.openStream); StdString wszModelFileName; Vec3 Position; Vec3 Rotation; Vec3 Scale; MemArchive2->Read( wszModelFileName ); MemArchive2->Read( Position ); MemArchive2->Read( Rotation ); MemArchive2->Read( Scale ); MemArchive2->Close(); MODELMAP::iterator itr; bool bReArchive = false; while( 1 ) { itr = m_vModelReference.find( wszModelFileName ); // If the Model Refernce already exists if( itr != m_vModelReference.end() ) { // If its newfilename is different and it isn't an empty string // We Change the file name and set the archive flag if( (wszModelFileName != itr->second.m_wszNewFileName) && (itr->second.m_wszNewFileName != StdString("")) ) { wszModelFileName = itr->second.m_wszNewFileName; bReArchive = true; } // We've reached a file that has the same exact newfilename, no change neccisary else { break; } } // We change model name first (up above) and then make sure to add it as a reference and break out itr = m_vModelReference.find( wszModelFileName ); if( itr == m_vModelReference.end() ) { /* MODELINFO tmpModelInfo; tmpModelInfo.m_wszNewFileName = wszModelFileName; m_vModelReference[wszModelFileName] = tmpModelInfo; m_iNewEntries++; */ break; } } m_szLastV3OFileName = wszModelFileName; // Archive the object back out if( bReArchive == true ) { IArchive *MemArchiveRE; CHashString memTypeRE(_T("Memory")); int sizeRE = 1024 + sizeof(Vec3) * 3; char* memchunkRE = new char[sizeRE]; CREATEARCHIVE caRE; caRE.mode = STREAM_MODE_WRITE; caRE.streamData = memchunkRE; caRE.streamSize = sizeRE; caRE.streamType = &memTypeRE; static DWORD msgHash_CreateArchive = CHashString(_T("CreateArchive")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateArchive, sizeof(CREATEARCHIVE), &caRE) != MSG_HANDLED) { return true; } MemArchiveRE = caRE.archive; MemArchiveRE->Write( wszModelFileName ); MemArchiveRE->Write( Position ); MemArchiveRE->Write( Rotation ); MemArchiveRE->Write( Scale ); CREATESTREAM csRE; csRE.streamData = caRE.streamData; csRE.streamSize = caRE.streamSize; csRE.mode = STREAM_MODE_READ; static DWORD msgHash_CreateStream_Memory = CHashString(_T("CreateStream_Memory")).GetUniqueID(); if (m_ToolBox->SendMessage(msgHash_CreateStream_Memory, sizeof(CREATESTREAM), &csRE) != MSG_HANDLED) { return true; } MemArchiveRE->Init(csRE.openStream); SERIALIZEOBJECTPARAMS sopRE; sopRE.name = name; sopRE.archive = MemArchiveRE; static DWORD msgHash_SerializeObject = CHashString(_T("SerializeObject")).GetUniqueID(); m_ToolBox->SendMessage(msgHash_SerializeObject, sizeof(SERIALIZEOBJECTPARAMS), &sopRE, NULL, NULL); MemArchiveRE->Close(); delete [] memchunkRE; memchunkRE = NULL; m_iV3ONameEdits++; } } } // bVisitEnter == false else { if( m_pArchiver != NULL ) { m_pArchiver->EndClass(); } } } return true; }
void Movie::PostExec(bool progressing) { hasButton = false; if (!active) return; m_execedFrame = -1; bool postExeced = m_postExecCount == lwf->execCount; if (progressing && playing && !m_jumped && !postExeced) { ++m_currentFrameInternal; currentFrame = m_currentFrameInternal + 1; } for (;;) { if (m_currentFrameInternal < 0 || m_currentFrameInternal >= totalFrames) { m_currentFrameInternal = 0; currentFrame = m_currentFrameInternal + 1; } if (m_currentFrameInternal == m_execedFrame) break; m_currentFrameCurrent = m_currentFrameInternal; m_execedFrame = m_currentFrameCurrent; const Data *d = lwf->data.get(); const Format::Frame &frame = d->frames[ data->frameOffset + m_currentFrameCurrent]; int controlAnimationOffset; IObject *instance; if (m_lastControlOffset == frame.controlOffset && m_lastControls == frame.controls) { controlAnimationOffset = m_lastControlAnimationOffset; if (m_skipped) { instance = m_instanceHead; while (instance) { if (instance->IsMovie()) { Movie *movie = (Movie *)instance; movie->m_attachMovieExeced = false; movie->m_attachMoviePostExeced = false; } else if (instance->IsButton()) { ((Button *)instance)->EnterFrame(); } instance = instance->linkInstance; } hasButton = m_lastHasButton; } else { for (int dlDepth = 0; dlDepth < data->depths; ++dlDepth) { Object *obj = m_displayList[dlDepth].get(); if (obj) { if (!postExeced) { obj->matrixIdChanged = false; obj->colorTransformIdChanged = false; } if (obj->IsMovie()) { Movie *movie = (Movie *)obj; movie->m_attachMovieExeced = false; movie->m_attachMoviePostExeced = false; } else if (obj->IsButton()) { ((Button *)obj)->EnterFrame(); hasButton = true; } } } m_lastHasButton = hasButton; m_skipped = true; } } else { ++m_movieExecCount; m_instanceHead = 0; m_instanceTail = 0; m_lastControlOffset = frame.controlOffset; m_lastControls = frame.controls; controlAnimationOffset = -1; for (int i = 0; i < frame.controls; ++i) { const Format::Control &control = d->controls[frame.controlOffset + i]; switch (control.controlType) { case Format::Control::MOVE: { const Format::Place &p = d->places[control.controlId]; ExecObject(p.depth, p.objectId, p.matrixId, 0, p.instanceId, p.blendMode); } break; case Format::Control::MOVEM: { const Format::ControlMoveM &ctrl = d->controlMoveMs[control.controlId]; const Format::Place &p = d->places[ctrl.placeId]; ExecObject(p.depth, p.objectId, ctrl.matrixId, 0, p.instanceId, p.blendMode); } break; case Format::Control::MOVEC: { const Format::ControlMoveC &ctrl = d->controlMoveCs[control.controlId]; const Format::Place &p = d->places[ctrl.placeId]; ExecObject(p.depth, p.objectId, p.matrixId, ctrl.colorTransformId, p.instanceId, p.blendMode); } break; case Format::Control::MOVEMC: { const Format::ControlMoveMC &ctrl = d->controlMoveMCs[control.controlId]; const Format::Place &p = d->places[ctrl.placeId]; ExecObject(p.depth, p.objectId, ctrl.matrixId, ctrl.colorTransformId, p.instanceId, p.blendMode); } break; case Format::Control::ANIMATION: if (controlAnimationOffset == -1) controlAnimationOffset = i; break; case Format::Control::CONTROL_MAX: // SUPPRESS WARNING break; } } m_lastControlAnimationOffset = controlAnimationOffset; m_lastHasButton = hasButton; for (int dlDepth = 0; dlDepth < data->depths; ++dlDepth) { Object *obj = m_displayList[dlDepth].get(); if (obj && obj->execCount != m_movieExecCount) { if (m_texts && obj->IsText()) EraseText(obj->objectId); obj->Destroy(); m_displayList[dlDepth].reset(); } } } m_attachMovieExeced = true; if (!m_attachedMovies.empty()) { AttachedMovieList::iterator it(m_attachedMovieList.begin()), itend(m_attachedMovieList.end()); for (; it != itend; ++it) if (it->second) it->second->Exec(); } m_attachMoviePostExeced = true; instance = m_instanceHead; while (instance) { if (instance->IsMovie()) { Movie *movie = (Movie *)instance; movie->PostExec(progressing); if (!hasButton && movie->hasButton) hasButton = true; } instance = instance->linkInstance; } if (!m_attachedMovies.empty()) { DetachDict::const_iterator dit(m_detachedMovies.begin()), ditend(m_detachedMovies.end()); for (; dit != ditend; ++dit) { AttachedMovies::iterator it = m_attachedMovies.find(dit->first); if (it != m_attachedMovies.end()) DeleteAttachedMovie(this, it->second, true, false); } m_detachedMovies.clear(); AttachedMovieList::iterator it(m_attachedMovieList.begin()), itend(m_attachedMovieList.end()); for (; it != itend; ++it) { if (it->second) { it->second->PostExec(progressing); if (!hasButton && it->second->hasButton) hasButton = true; } } } if (!m_attachedLWFs.empty()) hasButton = true; if (!m_postLoaded) { m_postLoaded = true; #if defined(LWF_USE_LUA) if (m_isRoot && !m_rootPostLoadFunc.empty()) lwf->CallFunctionLua(m_rootPostLoadFunc, this); if (!m_postLoadFunc.empty()) lwf->CallFunctionLua(m_postLoadFunc, this); #endif if (!m_handler.Empty()) m_handler.Call(METype::POSTLOAD, this); } if (controlAnimationOffset != -1 && m_execedFrame == m_currentFrameInternal) { bool animationPlayed = m_animationPlayedFrame == m_currentFrameCurrent && !m_jumped; if (!animationPlayed) { for (int i = controlAnimationOffset; i < frame.controls; ++i) { const Format::Control &control = d->controls[frame.controlOffset + i]; lwf->PlayAnimation(control.controlId, this); } } } m_animationPlayedFrame = m_currentFrameCurrent; if (m_currentFrameCurrent == m_currentFrameInternal) m_jumped = false; } #if defined(LWF_USE_LUA) if (m_isRoot && !m_rootEnterFrameFunc.empty()) lwf->CallFunctionLua(m_rootEnterFrameFunc, this); if (!m_enterFrameFunc.empty()) lwf->CallFunctionLua(m_enterFrameFunc, this); #endif PlayAnimation(ClipEvent::ENTERFRAME); if (!m_handler.Empty()) m_handler.Call(METype::ENTERFRAME, this); m_postExecCount = lwf->execCount; }
//-***************************************************************************** //-***************************************************************************** // DO IT. //-***************************************************************************** //-***************************************************************************** int main( int argc, char *argv[] ) { if (argc < 4) { std::cerr << "USAGE: " << argv[0] << " outFile.abc inFile1.abc" << " inFile2.abc (inFile3.abc ...)" << std::endl; return -1; } { size_t numInputs = argc - 2; std::vector< chrono_t > minVec; minVec.reserve(numInputs); std::vector< IArchive > iArchives; iArchives.reserve(numInputs); std::map< chrono_t, size_t > minIndexMap; size_t rootChildren = 0; Alembic::AbcCoreFactory::IFactory factory; factory.setPolicy(ErrorHandler::kThrowPolicy); Alembic::AbcCoreFactory::IFactory::CoreType coreType; for (int i = 2; i < argc; ++i) { IArchive archive = factory.getArchive(argv[i], coreType); if (!archive.valid() || archive.getTop().getNumChildren() < 1) { std::cerr << "ERROR: " << argv[i] << " not a valid Alembic file" << std::endl; return 1; } IObject iRoot = archive.getTop(); size_t numChildren = iRoot.getNumChildren(); if (i == 2) { rootChildren = numChildren; } else if (rootChildren != numChildren) { std::cerr << "ERROR: " << argv[i] << " doesn't have the same number of children as: " << argv[i-1] << std::endl; } // reorder the input files according to their mins chrono_t min = DBL_MAX; Alembic::Util::uint32_t numSamplings = archive.getNumTimeSamplings(); if (numSamplings > 1) { // timesampling index 0 is special, so it will be skipped // // make sure all the other timesampling objects start at // the same time or throw here // min = archive.getTimeSampling(1)->getSampleTime(0); for (Alembic::Util::uint32_t s = 2; s < numSamplings; ++s) { chrono_t thisMin = archive.getTimeSampling(s)->getSampleTime(0); if (fabs(thisMin - min) > 1e-5) { std::cerr << "ERROR: " << argv[i] << " has non-default TimeSampling objects" << " that don't start at the same time." << std::endl; return 1; } } minVec.push_back(min); if (minIndexMap.count(min) == 0) { minIndexMap.insert(std::make_pair(min, i-2)); } else if (argv[2] != argv[i]) { std::cerr << "ERROR: overlapping frame range between " << argv[2] << " and " << argv[i] << std::endl; return 1; } } else { std::cerr << "ERROR: " << archive.getName() << " only has default (static) TimeSampling." << std::endl; return 1; } iArchives.push_back(archive); } // now reorder the input nodes so they are in increasing order of their // min values in the frame range std::sort(minVec.begin(), minVec.end()); std::vector< IArchive > iOrderedArchives; iOrderedArchives.reserve(numInputs); for (size_t f = 0; f < numInputs; ++f) { size_t index = minIndexMap.find(minVec[f])->second; iOrderedArchives.push_back(iArchives[index]); } std::string appWriter = "AbcStitcher"; std::string fileName = argv[1]; std::string userStr; // Create an archive with the default writer OArchive oArchive; if (coreType == Alembic::AbcCoreFactory::IFactory::kHDF5) { oArchive = CreateArchiveWithInfo( Alembic::AbcCoreHDF5::WriteArchive(), fileName, appWriter, userStr, ErrorHandler::kThrowPolicy); } else if (coreType == Alembic::AbcCoreFactory::IFactory::kOgawa) { oArchive = CreateArchiveWithInfo( Alembic::AbcCoreOgawa::WriteArchive(), fileName, appWriter, userStr, ErrorHandler::kThrowPolicy); } OObject oRoot = oArchive.getTop(); if (!oRoot.valid()) return -1; std::vector<IObject> iRoots; iRoots.resize(numInputs); for (size_t f = 0; f < rootChildren; ++f) { for (size_t g = 0; g < numInputs; ++g) { iRoots[g] = iOrderedArchives[g].getTop().getChild(f); } visitObjects(iRoots, oRoot); } // collect the top level compound property ICompoundPropertyVec iCompoundProps; iCompoundProps.reserve(numInputs); for (size_t f = 0; f < numInputs; ++f) { iCompoundProps.push_back(iRoots[f].getParent().getProperties()); } OCompoundProperty oCompoundProperty = oRoot.getProperties(); stitchCompoundProp(iCompoundProps, oCompoundProperty); } return 0; }
//-***************************************************************************** void diabolicalInstance( const std::string& iArchiveName, bool useOgawa ) { /* a0 b0 (points to a0) / | a1 b1 (points to a1) / | a2 b2 (points to b2) */ { OArchive archive; if (useOgawa) { archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(), iArchiveName, ErrorHandler::kThrowPolicy ); } else { archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(), iArchiveName, ErrorHandler::kThrowPolicy ); } OObject topobj = archive.getTop(); OObject a0( topobj, "a0" ); TESTING_ASSERT( topobj.addChildInstance( a0, "b0" ) ); OObject a1( a0, "a1" ); TESTING_ASSERT( a0.addChildInstance( a1, "b1" ) ); OObject a2( a1, "a2" ); TESTING_ASSERT( a1.addChildInstance( a2, "b2" ) ); } { AbcF::IFactory factory; IArchive archive = factory.getArchive( iArchiveName ); IObject topObject = archive.getTop(); IObject a0( topObject.getChild(0) ); TESTING_ASSERT( !a0.isInstanceDescendant() ); TESTING_ASSERT( a0.getFullName() == "/a0" ); TESTING_ASSERT( !a0.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0.getParent().getFullName() == "/" ); IObject b0( topObject.getChild(1) ); TESTING_ASSERT( b0.isInstanceDescendant() ); TESTING_ASSERT( b0.getName() == "b0" ); TESTING_ASSERT( b0.getFullName() == "/b0" ); TESTING_ASSERT( !b0.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0.getParent().getFullName() == "/" ); IObject a0a1( a0.getChild(0) ); TESTING_ASSERT( !a0a1.isInstanceDescendant() ); TESTING_ASSERT( a0a1.getName() == "a1" ); TESTING_ASSERT( a0a1.getFullName() == "/a0/a1" ); TESTING_ASSERT( !a0a1.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0a1.getParent().getName() == "a0" ); TESTING_ASSERT( a0a1.getParent().getFullName() == "/a0" ); IObject a0b1( a0.getChild(1) ); TESTING_ASSERT( a0b1.isInstanceDescendant() ); TESTING_ASSERT( a0b1.getName() == "b1" ); TESTING_ASSERT( a0b1.getFullName() == "/a0/b1" ); TESTING_ASSERT( !a0b1.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0b1.getParent().getName() == "a0" ); TESTING_ASSERT( a0b1.getParent().getFullName() == "/a0" ); IObject b0a1( b0.getChild(0) ); TESTING_ASSERT( b0a1.isInstanceDescendant() ); TESTING_ASSERT( b0a1.getParent().isInstanceDescendant() ); IObject b0b1( b0.getChild(1) ); TESTING_ASSERT( b0b1.isInstanceDescendant() ); TESTING_ASSERT( b0b1.getName() == "b1" ); TESTING_ASSERT( b0b1.getFullName() == "/b0/b1" ); TESTING_ASSERT( b0b1.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0b1.getParent().getName() == "b0" ); TESTING_ASSERT( b0b1.getParent().getFullName() == "/b0" ); IObject a0a1a2( a0a1.getChild(0) ); TESTING_ASSERT( !a0a1a2.isInstanceDescendant() ); TESTING_ASSERT( a0a1a2.getName() == "a2" ); TESTING_ASSERT( a0a1a2.getFullName() == "/a0/a1/a2" ); TESTING_ASSERT( !a0a1a2.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0a1a2.getParent().getName() == "a1" ); TESTING_ASSERT( a0a1a2.getParent().getFullName() == "/a0/a1" ); TESTING_ASSERT( !a0a1a2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( a0a1a2.getParent().getParent().getName() == "a0" ); TESTING_ASSERT( a0a1a2.getParent().getParent().getFullName() == "/a0" ); IObject a0a1b2( a0a1.getChild(1) ); TESTING_ASSERT( a0a1b2.isInstanceDescendant() ); TESTING_ASSERT( a0a1b2.getName() == "b2" ); TESTING_ASSERT( a0a1b2.getFullName() == "/a0/a1/b2" ); TESTING_ASSERT( !a0a1b2.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0a1b2.getParent().getName() == "a1" ); TESTING_ASSERT( a0a1b2.getParent().getFullName() == "/a0/a1" ); TESTING_ASSERT( !a0a1b2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( a0a1b2.getParent().getParent().getName() == "a0" ); TESTING_ASSERT( a0a1b2.getParent().getParent().getFullName() == "/a0" ); IObject a0b1a2( a0b1.getChild(0) ); TESTING_ASSERT( a0b1a2.isInstanceDescendant() ); TESTING_ASSERT( a0b1a2.getName() == "a2" ); TESTING_ASSERT( a0b1a2.getFullName() == "/a0/b1/a2" ); TESTING_ASSERT( a0b1a2.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0b1a2.getParent().getName() == "b1" ); TESTING_ASSERT( a0b1a2.getParent().getFullName() == "/a0/b1" ); TESTING_ASSERT( !a0b1a2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( a0b1a2.getParent().getParent().getName() == "a0" ); TESTING_ASSERT( a0b1a2.getParent().getParent().getFullName() == "/a0" ); IObject a0b1b2( a0b1.getChild(1) ); TESTING_ASSERT( a0b1b2.isInstanceDescendant() ); TESTING_ASSERT( a0b1b2.getName() == "b2" ); TESTING_ASSERT( a0b1b2.getFullName() == "/a0/b1/b2" ); TESTING_ASSERT( a0b1b2.getParent().isInstanceDescendant() ); TESTING_ASSERT( a0b1b2.getParent().getName() == "b1" ); TESTING_ASSERT( a0b1b2.getParent().getFullName() == "/a0/b1" ); TESTING_ASSERT( !a0b1b2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( a0b1b2.getParent().getParent().getName() == "a0" ); TESTING_ASSERT( a0b1b2.getParent().getParent().getFullName() == "/a0" ); IObject b0a1a2( b0a1.getChild(0) ); TESTING_ASSERT( b0a1a2.isInstanceDescendant() ); TESTING_ASSERT( b0a1a2.getName() == "a2" ); TESTING_ASSERT( b0a1a2.getFullName() == "/b0/a1/a2" ); TESTING_ASSERT( b0a1a2.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0a1a2.getParent().getName() == "a1" ); TESTING_ASSERT( b0a1a2.getParent().getFullName() == "/b0/a1" ); TESTING_ASSERT( b0a1a2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( b0a1a2.getParent().getParent().getName() == "b0" ); TESTING_ASSERT( b0a1a2.getParent().getParent().getFullName() == "/b0" ); IObject b0a1b2( b0a1.getChild(1) ); TESTING_ASSERT( b0a1b2.isInstanceDescendant() ); TESTING_ASSERT( b0a1b2.getName() == "b2" ); TESTING_ASSERT( b0a1b2.getFullName() == "/b0/a1/b2" ); TESTING_ASSERT( b0a1b2.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0a1b2.getParent().getName() == "a1" ); TESTING_ASSERT( b0a1b2.getParent().getFullName() == "/b0/a1" ); TESTING_ASSERT( b0a1b2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( b0a1b2.getParent().getParent().getName() == "b0" ); TESTING_ASSERT( b0a1b2.getParent().getParent().getFullName() == "/b0" ); IObject b0b1a2( b0b1.getChild(0) ); TESTING_ASSERT( b0b1a2.isInstanceDescendant() ); TESTING_ASSERT( b0b1a2.getName() == "a2" ); TESTING_ASSERT( b0b1a2.getFullName() == "/b0/b1/a2" ); TESTING_ASSERT( b0b1a2.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0b1a2.getParent().getName() == "b1" ); TESTING_ASSERT( b0b1a2.getParent().getFullName() == "/b0/b1" ); TESTING_ASSERT( b0b1a2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( b0b1a2.getParent().getParent().getName() == "b0" ); TESTING_ASSERT( b0b1a2.getParent().getParent().getFullName() == "/b0" ); IObject b0b1b2( b0b1.getChild(1) ); TESTING_ASSERT( b0b1b2.isInstanceDescendant() ); TESTING_ASSERT( b0b1b2.getName() == "b2" ); TESTING_ASSERT( b0b1b2.getFullName() == "/b0/b1/b2" ); TESTING_ASSERT( b0b1b2.getParent().isInstanceDescendant() ); TESTING_ASSERT( b0b1b2.getParent().getName() == "b1" ); TESTING_ASSERT( b0b1b2.getParent().getFullName() == "/b0/b1" ); TESTING_ASSERT( b0b1b2.getParent().getParent().isInstanceDescendant() ); TESTING_ASSERT( b0b1b2.getParent().getParent().getName() == "b0" ); TESTING_ASSERT( b0b1b2.getParent().getParent().getFullName() == "/b0" ); } }
void readProperty(const std::string &archiveName) { // Open an existing archive for reading. Indicate that we want // Alembic to throw exceptions on errors. std::cout << "Reading " << archiveName << std::endl; IArchive archive( Alembic::AbcCoreHDF5::ReadArchive(), archiveName, ErrorHandler::kThrowPolicy ); IObject archiveTop = archive.getTop(); // Determine the number of (top level) children the archive has const unsigned int numChildren = archiveTop.getNumChildren(); ABCA_ASSERT( numChildren == 1, "Wrong number of children (expected 3)"); std::cout << "The archive has " << numChildren << " children:" << std::endl; // Iterate through them, print out their names IObject child( archiveTop, archiveTop.getChildHeader(0).getName() ); std::cout << " " << child.getName(); // Properties ICompoundProperty props = child.getProperties(); size_t numProperties = props.getNumProperties(); // only top-level props ABCA_ASSERT( numProperties == 1, "Expected 1 property, found " << numProperties); std::cout << " has a simple property"; std::vector<std::string> propNames(1); propNames[0] = props.getPropertyHeader(0).getName(); std::cout << " named " << propNames[0] << std::endl; PropertyType pType = props.getPropertyHeader(0).getPropertyType(); ABCA_ASSERT( pType == kScalarProperty, "Expected a scalar property, but didn't find one" ); DataType dType = props.getPropertyHeader(0).getDataType(); ABCA_ASSERT( dType.getPod() == kFloat64POD, "Expected a double (kFloat64POD) property, but didn't" " find one" ); // We know this is a scalar property (I'm eliding the if/else // statements required to recognize this) IDoubleProperty mass( props, propNames[0] ); size_t numSamples = mass.getNumSamples(); std::cout << ".. it has " << numSamples << " samples" << std::endl; ABCA_ASSERT( numSamples == 5, "Expected 5 samples, found " << numSamples ); std::cout << "..with values: "; for (int ss=0; ss<numSamples; ss++) { ISampleSelector iss( (index_t) ss); printSampleValue( mass, iss ); double massDiff = mass.getValue( iss ) - (33.0 + 0.1*ss); ABCA_ASSERT( fabs(massDiff) < 1e-12, "Incorrect sample value read" ); } std::cout << std::endl; // Done - the archive closes itself }
void readUInt32ArrayProperty(const std::string &archiveName) { // Open an existing archive for reading. Indicate that we want // Alembic to throw exceptions on errors. std::cout << "Reading " << archiveName << std::endl; IArchive archive( Alembic::AbcCoreHDF5::ReadArchive(), archiveName, ErrorHandler::kThrowPolicy ); IObject archiveTop = archive.getTop(); // Determine the number of (top level) children the archive has const unsigned int numChildren = archiveTop.getNumChildren(); ABCA_ASSERT( numChildren == 1, "Wrong number of children (expected 1)"); std::cout << "The archive has " << numChildren << " children:" << std::endl; // Iterate through them, print out their names IObject child( archiveTop, archiveTop.getChildHeader(0).getName() ); std::cout << " named '" << child.getName() << "'"; // Properties ICompoundProperty props = child.getProperties(); size_t numProperties = props.getNumProperties(); // only top-level props ABCA_ASSERT( numProperties == 1, "Expected 1 property, found " << numProperties); std::cout << " with one property"; std::vector<std::string> propNames(1); propNames[0] = props.getPropertyHeader(0).getName(); std::cout << " named '" << propNames[0] << "'" << std::endl; PropertyType pType = props.getPropertyHeader(0).getPropertyType(); ABCA_ASSERT( pType == kArrayProperty, "Expected an array property, but didn't find one" ); std::cout << " which is an array property"; DataType dType = props.getPropertyHeader(0).getDataType(); ABCA_ASSERT( dType.getPod() == kUint32POD, "Expected an unsigned int (kUint32POD) property, but didn't" " find one" ); // We know this is an array property (I'm eliding the if/else // statements required to recognize and handle this properly) IUInt32ArrayProperty primes( props, propNames[0] ); size_t numSamples = primes.getNumSamples(); std::cout << ".. it has " << numSamples << " samples" << std::endl; ABCA_ASSERT( numSamples == 5, "Expected 5 samples, found " << numSamples ); const TimeSampling ts = primes.getTimeSampling(); std::cout << "..with time/value pairs: " << std::endl;; for (int ss=0; ss<numSamples; ss++) { std::cout << " "; ISampleSelector iss( (index_t) ss); std::cout << ts.getSampleTime( (index_t) ss ) << " / "; UInt32ArraySamplePtr samplePtr; primes.get( samplePtr, iss ); std::cout << "[ "; size_t numPoints = samplePtr->size(); for ( size_t jj=0 ; jj<numPoints ; jj++ ) std::cout << (*samplePtr)[jj] << " "; std::cout << "]" << std::endl; // ASSERT that we are reading the correct values for ( size_t jj=0 ; jj<numPoints ; jj++ ) ABCA_ASSERT( (*samplePtr)[jj] == g_primes[jj], "Incorrect value read from archive." ); } std::cout << std::endl; // Done - the archive closes itself }
void ofLive::setup() { rCPP.Initialise(&rLOG, NULL); # ifdef TARGET_LINUX # ifdef NDEBUG rCPP.AddLibraryDir("../of/lib-linux/release-x86-64"); # else rCPP.AddLibraryDir("../of/lib-linux/debug-x86-64"); # endif # endif # ifdef TARGET_LINUX rCPP.AddIncludeDir("/usr/include/AL"); rCPP.AddIncludeDir("/usr/include/cairo"); rCPP.AddIncludeDir("/usr/include/gtk-3.0"); rCPP.AddIncludeDir("/usr/include/atk-1.0"); rCPP.AddIncludeDir("/usr/include/glib-2.0"); rCPP.AddIncludeDir("/usr/lib/glib-2.0/include/"); rCPP.AddIncludeDir("/usr/include/harfbuzz"); rCPP.AddIncludeDir("/usr/include/pixman-1"); rCPP.AddIncludeDir("/usr/include/libpng12"); rCPP.AddIncludeDir("/usr/include/pango-1.0"); rCPP.AddIncludeDir("/usr/include/freetype2"); rCPP.AddIncludeDir("/usr/include/gio-unix-2.0"); rCPP.AddIncludeDir("/usr/include/gstreamer-1.0"); rCPP.AddIncludeDir("/usr/lib/gstreamer-1.0/include"); rCPP.AddIncludeDir("/usr/lib/gstreamer-1.0/include/gst"); rCPP.AddIncludeDir("/usr/include/gdk-pixbuf-2.0"); rCPP.AddIncludeDir("/usr/include/at-spi2-atk/2.0"); rCPP.AddIncludeDir("/usr/lib/x86_64-linux-gnu/glib-2.0/include"); # endif rCPP.AddIncludeDir("../of/src/freeimage"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR/Half"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR/Iex"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR/IlmImf"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR/IlmThread"); rCPP.AddIncludeDir("../of/src/freeimage/OpenEXR/Imath"); rCPP.AddIncludeDir("../of/src/rtaudio"); rCPP.AddIncludeDir("../of/src/rtaudio/include"); rCPP.AddIncludeDir("../of/src/utf8cpp"); rCPP.AddIncludeDir("../of/src/utf8cpp/include"); rCPP.AddIncludeDir("../of/src/utf8cpp/include/utf8"); rCPP.AddIncludeDir("../of/src/glew"); rCPP.AddIncludeDir("../of/src/glew/include"); rCPP.AddIncludeDir("../of/src/glfw"); rCPP.AddIncludeDir("../of/src/glfw/include"); rCPP.AddIncludeDir("../of/src/glfw/include/GLFW"); rCPP.AddIncludeDir("../of/src/kissfft"); rCPP.AddIncludeDir("../of/src/kissfft/tools"); rCPP.AddIncludeDir("../of/src/poco"); rCPP.AddIncludeDir("../of/src/poco/Crypto/include"); rCPP.AddIncludeDir("../of/src/poco/Foundation/include"); rCPP.AddIncludeDir("../of/src/poco/Net/include"); rCPP.AddIncludeDir("../of/src/poco/NetSSL_OpenSSL/include"); rCPP.AddIncludeDir("../of/src/poco/Util/include"); rCPP.AddIncludeDir("../of/src/poco/XML/include"); rCPP.AddIncludeDir("../of/src/poco/Zip/include"); rCPP.AddIncludeDir("../of/src/rtaudio"); rCPP.AddIncludeDir("../of/src/rtaudio/include"); rCPP.AddIncludeDir("../of/src/libtess2"); rCPP.AddIncludeDir("../of/src/libtess2/Include"); rCPP.AddIncludeDir("../of/src/libtess2/Sources"); rCPP.AddIncludeDir("../of/src/openframeworks"); rCPP.AddIncludeDir("of/src/openframeworks"); rCPP.AddIncludeDir("../of/src/openframeworks/3d"); rCPP.AddIncludeDir("../of/src/openframeworks/app"); rCPP.AddIncludeDir("../of/src/openframeworks/communication"); rCPP.AddIncludeDir("../of/src/openframeworks/events"); rCPP.AddIncludeDir("../of/src/openframeworks/gl"); rCPP.AddIncludeDir("../of/src/openframeworks/graphics"); rCPP.AddIncludeDir("../of/src/openframeworks/math"); rCPP.AddIncludeDir("../of/src/openframeworks/sound"); rCPP.AddIncludeDir("../of/src/openframeworks/types"); rCPP.AddIncludeDir("../of/src/openframeworks/utils"); rCPP.AddIncludeDir("../of/src/openframeworks/video"); rCPP.AddIncludeDir("RuntimeCompiledCPlusPlus/Aurora"); rCPP.AddIncludeDir("addons/ofxImGui/src"); rCPP.AddIncludeDir("addons/ofxImGui/libs/imgui/src"); rCPP.AddIncludeDir("../of/addons/ofxAssimpModelLoader/src"); rCPP.AddIncludeDir("../of/addons/ofxAssimpModelLoader/libs/assimp/include/"); rCPP.AddIncludeDir("./"); { ofDirectory dir(ofFilePath::getCurrentExeDir() + ".."); dir.listDir(); vector<ofFile> files = dir.getFiles(); for (ofFile& file : files) { if (file.isDirectory() && file.getBaseName().substr(0,3) == "ofx") { rCPP.AddIncludeDir(&(file.path())[0]); rCPP.AddIncludeDir(&(file.path() + "/src")[0]); } } } rCPP.GetObjectFactorySystem()->AddListener(this); { IObject* rObject = rCPP.GetObjectFactorySystem()->GetConstructor("ofApp")->Construct(); rObject->GetInterface(&rAPP); rOID = rObject->GetObjectId(); } rAPP->setup(); }
void accumXform( Imath::M44d &xf, IObject obj, chrono_t curTime, bool interpolate) { if ( IXform::matches( obj.getHeader() ) ) { Imath::M44d mtx; IXform x( obj, kWrapExisting ); XformSample xs; x.getSchema().get( xs ); if (!x.getSchema().isConstant()) { TimeSamplingPtr timeSampler = x.getSchema().getTimeSampling(); if (interpolate) { //std::pair<index_t, chrono_t> lSamp;// = timeSampler->getFloorIndex(curTime, x.getSchema().getNumSamples()); Alembic::AbcCoreAbstract::index_t floorIdx, ceilIdx; double amt = getWeightAndIndex(curTime, timeSampler, x.getSchema().getNumSamples(), floorIdx, ceilIdx); if (amt != 0 && floorIdx != ceilIdx) { const ISampleSelector iss_start(floorIdx);//lSamp.first); Imath::M44d mtx_start = x.getSchema().getValue(iss_start).getMatrix(); //std::pair<index_t, chrono_t> rSamp = timeSampler->getCeilIndex(curTime, x.getSchema().getNumSamples()); const ISampleSelector iss_end(ceilIdx);//rSamp.first); Imath::M44d mtx_end = x.getSchema().getValue(iss_end).getMatrix(); Imath::V3d s_l,s_r,h_l,h_r,t_l,t_r; Imath::Quatd quat_l,quat_r; DecomposeXForm(mtx_start, s_l, h_l, quat_l, t_l); DecomposeXForm(mtx_end, s_r, h_r, quat_r, t_r); if ((quat_l ^ quat_r) < 0) { quat_r = -quat_r; } mtx = RecomposeXForm(Imath::lerp(s_l, s_r, amt), Imath::lerp(h_l, h_r, amt), Imath::slerp(quat_l, quat_r, amt), Imath::lerp(t_l, t_r, amt)); } else { const ISampleSelector iss(curTime); xs = x.getSchema().getValue(iss); mtx = xs.getMatrix(); } } else { // no interpolation, get nearest sample const ISampleSelector iss(curTime); xs = x.getSchema().getValue(iss); mtx = xs.getMatrix(); } } else { mtx = xs.getMatrix(); } xf *= mtx; } }
void errorHandlerTest(bool useOgawa) { { OArchive archive; if (useOgawa) { archive = OArchive( Alembic::AbcCoreOgawa::WriteArchive(), "throwTest.abc", ErrorHandler::kThrowPolicy ); } else { archive = OArchive( Alembic::AbcCoreHDF5::WriteArchive(), "throwTest.abc", ErrorHandler::kThrowPolicy ); } OObject archiveTop = archive.getTop(); ABCA_ASSERT( archiveTop.getErrorHandler().getPolicy() == ErrorHandler::kThrowPolicy, "Error: Not kThrowPolicy" ); OObject childQuiet(archiveTop, "childQuiet", ErrorHandler::kQuietNoopPolicy ); OObject childNoisy(archiveTop, "childNoisy", ErrorHandler::kNoisyNoopPolicy ); OObject grandchildQuiet(childQuiet, "grandchildQuiet" ); OObject grandchildNoisy(childNoisy, "grandchildNoisy" ); ABCA_ASSERT( childQuiet.getErrorHandler().getPolicy() == ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" ); ABCA_ASSERT( childNoisy.getErrorHandler().getPolicy() == ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" ); ABCA_ASSERT( grandchildQuiet.getErrorHandler().getPolicy() == ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" ); ABCA_ASSERT( grandchildNoisy.getErrorHandler().getPolicy() == ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" ); } { AbcF::IFactory factory; factory.setPolicy( ErrorHandler::kThrowPolicy ); AbcF::IFactory::CoreType coreType; IArchive archive = factory.getArchive("throwTest.abc", coreType); IObject archiveTop = archive.getTop(); ABCA_ASSERT( archiveTop.getErrorHandler().getPolicy() == ErrorHandler::kThrowPolicy, "Error: Not kThrowPolicy" ); IObject childQuiet(archiveTop, "childQuiet", ErrorHandler::kQuietNoopPolicy ); IObject childNoisy(archiveTop, "childNoisy", ErrorHandler::kNoisyNoopPolicy ); IObject grandchildQuiet(childQuiet, "grandchildQuiet" ); IObject grandchildNoisy(childNoisy, "grandchildNoisy" ); ABCA_ASSERT( childQuiet.getErrorHandler().getPolicy() == ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" ); ABCA_ASSERT( childNoisy.getErrorHandler().getPolicy() == ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" ); ABCA_ASSERT( grandchildQuiet.getErrorHandler().getPolicy() == ErrorHandler::kQuietNoopPolicy, "Error: Not kQuietNoopPolicy" ); ABCA_ASSERT( grandchildNoisy.getErrorHandler().getPolicy() == ErrorHandler::kNoisyNoopPolicy, "Error: Not kNoisyNoopPolicy" ); } }
bool avm_elem::Equals(const IObject &value) const { return(this->ToString() == value.ToString()); }
/** * Return a random point in a generic shape. * @param object an IObject within which the point is generated * @param rng a random number generator * @param maxAttempts maximum number of random numbers to use before giving up * @return a point */ boost::optional<Kernel::V3D> inGenericShape(const IObject &object, Kernel::PseudoRandomNumberGenerator &rng, size_t maxAttempts) { return bounded(object, rng, object.getBoundingBox(), maxAttempts); }
void readSimpleProperties(const std::string &archiveName) { // Open an existing archive for reading. Indicate that we want // Alembic to throw exceptions on errors. AbcF::IFactory factory; factory.setPolicy( ErrorHandler::kThrowPolicy ); AbcF::IFactory::CoreType coreType; IArchive archive = factory.getArchive(archiveName, coreType); IObject archiveTop = archive.getTop(); // Determine the number of (top level) children the archive has const int numChildren = archiveTop.getNumChildren(); TESTING_ASSERT( numChildren == 4 ); std::cout << "The archive has " << numChildren << " children:" << std::endl; // Iterate through them, print out their names for (int ii=0; ii<numChildren; ii++) { IObject child( archiveTop, archiveTop.getChildHeader( ii ).getName() ); std::cout << " " << child.getName(); std::cout << " has " << child.getNumChildren() << " children" << std::endl; // Properties ICompoundProperty props = child.getProperties(); int numProperties = props.getNumProperties(); std::cout << " ..and " << numProperties << " simple properties" << std::endl; std::vector<std::string> propNames; for (int pp=0; pp<numProperties; pp++) propNames.push_back( props.getPropertyHeader(pp).getName() ); for (int jj=0; jj<numProperties; jj++) { std::cout << " ..named " << propNames[jj] << std::endl; std::cout << " ..with type: "; PropertyType pType = props.getPropertyHeader(jj).getPropertyType(); if (pType == kCompoundProperty) { std::cout << "compound" << std::endl; } else if (pType == kScalarProperty) { std::cout << "scalar" << std::endl; } else if (pType == kArrayProperty) { std::cout << "array" << std::endl; } DataType dType = props.getPropertyHeader(jj).getDataType(); std::cout << " ..with POD-type: "; switch (dType.getPod()) { case kBooleanPOD: std::cout << "boolean" << std::endl; break; // Char/UChar case kUint8POD: std::cout << "unsigned char" << std::endl; break; case kInt8POD: std::cout << "char" << std::endl; break; // Short/UShort case kUint16POD: std::cout << "short unsigned int" << std::endl; break; case kInt16POD: std::cout << "short int" << std::endl; break; // Int/UInt case kUint32POD: std::cout << "unsigned int" << std::endl; break; case kInt32POD: std::cout << "int" << std::endl; break; // Long/ULong case kUint64POD: std::cout << "unsigned long int" << std::endl; break; case kInt64POD: std::cout << "long int" << std::endl; break; // Half/Float/Double case kFloat16POD: std::cout << "half" << std::endl; break; case kFloat32POD: std::cout << "float" << std::endl; break; case kFloat64POD: std::cout << "double" << std::endl; break; case kStringPOD: std::cout << "string" << std::endl; break; case kUnknownPOD: default: std::cout << " Unknown! (this is bad)" << std::endl; }; TimeSamplingPtr ts = GetCompoundPropertyReaderPtr(props)-> getScalarProperty( propNames[jj] )->getTimeSampling(); int numSamples = ts->getNumStoredTimes(); std::cout << " ..and " << ts->getTimeSamplingType() << std::endl << " ..and " << numSamples << " samples at times: "; if (numSamples > 0) { std::cout << " ( "; for (int ss=0; ss<numSamples; ss++) std::cout << ts->getSampleTime(ss) << " "; std::cout << ")"; } std::cout << std::endl; std::cout << " ..and values: "; if (numSamples > 0) { for (int ss=0; ss<numSamples; ss++) { ISampleSelector iss( (index_t) ss); switch (dType.getPod()) { // Boolean case kBooleanPOD: { IBoolProperty prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } // Char/UChar case kUint8POD: { IUcharProperty prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kInt8POD: { ICharProperty prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } // Short/UShort case kUint16POD: { IUInt16Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kInt16POD: { IInt16Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } // Int/UInt case kUint32POD: { IUInt32Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kInt32POD: { IInt32Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } // Long/ULong case kUint64POD: { IUInt64Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kInt64POD: { IInt64Property prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } // Half/Float/Double case kFloat16POD: // iostream doesn't understand float_16's //printSampleValue( IHalfProperty( props, propNames[jj] ), // iss ); break; case kFloat32POD: { IFloatProperty prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kFloat64POD: { IDoubleProperty prop( props, propNames[jj] ); printSampleValue( prop, iss ); break; } case kUnknownPOD: default: std::cout << " Unknown! (this is bad)" << std::endl; }; } } std::cout << std::endl; std::cout << std::endl; // done parsing property } } // Done - the archive closes itself }
void readWriteColorArrayProperty(const std::string &archiveName) { { OArchive archive( Alembic::AbcCoreHDF5::WriteArchive(), archiveName, ErrorHandler::kThrowPolicy ); OObject archiveTop = archive.getTop(); OObject child( archiveTop, "test" ); OCompoundProperty childProps = child.getProperties(); OC3fArrayProperty shades( childProps, "shades", TimeSamplingType( 1.0 ) ); std::vector < C3f > grays(8); grays[0].x = 0.0; grays[0].y = 0.0; grays[0].z = 0.0; grays[1].x = 0.125; grays[1].y = 0.125; grays[1].z = 0.125; grays[2].x = 0.25; grays[2].y = 0.25; grays[2].z = 0.25; grays[3].x = 0.375; grays[3].y = 0.375; grays[3].z = 0.375; grays[4].x = 0.5; grays[4].y = 0.5; grays[4].z = 0.5; grays[5].x = 0.625; grays[5].y = 0.625; grays[5].z = 0.625; grays[6].x = 0.75; grays[6].y = 0.75; grays[6].z = 0.75; grays[7].x = 0.875; grays[7].y = 0.875; grays[7].z = 0.875; // let's write 4 different color3f[2] Dimensions d; d.setRank(2); d[0] = 2; d[1] = 4; C3fArraySample cas(&(grays.front()), d); shades.set(cas); } { // now read it IArchive archive( Alembic::AbcCoreHDF5::ReadArchive(), archiveName, ErrorHandler::kThrowPolicy ); IObject archiveTop = archive.getTop(); const unsigned int numChildren = archiveTop.getNumChildren(); IObject child( archiveTop, archiveTop.getChildHeader(0).getName() ); ICompoundProperty props = child.getProperties(); IC3fArrayProperty shades( props, "shades" ); C3fArraySamplePtr samplePtr; shades.get( samplePtr ); ABCA_ASSERT( samplePtr->getDimensions().rank() == 2, "Incorrect rank on the sample." ); ABCA_ASSERT( samplePtr->getDimensions().numPoints() == 8, "Incorrect number of total points." ); ABCA_ASSERT( samplePtr->getDimensions()[0] == 2, "Incorrect size on dimension 0." ); ABCA_ASSERT( samplePtr->getDimensions()[1] == 4, "Incorrect size on dimension 1." ); for (size_t i = 0; i < 8; ++i) { ABCA_ASSERT( (*samplePtr)[i].x == i/8.0 && (*samplePtr)[i].x == (*samplePtr)[i].y && (*samplePtr)[i].x == (*samplePtr)[i].z, "Color [" << i << "] is incorrect."); } } }