自学教程：C++ tile函数代码示例

void ReportWriterWindow::sPrepareWindowMenu(){  windowMenu->clear();  int intCascadeid = windowMenu->insertItem(tr("&Cascade"), ws, SLOT(cascade()));  int intTileid = windowMenu->insertItem(tr("&Tile"), ws, SLOT(tile()));  windowMenu->insertSeparator();  int cnt = 0;  QWidgetList windows = ws->windowList();  for (unsigned int intCursor = 0; intCursor < windows.count(); intCursor++)  {    if(windows.at(intCursor)->isVisible())    {      int intMenuid = windowMenu->insertItem(windows.at(intCursor)->caption(), windows.at(intCursor), SLOT(setFocus()));      windowMenu->setItemChecked(intMenuid, (ws->activeWindow() == windows.at(intCursor)));      cnt++;    }  }  if (cnt < 1)  {    windowMenu->setItemEnabled(intCascadeid, FALSE);    windowMenu->setItemEnabled(intTileid, FALSE);  }}

void mission_start::kill_horde_master(mission *miss){ npc *p = g->find_npc(miss->npc_id); p->attitude = NPCATT_FOLLOW;//npc joins you int dist = 0;//pick one of the below locations for the horde to haunt point site = g->cur_om->find_closest(g->om_location(), "office_tower_1", dist, false); if (site.x == -1 && site.y == -1 )    site = g->cur_om->find_closest(g->om_location(), "hotel_tower_1_8", dist, false); if (site.x == -1 && site.y == -1)    site = g->cur_om->find_closest(g->om_location(), "school_5", dist, false); if (site.x == -1 && site.y == -1)    site = g->cur_om->find_closest(g->om_location(), "forest_thick", dist, false); miss->target = site;// Make it seen on our map for (int x = site.x - 6; x <= site.x + 6; x++) {  for (int y = site.y - 6; y <= site.y + 6; y++)   g->cur_om->seen(x, y, 0) = true; } tinymap tile(&(g->traps)); tile.load(site.x * 2, site.y * 2,  0, false); tile.add_spawn("mon_zombie_master", 1, SEEX, SEEY, false, -1, miss->uid, "Demonic Soul"); tile.add_spawn("mon_zombie_brute",3,SEEX,SEEY); tile.add_spawn("mon_zombie_fast",3,SEEX,SEEY); if (SEEX > 1 && SEEX < OMAPX && SEEY > 1 && SEEY < OMAPY){ for (int x = SEEX - 1; x <= SEEX + 1; x++) {  for (int y = SEEY - 1; y <= SEEY + 1; y++)   tile.add_spawn("mon_zombie",rng(3,10),x,y);   tile.add_spawn("mon_zombie_fast",rng(0,2),SEEX,SEEY); }} tile.add_spawn("mon_zombie_necro",2,SEEX,SEEY); tile.add_spawn("mon_zombie_hulk",1,SEEX,SEEY); tile.save(g->cur_om, int(g->turn), site.x * 2, site.y * 2, 0);}

bool TileManager::LoadTileInfo( const TiXmlElement *strip ) {  std::string tileName, tileType;  int tileId = 0;  const char *name = strip->Attribute( "name" );  if ( name ) {    tileName = name;  } else {    LogErr( "No name specified for tile." );    return false;  }  const char *type = strip->Attribute( "type" );  if ( type ) {    tileType = type;  } else {    LogErr( "No type specified for tile." );    return false;  }  strip->QueryIntAttribute( "id", &tileId );  Tile tile( tileType, tileName, tileId );  m_tileDataName.insert(    std::pair<std::string, Tile>( tileName, tile ));  m_tileDataId.insert(    std::pair<int, Tile*>( tileId, &m_tileDataName[tileName] ));  return true;}

bool World::IsBuildTileAccessible(const BuildTile& parBuildTile, const int2& parDimensions) const{	assert(parBuildTile.IsValid());	if (!accessibleTile_[parBuildTile.x()][parBuildTile.y()])		return false;	BuildTile dimensionInBuildTile(float2(float(parDimensions.x), float(parDimensions.y))); // force conversion	const int2& minTile = int2(		parBuildTile.x() - 1 - dimensionInBuildTile.w() / 2,		parBuildTile.y() - 1 - dimensionInBuildTile.h() / 2);	const int2& maxTile = int2(		parBuildTile.x() + 1 + dimensionInBuildTile.w() / 2,		parBuildTile.y() + 1 + dimensionInBuildTile.h() / 2);	for (int x = minTile.x; x <= maxTile.x; ++x)	{		for (int y = minTile.y; y <= maxTile.y; ++y)		{			BuildTile tile(x, y);			if (!tile.IsValid() || !accessibleTile_[x][y])				return false;		}	}	return true;}

void hc_map::update_tile(hc_connection *con){	hc_tile_info new_info;	con->recv(&new_info);	vector<hc_tile> *tiles = nullptr;	if(new_info.type == 0)	{		tiles = &background;		background_changed = true;	}	else if(new_info.type == 1)	{		tiles = &objects;		objects_changed = true;	}	else	{		hc_fatal << "Unknown tiletype" << endl;		exit(0);	}	for(auto t:*tiles)	{		if(t.get_ID() == new_info.tile_ID)		{			t.update(new_info);			return;		}	}	hc_tile tile(new_info.tile_ID, new_info);	tiles->push_back(tile);}

void StageState::CreateCharacter(int x, int y){	Point tile(x, y);	Point tiles = tile;	tile = tileMap.GetTileCenter(tile);	Permonkey* pM = new Permonkey(tile.x, tile.y, tiles, tileMap, objList);	objectArray.emplace_back(pM);}

void findContiguous(const MapTiles &map, TileCoord startTileLocation, std::set<TileCoord, TileCoord::Before> *regionTiles) {    regionTiles->clear();        std::set<TileCoord, TileCoord::Before> tilesToExpandFrom;    tilesToExpandFrom.insert(startTileLocation);        regionTiles->insert(startTileLocation);        while (!tilesToExpandFrom.empty()) {        TileCoord tileToExpandFrom = *tilesToExpandFrom.begin();        tilesToExpandFrom.erase(tilesToExpandFrom.begin());                for (int rowDelta = -1; rowDelta <= 1; rowDelta++) {            for (int colDelta = -1; colDelta <= 1; colDelta++) {                if (rowDelta == 0 && colDelta == 0)                    continue;                                TileCoord tile(tileToExpandFrom.row + rowDelta, tileToExpandFrom.col + colDelta);                                if (map[tile] == map[tileToExpandFrom]) {                    if (regionTiles->find(tile) != regionTiles->end())                        continue;                                        regionTiles->insert(tile);                    tilesToExpandFrom.insert(tile);                }            }        }    }    //    std::cout << "found contiguous block of size " << regionTiles->size() << std::endl;}

void LoadedMap::loadTerrains(XMLElement *element, TileSet *target){    Logger.logMessage(LOG_STATE, LOG_MAP, "LoadedMap::loadTerrains start/n");    assert(element);    assert(target);    XMLElement *terrain = element->FirstChildElement(XML_TERRAIN.c_str());    Logger.logMessage(LOG_DEBUG, LOG_MAP, "LoadedMap::loadTerrains: Found first terrain/n");    while(terrain)    {        TerrainType parsed_terrain;        parsed_terrain.name = getAttributeString(terrain, XML_TERRAIN_NAME);        stringstream tile (terrain->Attribute(XML_TERRAIN_TILE.c_str()));        tile >> parsed_terrain.tile;        XMLElement *properties = terrain->FirstChildElement(XML_TERRAIN_PROPS.c_str());        if(properties)        {            loadTerrainProperties(properties, &parsed_terrain);        }        target->terraintypes.push_back(parsed_terrain);        terrain = terrain->NextSiblingElement();    }    Logger.logMessage(LOG_STATE, LOG_MAP, "LoadedMap::loadTerrains end/n");}

void Tileset::Init16bpp(const std::vector<Image16Bpp>& images){    int tile_width = 8 + params.border;    const ImageTile& nullTile = ImageTile::GetNullTile();    itiles.insert(nullTile);    for (unsigned int k = 0; k < images.size(); k++)    {        const Image16Bpp& image = images[k];        unsigned int tilesX = image.width / tile_width;        unsigned int tilesY = image.height / tile_width;        unsigned int totalTiles = tilesX * tilesY;        // Perform reduce.        for (unsigned int i = 0; i < totalTiles; i++)        {            int tilex = i % tilesX;            int tiley = i / tilesX;            ImageTile tile(image, tilex, tiley, params.border);            std::set<ImageTile>::iterator foundTile = itiles.find(tile);            if (foundTile == itiles.end())            {                tile.id = itiles.size();                itiles.insert(tile);            }        }    }}

dng_tile_iterator::dng_tile_iterator (const dng_point &tileSize,                                      const dng_rect &area)    :	fArea           ()    ,	fTileWidth      (0)    ,	fTileHeight     (0)    ,	fTileTop        (0)    ,	fTileLeft       (0)    ,	fRowLeft        (0)    ,	fLeftPage       (0)    ,	fRightPage      (0)    ,	fTopPage        (0)    ,	fBottomPage     (0)    ,	fHorizontalPage (0)    ,	fVerticalPage   (0){    dng_rect tile (area);    tile.b = Min_int32 (tile.b, tile.t + tileSize.v);    tile.r = Min_int32 (tile.r, tile.l + tileSize.h);    Initialize (tile,                area);}

static voidocean_tile2(struct rect *r, int dx, int dy, int wf, int hf, struct item_bin_sink *out){	struct item_bin *ib=(struct item_bin *)buffer;	int w=r->h.x-r->l.x;	int h=r->h.y-r->l.y;	char tile2[32];	struct rect bbox;	struct coord co;	bbox.l.x=r->l.x+dx*w;	bbox.l.y=r->l.y+dy*h;	bbox.h.x=bbox.l.x+w*wf;	bbox.h.y=bbox.l.y+h*hf;	//fprintf(stderr,"0x%x,0x%x-0x%x,0x%x -> 0x%x,0x%x-0x%x,0x%x/n",r->l.x,r->l.y,r->h.x,r->h.y,bbox.l.x,bbox.l.y,bbox.h.x,bbox.h.y);	item_bin_init(ib,type_poly_water_tiled);	item_bin_bbox(ib, &bbox);	item_bin_write_to_sink(ib, out, NULL);#if 0	item_bin_init(ib, type_border_country);	item_bin_bbox(ib, &bbox);	item_bin_add_attr_string(ib, attr_debug, tile2);	item_bin_write_to_sink(ib, out, NULL);#endif	tile(&bbox, NULL, tile2, 32, 0, NULL);	co.x=(bbox.l.x+bbox.h.x)/2;	co.y=(bbox.l.y+bbox.h.y)/2;	//item_bin_write_debug_point_to_sink(out, &co, "%s 15",tile2);}

Colony::~Colony(){    disconnect(this, nullptr, tile(), nullptr);    m_planet->removeColony();    m_player->removeColony(this);}

TileGroup::TileGroup(BackendType backend_type,                     TileGroupHeader *tile_group_header, AbstractTable *table,                     const std::vector<catalog::Schema> &schemas,                     const column_map_type &column_map, int tuple_count)    : database_id(INVALID_OID),      table_id(INVALID_OID),      tile_group_id(INVALID_OID),      backend_type(backend_type),      tile_schemas(schemas),      tile_group_header(tile_group_header),      table(table),      num_tuple_slots(tuple_count),      column_map(column_map) {  tile_count = tile_schemas.size();  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {    auto &manager = catalog::Manager::GetInstance();    oid_t tile_id = manager.GetNextOid();    std::shared_ptr<Tile> tile(storage::TileFactory::GetTile(        backend_type, database_id, table_id, tile_group_id, tile_id,        tile_group_header, tile_schemas[tile_itr], this, tuple_count));    // Add a reference to the tile in the tile group    tiles.push_back(tile);  }}

Image* EXRImageFileReader::read(    const char*         filename,    ImageAttributes*    image_attributes){    ProgressiveEXRImageFileReader reader(32, 32);    reader.open(filename);    CanvasProperties props;    reader.read_canvas_properties(props);    if (image_attributes)        reader.read_image_attributes(*image_attributes);    auto_ptr<Image> image(        new Image(            props.m_canvas_width,            props.m_canvas_height,            props.m_tile_width,            props.m_tile_height,            props.m_channel_count,            props.m_pixel_format));    for (size_t tile_y = 0; tile_y < props.m_tile_count_y; ++tile_y)    {        for (size_t tile_x = 0; tile_x < props.m_tile_count_x; ++tile_x)        {            auto_ptr<Tile> tile(reader.read_tile(tile_x, tile_y));            image->set_tile(tile_x, tile_y, tile.release());        }    }    reader.close();    return image.release();}

double tiledInnerParallelGauss(double** a, double* answer, size_t N, int r1, int r2) {	makeMainElementNotZero(a, N);//	int r1 = 2;//	int r2 = 2;	int Q1 = N / r1;	int Q2 = N / r2;	//##########	double start = omp_get_wtime();	for (int k = 0; k < N - 1; ++k) {		for (int i_gl = 0; i_gl < Q1; ++i_gl) {#pragma omp parallel for        			for (int j_gl = 0; j_gl < Q2; ++j_gl) {				tile(k, i_gl, j_gl, r1, r2, a, N);  			}		}	}	double finish = omp_get_wtime();	//##########        	check("Inner", a,answer,N, finish - start);	return finish - start;}

void MozQWidgetFast::paint(QPainter* aPainter,                           const QStyleOptionGraphicsItem*,                           QWidget*){  // toolbar height  int toolbarHeight = 80;  // Offset of favicon starting from left toolbar edge  int faviconOffset = 25;  // favicon size  int faviconSize = 32;  // width of left and right TOOLBAR_SPLASH part  // |------------------------------|  // |LeftPart|tile...part|RightPart|  float toolbarPartWidth = 77;  // width of TOOLBAR_SPLASH part after toolbarPartWidth,  // that can be used for tiled toolbar area  int tileWidth = 2;  // Paint left toolbar part  aPainter->drawPixmap(QRect(0, 0, toolbarPartWidth, toolbarHeight),                       mToolbar, QRect(0, 0, toolbarPartWidth, toolbarHeight));  // Paint Tile pixmap of middle toolbar part  QPixmap tile(tileWidth, toolbarHeight);  QPainter p(&tile);  p.drawPixmap(QRect(0, 0, tileWidth, toolbarHeight), mToolbar,               QRect(toolbarPartWidth, 0, tileWidth, toolbarHeight));  aPainter->drawTiledPixmap(QRect(toolbarPartWidth, 0, rect().width() - toolbarPartWidth * 2,                                  toolbarHeight),                            tile);  // Paint Favicon  aPainter->drawPixmap(QRect(faviconOffset, faviconOffset,                             faviconSize, faviconSize),                       mIcon);  if (!mUrl.isEmpty()) {    // Height or URL string (font height)    float urlHeight = 24.0f;    // Start point of URL string, relative to window 0,0    int urlOffsetX = 80;    int urlOffsetY = 48;    QFont font = aPainter->font();    font.setPixelSize(urlHeight);    font.setFamily(QString("Nokia Sans"));    font.setKerning(true);    aPainter->setFont(font);    aPainter->setRenderHint(QPainter::TextAntialiasing, true);    aPainter->drawText(urlOffsetX, urlOffsetY,                       aPainter->fontMetrics().elidedText(mUrl, Qt::ElideRight, rect().width() - urlOffsetX * 2));  }  // Paint Right toolbar part  aPainter->drawPixmap(QRect(rect().width() - toolbarPartWidth,                             0, toolbarPartWidth,                             toolbarHeight),                       mToolbar,                       QRect(mToolbar.width() - toolbarPartWidth, 0,                             toolbarPartWidth, toolbarHeight));  nsFastStartup::GetSingleton()->painted();}

void decleftcount(void){	int curid = workspace_get_active();	if (workspace_dec_left_count(curid)) {		tile(curid);	}}

void decleftwidth(void){	int curid = workspace_get_active();	if (workspace_dec_left_width(curid)) {		tile(curid);	}}

	virtual void Execute(const DataObject &)	{		RULE.Execute(shRuleUpdateMessageUI, DataObject(stPlaceTheRobber,             stWaitingPlaceTheRobber));		//set the dummy selection		DummySelectionObject *pSelection = new DummySelectionObject(			shRuleExecuteRobberPlacement);		//send the dummy selection object up		Controller::get().Transmit(shEventSelectionObject, 			SelectionObjectPtr(pSelection));		// Make sure eveything is hidden.		Controller::get().Transmit(shEventBuildUI, 			DataObject(false, GetGame()));		Controller::get().Transmit(shEventControlsUI, DataObject(false));		RULE.Execute(shRuleResetTileFlags, DataObject(IGameObject::Dim));		// They can't place the robber on the current robber tile.		const HexObjectPtr& robber = GetGame()->getHexObject(shRobber);		wxInt32 robberTile = robber->tile();		if(true == robber->isset(IGameObject::Hidden))		{			robberTile = -1;		}		// Turn on all land tiles except the robber tile.		wxInt32 tiles = numTiles();		for(wxInt32 i = 0; i < tiles; ++i)		{			if(i != robberTile)			{				DataObject input(i), output;				RULE.Decide(shLogicTileIsLand, input, output);				if(true == output.read<bool>())				{					tile(i)->reset();					tile(i)->set(IGameObject::Select);				}			}		}	}

//return a new image from a tile in this imageImage * Image::createImageFromThis(int tileNum, int iAlpha /*=-1*/){	SDL_Rect r = tile(tileNum, _tileW, _tileH);	Image *image = new Image(r.w, r.h, iAlpha);	image->blitFrom(this, tileNum);	image->setTileSize(_tileW, _tileH);	return image;}

static voidupdate_fog_after_move (Unit *u){  Mcrd m;  FOR_EACH_MCRD(m){    if(mdist(m, u->m) <= utypes[u->t].v)      tile(m)->visible = true;  }}

static voiddraw_fog (void){  Mcrd m;  FOR_EACH_MCRD(m){    if(!tile(m)->visible)      draw_img(img_fog_of_war, map2scr(m));  }}

static voiddraw_map (void){  Mcrd m;  FOR_EACH_MCRD(m){    SDL_Surface *s = img_tiles[tile(m)->t];    draw_img(s, map2scr(m));  }}

//-----------------------------------------------------------------------------//init the image fragment tile -- virtual function//-----------------------------------------------------------------------------void Compose_Viewer::init_ift(){    m_ift = new ImageFragment_Tile(0, 0, gw, gh);    //single tile viewer    NodeRectile tile(1, m_gw, m_gh);    m_ift->set_tile(&tile);}

void KviMdiManager::destroyChild(KviMdiChild *lpC){	removeSubWindow(lpC);	delete lpC;	if(!m_bInSDIMode && KVI_OPTION_BOOL(KviOption_boolAutoTileWindows))		tile();}

void Frustum::tileFrustum(U32 numTiles, const Point2I& curTile, Point2F overlap){   //These will be stored to re-tile the frustum if needed   mNumTiles = numTiles;    mCurrTile = curTile;    mTileOverlap = overlap;      tile(&mNearLeft, &mNearRight, &mNearTop, &mNearBottom, mNumTiles, mCurrTile, mTileOverlap);}