C++ Loader类代码示例

Water::Water(Loader loader)
{
	float positions[] = { -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f };
	int indices[] = { 0, 1, 3, 3, 1, 2 };

	// create a ground-plane that is 2x2 meters and scale it so it becomes 100x100 meters. 
	waterplane = loader.createModel(positions, 12, indices, 6);

	Mat4 scaleMatrix;
	scaleMatrix.loadScale(150, 1, 150);
	waterplane.setModelMatrix(scaleMatrix);

	dudvTexture = loader.loadBMPtexture("water_dudv.bmp");
	normalTexture = loader.loadBMPtexture("water_nomal.bmp");
	shader.createShader("waterVertexShader.glsl", "waterFragmentShader.glsl");
	
	reflectionFrameBuffer = FrameBufferUtilities::createBuffer();
	reflectionTexture = FrameBufferUtilities::createTextureAttachment(REFLECTION_WIDTH, REFLECTION_HEIGHT);
	reflectionDepthBuffer = FrameBufferUtilities::createDepthBufferAttachment(REFLECTION_WIDTH, REFLECTION_HEIGHT);
	FrameBufferUtilities::unbindCurrentBuffer();

	refractionFrameBuffer = FrameBufferUtilities::createBuffer();
	refractionTexture = FrameBufferUtilities::createTextureAttachment(REFRACTION_WIDTH, REFRACTION_HEIGHT);
	refractionDepthTexture = FrameBufferUtilities::createDepthTextureAttachment(REFRACTION_WIDTH, REFRACTION_HEIGHT);
	FrameBufferUtilities::unbindCurrentBuffer();

	double waterheight = 0; 
	reflection_clip_plane = Vec4{ 0, 1, 0, -waterheight + 0.05 }; 
	refraction_clip_plane = Vec4{ 0, -1, 0, -waterheight };
}

//Initialize the player.
Player::Player() {
	Loader loader;
	this->tex = loader.loadTexture("assets/pics/player.png");
	this->setTexture(tex);

	this->setTextureRect(sf::IntRect(0, 0, 170, 222));
	this->setOrigin(this->getLocalBounds().width / 2, this->getLocalBounds().height / 2);
	this->setScale(sf::Vector2f(0.3, 0.3));
	
	this->shieldTex = loader.loadTexture("assets/pics/shield.png");
	this->shieldTex.setSmooth(true);
	this->shield.setTexture(shieldTex);
	this->shield.setScale(sf::Vector2f(1.5, 1.5));

	this->spawnPoint = sf::Vector2f(400, 500);
	this->setPosition(sf::Vector2f(spawnPoint));
	this->health = 100;
	this->damage = 10;
	this->ammoDescription = "Red Rays of Happiness";
	this->shieldCharge = 200;
	this->isShielded = false;
	this->setRotation(0);
	this->acceleration = .2f;
	this->maxVelocity = 5.f;
	this->velocity = sf::Vector2f(0, 0);
	this->alive = true;
	this->isDying = false;
	this->pointMultiplier = 1;
	this->rateOfFire = 0.2;
	this->frameCount = 0;
}

/**
 * Loads Config
 * Starts the C64 Components and Threads
 */
void startComponents(char* memPtr,struct _6510_cpu* cpuPtr)
{
    std::cout << "loading components..."<<std::endl;
    memoryManager = new Service::MemoryManager((MemoryCell)memPtr);
    Loader loader = Loader(memoryManager);

    std::cout << "load configfile..."<< std::endl;
    loader.loadConfig();


    std::cout << "starting Sid thread..."<<std::endl;
    Sid::Sid* sid =  new Sid::Sid(memoryManager);

    std::cout << "starting cia thread..."<<std::endl;
    cia = new Cia::Cia(cpuPtr,memoryManager);
    VIC* vic = new VIC(cpuPtr);

    std::cout << "create memoryMap" <<std::endl;
    memMap = new MemoryMap(memoryManager,cpuPtr);
    memMap->draw(0x0,1.1);
    sidThread =thread([sid]{sid->run();});

    C64Clock = new Service::Clock(memoryManager);


    Screen* screen = new Screen(vic,cia,memoryManager,memMap);

    screenThread = thread([screen]{screen->power();});
    C64Clock->addComponent(screen);
    C64Clock->addComponent(cia);




}

void process_lines(vector<string> & lines)
{

    const int nlines = lines.size();  // number of lines
    const int n = nlines - 1; // number of input data
    if (nlines < 2) {
        cout << "number of lines is wrong" << endl;
        exit(EXIT_FAILURE);
    }


    Loader loader; // frontend
    Docker docker; // backend

    for (int i = 0; i < n; ++i) {
        string input = lines[i + 1];
        //cout << input << endl;

        loader.load(input);
        loader.check();

#if 1
        vector<string> tokens = loader.get_tokens();
        for (unsigned int i = 0; i < tokens.size() - 1; ++i)
            cout << tokens[i] << ",";
        cout << tokens[tokens.size() - 1];
#endif
        cout << endl;


        loader.build_complex(docker.complex);
        docker.run();
    }
}

	 //obj = new object
void ExceptionThrower::throwException(const char * exceptionClassName, const char * message)
{
	//This method should be implemented , for now it will be empty..
	Loader * loadclass = Loader::getInstance();
	ClassData* exceptionClassData = loadclass->getClassData(exceptionClassName);
	exceptionObject = new Object(exceptionClassData);
}

