void AssetDownloadTask::assetFileDownloaded(ResourceDownloadTaskPtr taskptr, Transfer::ChunkRequestPtr request, Transfer::DenseDataPtr response) { boost::mutex::scoped_lock lok(mDependentDownloadMutex); // Clear from the active download list assert(mActiveDownloads.size() == 1); mActiveDownloads.erase(taskptr->getIdentifier()); mFinishedDownloads.push_back(taskptr->getIdentifier()); // Lack of response data means failure of some sort if (!response) { SILOG(ogre, warn, "Failed to download resource for " << taskptr->getIdentifier()); failDownload(); return; } // FIXME here we could have another callback which lets them get // at the hash to try to use an existing copy. Even with the // eventual centralized loading we want, this may still be // beneficial since Ogre may have a copy even if we don't have a // copy of the raw data any more. mParseMeshHandle = mScene->parseMesh( request->getMetadata(), request->getMetadata().getFingerprint(), response, mIsAggregate, std::tr1::bind(&AssetDownloadTask::weakHandleAssetParsed, getWeakPtr(), _1) ); }
void AssetDownloadTask::addDependentDownload(const Transfer::URI& depUrl, const Transfer::Chunk& depChunk) { ResourceDownloadTaskPtr dl = ResourceDownloadTask::construct( depChunk, mScene->transferPool(), mPriority, std::tr1::bind(&AssetDownloadTask::weakTextureDownloaded, getWeakPtr(), depUrl, _1, _2, _3) ); addDependentDownload(dl); }
void AssetDownloadTask::downloadAssetFile() { assert( !mAssetURI.empty() ); ResourceDownloadTaskPtr dl = ResourceDownloadTask::construct( mAssetURI, mScene->transferPool(), mPriority, std::tr1::bind(&AssetDownloadTask::weakAssetFileDownloaded, getWeakPtr(), _1, _2) ); mActiveDownloads[mAssetURI] = dl; dl->start(); }
void AssetDownloadTask::handleAssetParsed(Mesh::MeshdataPtr md) { mAsset = md; if (!md) { SILOG(ogre,error,"Failed to parse mesh " << mAssetURI.toString()); mCB(); return; } // This is a sanity check. There's no way Ogre can reasonably handle meshes // that require a ton of draw calls. Estimate them here and if its too high, // destroy the data and invoke the callback to make it look like failure. { // Draw calls = // Number of instances * number of primitives in instance uint32 draw_calls = 0; Meshdata::GeometryInstanceIterator geoinst_it = md->getGeometryInstanceIterator(); uint32 geoinst_idx; Matrix4x4f pos_xform; while( geoinst_it.next(&geoinst_idx, &pos_xform) ) draw_calls += md->geometry[ md->instances[geoinst_idx].geometryIndex ].primitives.size(); // Arbitrary number, but probably more than we should even allow given // that there are probably hundreds or thousands of other objects if (draw_calls > 500) { SILOG(ogre,error,"Excessively complicated mesh: " << mAssetURI.toString() << " has " << draw_calls << " draw calls. Ignoring this mesh."); mAsset = Mesh::MeshdataPtr(); mCB(); return; } } mRemainingDownloads = md->textures.size(); // Special case for no dependent downloads if (mRemainingDownloads == 0) { mCB(); return; } String assetURIString = mAssetURI.toString(); for(TextureList::const_iterator it = md->textures.begin(); it != md->textures.end(); it++) { String texURIString = assetURIString.substr(0, assetURIString.rfind("/")+1) + (*it); Transfer::URI texURI(texURIString); ResourceDownloadTaskPtr dl = ResourceDownloadTask::construct( texURI, mScene->transferPool(), mPriority, std::tr1::bind(&AssetDownloadTask::weakTextureDownloaded, getWeakPtr(), _1, _2) ); mActiveDownloads[texURI] = dl; dl->start(); } }
void AssetDownloadTask::downloadAssetFile() { assert( !mAssetURI.empty() ); boost::mutex::scoped_lock lok(mDependentDownloadMutex); ResourceDownloadTaskPtr dl = ResourceDownloadTask::construct( mAssetURI, mScene->transferPool(), mPriority, std::tr1::bind(&AssetDownloadTask::weakAssetFileDownloaded, getWeakPtr(), _1, _2, _3) ); mActiveDownloads[dl->getIdentifier()] = dl; dl->start(); }
bool HostedObject::objectHostConnect(const SpaceID spaceID, const Location startingLocation, const BoundingSphere3f meshBounds, const String mesh, const String physics, const String query, const String zernike, const ObjectReference orefID, PresenceToken token) { ObjectReference oref = (orefID == ObjectReference::null()) ? ObjectReference(UUID::random()) : orefID; SpaceObjectReference connectingSporef (spaceID,oref); // Note: we always use Time::null() here. The server will fill in the // appropriate value. When we get the callback, we can fix this up. Time approx_server_time = Time::null(); if (mObjectHost->connect( getSharedPtr(), connectingSporef, spaceID, TimedMotionVector3f(approx_server_time, MotionVector3f( Vector3f(startingLocation.getPosition()), startingLocation.getVelocity()) ), TimedMotionQuaternion(approx_server_time,MotionQuaternion(startingLocation.getOrientation().normal(),Quaternion(startingLocation.getAxisOfRotation(),startingLocation.getAngularSpeed()))), //normalize orientations meshBounds, mesh, physics, query, zernike, std::tr1::bind(&HostedObject::handleConnected, getWeakPtr(), mObjectHost, _1, _2, _3), std::tr1::bind(&HostedObject::handleMigrated, getWeakPtr(), _1, _2, _3), std::tr1::bind(&HostedObject::handleStreamCreated, getWeakPtr(), _1, _2, token), std::tr1::bind(&HostedObject::handleDisconnected, getWeakPtr(), _1, _2) )) { mObjectHost->registerHostedObject(connectingSporef,getSharedPtr()); return true; }else { return false; } }
void AssetDownloadTask::assetFileDownloaded(std::tr1::shared_ptr<ChunkRequest> request, std::tr1::shared_ptr<const DenseData> response) { // Clear from the active download list assert(mActiveDownloads.size() == 1); mActiveDownloads.erase(mAssetURI); // Lack of response data means failure of some sort if (!response) { failDownload(); return; } // FIXME here we could have another callback which lets them get // at the hash to try to use an existing copy. Even with the // eventual centralized loading we want, this may still be // beneficial since Ogre may have a copy even if we don't have a // copy of the raw data any more. mScene->parseMesh( mAssetURI, request->getMetadata().getFingerprint(), response, std::tr1::bind(&AssetDownloadTask::weakHandleAssetParsed, getWeakPtr(), _1) ); }
ResourceDependencyTask* GraphicsResourceShader::createDependencyTask(DependencyManager *manager) { return new ShaderDependencyTask(manager, getWeakPtr(), mResourceID.toString()); }
ResourceUnloadTask* GraphicsResourceShader::createUnloadTask(DependencyManager *manager) { return new ShaderUnloadTask(manager, getWeakPtr(), mResourceID.toString(), mArchiveName, mLoadEpoch); }
std::tr1::shared_ptr<T> getSharedPtr() const { std::tr1::shared_ptr<T> retval(getWeakPtr()); return retval; }
ResourceUnloadTask* GraphicsResourceMesh::createUnloadTask(DependencyManager *manager) { return new MeshUnloadTask(manager, getWeakPtr(), mResourceID.toString(), mLoadEpoch); }
void addDependency(SharedResourcePtr newResource) { assert(newResource); mDependencies.insert(newResource); newResource->addDependent(getWeakPtr()); }