void ShaderUnloadTask::doRun()
{
  CDNArchive::clearArchive(mArchiveName);

  SharedResourcePtr resource = mResource.lock();
  if (resource) {
    resource->unloaded(true, mEpoch);
  }
}
void ShaderDependencyTask::operator()()
{
  SharedResourcePtr resourcePtr = mResource.lock();
  if (!resourcePtr) {
    finish(false);
    return;
  }

  resourcePtr->parsed(true);

  finish(true);
}
void ShaderDependencyTask::run()
{
  SharedResourcePtr resourcePtr = mResource.lock();
  if (!resourcePtr) {
    signalCompletion(false);
    return;
  }

  resourcePtr->parsed(true);

  signalCompletion();
}
SharedResourcePtr GraphicsResourceManager::getResourceAsset(const URI &id, GraphicsResource::Type resourceType)
{
  WeakResourcePtr curWeakPtr;
  SharedResourcePtr curSharedPtr;
  if (ResourceManager::getSingleton().isMHashScheme(id)) {
    try {
      curWeakPtr = getResource(RemoteFileId(id).fingerprint().convertToHexString());
      curSharedPtr = curWeakPtr.lock();
    } catch (std::invalid_argument &ia) {
    }
  }
  if (!curSharedPtr) {
    curWeakPtr = getResource(id.toString());
    curSharedPtr = curWeakPtr.lock();
  }
  if (curSharedPtr)
    return curSharedPtr;
  else {
    try {
      if (ResourceManager::getSingleton().isMHashScheme(id)) {
        // std::invalid_argument may be thrown, but is caught by the "catch" below.
        RemoteFileId resourceId(id);
        if (resourceType == GraphicsResource::MESH) {
          curSharedPtr = GraphicsResource::construct<GraphicsResourceMesh>(resourceId);
        }
        else if (resourceType == GraphicsResource::MATERIAL) {
          curSharedPtr = GraphicsResource::construct<GraphicsResourceMaterial>(resourceId);
        }
        else if (resourceType == GraphicsResource::TEXTURE) {
          curSharedPtr = GraphicsResource::construct<GraphicsResourceTexture>(resourceId);
        }
        else if (resourceType == GraphicsResource::SHADER) {
          curSharedPtr = GraphicsResource::construct<GraphicsResourceShader>(resourceId);
        }
        else {
          assert(false);
        }
      }
      else {
        curSharedPtr = GraphicsResource::construct<GraphicsResourceName>(id, resourceType);
      }

      mIDResourceMap[curSharedPtr->getID()] = curSharedPtr;
      mResources.insert(curSharedPtr.get());
    }
    catch (std::invalid_argument& exc) {

    }

    return curSharedPtr;
  }
}
Esempio n. 5
0
SharedResourcePtr receiveResource ( SimpleTcpEndPoint client )
{
    unsigned long long index = 0;
    ByteBuffer message;
    client.receive ( message );
    received += message.getLength();
    SharedResourcePtr result = ResourceHolder::FromBuffer(message,index);
    recvResources[result->getUUID()] = result;
    ResourceHolder::RegisterResource(result);
    if ( recvCB.find ( result->mTypeID) != recvCB.end () ) {
        (*recvCB[result->mTypeID]) ( result );
    }
    return result;
}
SharedResourcePtr GraphicsResourceManager::getResourceEntity(const SpaceObjectReference &id, GraphicsEntity *graphicsEntity)
{
  WeakResourcePtr curWeakPtr = getResource(id.toString());
  SharedResourcePtr curSharedPtr = curWeakPtr.lock();
  if (curSharedPtr)
    return curSharedPtr;
  else {
    curSharedPtr = GraphicsResource::construct<GraphicsResourceEntity>(id, graphicsEntity);
    mIDResourceMap[id.toString()] = curSharedPtr;
    mEntities.insert(curSharedPtr.get());

    return curSharedPtr;
  }
}
/*
bool MeshUnloadTask::mainThreadUnload(String name)
{
  Ogre::MeshManager::getSingleton().unload(name);
//  operationCompleted(Ogre::BackgroundProcessTicket(), Ogre::BackgroundProcessResult());
  return false;
}
*/
void MeshUnloadTask::doRun()
{
  /*I REALLY wish this were true*/
  // SequentialWorkQueue::getSingleton().queueWork(std::tr1::bind(&MeshUnloadTask::mainThreadUnload, this, mHash));

  String hash = mHash; //CDNArchive::canonicalMhashName(mHash);
  Ogre::MeshManager* meshManager = Ogre::MeshManager::getSingletonPtr();
  meshManager->remove(hash);

  Ogre::ResourcePtr meshResource = meshManager->getByName(hash);
  assert(meshResource.isNull());

  SharedResourcePtr resource = mResource.lock();
  if (resource)
    resource->unloaded(true, mEpoch);
}
Esempio n. 8
0
void OnReceiveWorld ( SharedResourcePtr resource )
{
    std::cout << "World::" << resource->getName().toStdString() << std::endl;
    Assets::WorldPtr world = resource.dynamicCast<Assets::World> ();
    for ( int i = 0 ; i < world->getSize < QUuid > ( "Cells" ) ; i ++ ) {
        fetchResource ( world->get < QUuid > ( "Cells", i ) );
    }
}
Esempio n. 9
0
void OnReceiveWorldCell ( SharedResourcePtr resource )
{
    std::cout << "WorldCell::" << resource->getName().toStdString() << std::endl;
    Assets::WorldCellPtr cell = resource.dynamicCast<Assets::WorldCell> ();
    for ( int i = 0 ; i < cell->getSize < QUuid > ( "GameObjects" ) ; i ++ ) {
        fetchResource ( cell->get < QUuid > ( "GameObjects", i ) );
    }
}
Esempio n. 10
0
void OnReceiveMesh ( SharedResourcePtr resource )
{
    std::cout << "Mesh::" << resource->getName().toStdString() << std::endl;
    Assets::MeshPtr mesh = resource.dynamicCast<Assets::Mesh> ();
    for ( unsigned int i = 0 ; i < mesh->getSize < Assets::MaterialGroup* > ( "MaterialGroups" ) ; i ++ ) {
        Assets::MaterialGroup* grp = mesh->get < Assets::MaterialGroup* > ( "MaterialGroups", i );
        fetchResource ( grp->get < QUuid > ( "Material" ) );
    }
}
Esempio n. 11
0
void MeshDependencyTask::operator()()
{
  SharedResourcePtr resourcePtr = mResource.lock();
  if (!resourcePtr) {
    finish(false);
    return;
  }

  if (OPTION_ENABLE_TEXTURES->as<bool>()) {
    GraphicsResourceManager *grm = GraphicsResourceManager::getSingletonPtr();

    MemoryBuffer::iterator itr, iend;
    for (itr = mBuffer.begin(), iend = mBuffer.end() - 7; itr != iend; ++itr) {
      if (*itr == 'm'
       && (*(itr + 1)) == 'e'
       && (*(itr + 2)) == 'r'
       && (*(itr + 3)) == 'u'
       && (*(itr + 4)) == ':'
       && (*(itr + 5)) == '/'
       && (*(itr + 6)) == '/') {
        String matDep = "";

        while (itr != iend + 4) {
          if (*itr == '.' && (*(itr + 1) == 'o')  && (*(itr + 2) == 's')) {
            matDep += ".os";
             break;
          }
          matDep += *itr;
          ++itr;
        }

        SharedResourcePtr hashResource = grm->getResourceAsset(URI(matDep), GraphicsResource::MATERIAL);
        resourcePtr->addDependency(hashResource);
      }
    }
  }

  resourcePtr->setCost(mBuffer.size());
  resourcePtr->parsed(true);

  finish(true);
}
Esempio n. 12
0
void OnReceiveGameEntity ( SharedResourcePtr resource )
{
    std::cout << "GameEntity::" << resource->getName().toStdString() << std::endl;
    Assets::GameEntityPtr ge = resource.dynamicCast<Assets::GameEntity> ();
    for ( int i = 0 ; i < ge->getSize < Assets::GameEntityElement* > ( "Elements" ) ; i ++ ) {
        Assets::GameEntityElement* elt = ge->get < Assets::GameEntityElement* > ( "Elements", i );
        for ( int j = 0 ; j < elt->getSize < QUuid > ( "Resources" ) ; j ++ ) {
            fetchResource ( elt->get < QUuid > ( "Resources", j ) );
        }
    }
}
Esempio n. 13
0
int main(int argc, char *argv[])
{
    /*
    __attach();
    __attachInterfaces();
    __attachGenerics();
    __attachAssets();*/
    __attachQImage();
    __attachWavefront();
    FileDescriptor file ( argv[1]);
    ResourceHolder::Load(file);
    ResourceHolder::Usage();
    foreach ( QUuid id, ResourceHolder::AllKeys() ) {
        SharedResourcePtr res = ResourceHolder::GetByUUID(id);
        res->Usage();
        ByteBuffer buffer = ResourceHolder::ToBuffer( res );
        unsigned long long index = 0;
        SharedResourcePtr ptr = ResourceHolder::FromBuffer(buffer,index);
        ptr->Usage();
    }
Esempio n. 14
0
void OnReceiveWavefrontMaterial ( SharedResourcePtr resource )
{
    QUuid fake;
    std::cout << "WavefrontMaterial::" << resource->getName().toStdString() << std::endl;
    Assets::MaterialPtr material = resource.dynamicCast<WavefrontMaterial> ();
    if ( fake != material->get < Texture > ( "AmbientMap" ).imageID )
        fetchResource ( material->get < Texture > ( "AmbientMap" ).imageID );
    if ( fake != material->get < Texture > ( "DiffuseMap" ).imageID )
        fetchResource ( material->get < Texture > ( "DiffuseMap" ).imageID );
    if ( fake != material->get < Texture > ( "SpecularMap" ).imageID )
        fetchResource ( material->get < Texture > ( "SpecularMap" ).imageID );
    if ( fake != material->get < Texture > ( "SpecularExponentMap" ).imageID )
        fetchResource ( material->get < Texture > ( "SpecularExponentMap" ).imageID );
    if ( fake != material->get < Texture > ( "DissolveMap" ).imageID )
        fetchResource ( material->get < Texture > ( "DissolveMap" ).imageID );
    if ( fake != material->get < Texture > ( "DecalMap" ).imageID )
        fetchResource ( material->get < Texture > ( "DecalMap" ).imageID );
    if ( fake != material->get < Texture > ( "DisplacementMap" ).imageID )
        fetchResource ( material->get < Texture > ( "DisplacementMap" ).imageID );
    if ( fake != material->get < Texture > ( "BumpMap" ).imageID )
        fetchResource ( material->get < Texture > ( "BumpMap" ).imageID );
    if ( fake != material->get < Texture > ( "ReflectionMap" ).imageID )
        fetchResource ( material->get < Texture > ( "ReflectionMap" ).imageID );
}
Esempio n. 15
0
 void addDependency(SharedResourcePtr newResource) {
   assert(newResource);
   mDependencies.insert(newResource);
   newResource->addDependent(getWeakPtr());
 }
Esempio n. 16
0
void OnReceiveLight ( SharedResourcePtr resource )
{
    std::cout << "Light::" << resource->getName().toStdString() << std::endl;
    Assets::LightPtr light = resource.dynamicCast<Assets::Light> ();
}
Esempio n. 17
0
void OnReceiveGameObject ( SharedResourcePtr resource )
{
    std::cout << "GameObject::" << resource->getName().toStdString() << std::endl;
    Assets::GameObjectPtr go = resource.dynamicCast<Assets::GameObject> ();
    fetchResource ( go->get < QUuid > ( "Entity" ) );
}
Esempio n. 18
0
bool ServerManager::interpret(QUuid client){

    if(client == NULL){

        std::cout << "erreur : client incorrect." << std::endl;
        return false;
    }
    if(connection == 0) {
        std::cout << "Error : no socket bound" << std::endl;
        return false;
    }

    if(!connection->isStarted()){

        std::cout << "erreur : connection non démarrée." << std::endl;
        return false;
    }

    //std::cout << "Client OK" << std::endl;

    EncByteBuffer requete, reponse;
    requete.setType(-2);
    SharedResourcePtr res;
    QUuid req, q;
    EncByteBuffer resource;
    long long unsigned int l;

    while(requete.getType() == -2) {

        if(connection->isStarted()){
            //std::cout << "EncTcpStartPoint try receiving" << std::endl;
            
			if(! connection->receive(client, requete) ) {
				std::cout << "Not able to receive" <<std::endl;
				return false;
			}
            if(!connection->hasEndPoint() ){
                std::cout << "No end to receive frome" <<std::endl;
                return false;
            }
            //std::cout << "After receiving " << requete.getType() << "/" << requete.getLength() << std::endl;
        }
        else
        {
            std::cout << "Connection dropped" << std::endl;
            return false;

        }
    }
        //std::cout << "Receiving request" << std::endl;
        //std::cout << "Type " << requete.getType() << " , length " << requete.getLength() << std::endl;
        
		switch(requete.getType()){

            case ServerManager::SHARED_R :
                //std::cout << "Received Request for resource " << std::endl;
                l = requete.getLength();
                req = QUuid((const char*)(requete.getData()));
                std:: cout << "Getting " << req.toString().toStdString() << std::endl;
                res = ServerManager::getInstance()->getRessource(req);
                reponse.setType(SHARED_R);
                if(res.isNull()) {
					reponse = EncByteBuffer(ERROR);
                	reponse.append(ByteBuffer((unsigned char*)(req.toByteArray().data()), req.toByteArray().size()));
                }
				else{
                	resource = ResourceHolder::ToBuffer(res);
                	reponse.append(resource);
				}
                break;

            case ServerManager::TEST :
            	reponse.setType(TEST);
                l = requete.getLength();
                ::fromBuffer(requete, l, req);
                res = ServerManager::getInstance()->getRessource(req);

                reponse.append(ByteBuffer((unsigned char*)(q.toByteArray().data()), q.toByteArray().size()));
                break;

			case ServerManager::WORLD :
				std::cout << "Error : Unexpected type WORLD." << std::endl;
				return false;
				break;

			default :
				std::cout << "Error : Unknown type " << requete.getType() << std::endl;
				return false;
				break;
        }

		if(! connection->send(client, reponse )){
				std::cout << "Couldn't send" << std::endl;
				return false;
		}

    return true;
}
Esempio n. 19
0
void OnReceiveImage ( SharedResourcePtr resource )
{
    std::cout << "Image::" << resource->getName().toStdString() << std::endl;
    Assets::ImagePtr image = resource.dynamicCast<Assets::Image> ();
}