QMap<QString, QString> Sonnet::Speller::availableDictionaries() const
{
    Loader *l = Loader::openLoader();
    const QStringList lst = l->languages();
    QMap<QString, QString> langs;

    foreach(QString tag, lst) { // krazy:exclude=foreach (no const& because tag is modified below)
        tag = tag.mid(0, tag.indexOf(QLatin1Char('-')));
        int underscorePos = tag.indexOf(QLatin1Char('_'));
        QString cIsoName, lIsoName;
	if (underscorePos != -1 && underscorePos <= 3) {
            cIsoName = tag.mid(underscorePos + 1, 2);
            lIsoName = tag.left(underscorePos);
	}  else {
            lIsoName = tag;
        }
        QLocale loc(tag);
        QString description;

        if (!cIsoName.isEmpty())
            description= QString::fromLatin1("%1 (%2)")
                         .arg(KGlobal::locale()->languageCodeToName(lIsoName))
                         .arg(KGlobal::locale()->countryCodeToName(cIsoName));
        else
            description= KGlobal::locale()->languageCodeToName(lIsoName);
        //qDebug()<<"Dict is "<<tag<<" ( "<<loc.name()<<")"<<", descr = "<<description;
        langs.insert(description, tag);
    }

void main()
{
	Loader loader;
	Mesh *mesh = new Mesh;
	loader.populatePos(mesh, 0);

	while (true){}
}

//Constructor takes in the texture path and an id for the Power-Up.
Powerups::Powerups(string path, string id) {	
	Loader loader;
	this->setRadius(20);
	this->tex = loader.loadTexture(path);
	this->tex.setSmooth(true);
	this->setTexture(&tex);
	this->id = id;
}

bool WindowsOperatingSystem::IsSupported(Loader const& rLdr, Architecture const& rArch) const
{
  // At this time, only Windows on x86 is supported
  if ((rLdr.GetName() == "PE" || rLdr.GetName() == "PE+") && rArch.GetName() == "Intel x86")
    return true;

  return false;
}

Loader* Loader::create()
{
  Loader* screen = new Loader();
  screen->autorelease();
  screen->retain();

  return screen;
}

  int run(int argc, char**argv){
    Loader loader;
    int ord,nproc;
    
    
    try{
      loader= Loader(argv[1],argv[2],argv[3],nproc);
    }catch(int e){
      cout<<"Error cargando el fichero de argumento";
      switch(e){
      case -1: cout<<" 1"<<endl;break;
      case -2: cout<<" 2"<<endl;break;
      case -3: cout<<" 3"<<endl;break;
	
	
      }
      return -1;
    }
    ord = (int)sqrt(nproc);//dimension matrix

    //Create query for get processors' proxies
    // try{
     Ice::ObjectPrx proxy = communicator()->stringToProxy("IceGrid/Query");
     Ice::ObjectPrx col = communicator()->stringToProxy("Collector");
     CollectorPrx collector = CollectorPrx::checkedCast(col);
     // }catch(){
    // }
    
    
  
    Cannon::Matrix A (loader.getA());
    Cannon::Matrix B (loader.getB());
    
    Cannon::Matrix R=  Modify::multiply(A,B);
    cout << "RESULT MATRIZ"<<endl;
    ofstream out("normalresult.m");
    for(int i=0;i<R.ncols;i++){
      for(int j=0;j<R.ncols;j++){
	out << R.data[j+ i*R.ncols] << " ";
	cout<<R.data[j+ i*R.ncols]<< " ";
      }
      out << endl;
      cout << endl;
    }
    out.close();
    vector < Cannon::Matrix> vA = Modify::split(A,ord);
    std::vector< Cannon::Matrix> vB = Modify::split(B,ord);
    
    
    vA = Modify::displace_horizontal(vA,ord);
    vB = Modify::displace_vertical(vB,ord);
    
    
    Dispatch dispatcher(nproc, proxy,collector);//create dispatcher for proccesors
    dispatcher.distr(vA,vB,0);   
    
    return 0;
  }

void MrmlView::stopDownloads()
{
    Loader *loader = Loader::self();
    QPtrListIterator<MrmlViewItem> it( m_items );
    for( ; it.current(); ++it ) {
        MrmlViewItem *item = it.current();
        if ( !item->hasRemotePixmap() )
            loader->removeDownload( item->url() );
    }
}

	Loader* RootParser15::beginCommon( )
	{
		mFileLoader->deleteFilePartLoader();
		Loader* loader = new Loader(mFileLoader);
		Loader15* loader15 = new Loader15(loader);
		loader->setParserImpl( loader15 );
		mFileLoader->setPartLoader(loader);
		mFileLoader->setParser(loader15);
		return loader;
	}

ScriptPromise FetchManager::fetch(ScriptState* scriptState, const FetchRequestData* request)
{
    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
    ScriptPromise promise = resolver->promise();

    OwnPtr<Loader> ownLoader(adoptPtr(new Loader(m_executionContext, this, resolver.release(), request)));
    Loader* loader = m_loaders.add(ownLoader.release()).storedValue->get();
    loader->start();
    return promise;
}

	Loader* RootParser14::beginCommonWithId( const char * id)
	{
		mFileLoader->deleteFilePartLoader();
		Loader* loader = new Loader(mFileLoader);
		Loader14* loader14 = new Loader14(loader);
		loader->setParserImpl( loader14 );
		mFileLoader->setPartLoader(loader);
		mFileLoader->setParser(loader14);
		mFileLoader->addToSidTree( id, 0);
		return loader;
	}