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

			vec2i print_stroked(				const drawer out,				vec2i pos,				const formatted_string& str,				const ralign_flags c,				const rgba stroke_color,				const unsigned wrapping_width,				const ltrbi clipper,				const bool use_kerning			) {				thread_local drafter draft;				thread_local printer print;				draft.wrap_width = wrapping_width;				draft.kerning = use_kerning;				draft.draw(str);				auto coloured_str = str;				for (auto& col : coloured_str) {					col.set_color(stroke_color);				}				thread_local formatted_utf32_string prev;				prev = draft.cached_str;				draft.cached_str = coloured_str;				if (c.test(ralign::CX)) {					pos.x -= draft.get_bbox().x / 2;				}				if (c.test(ralign::CY)) {					pos.y -= draft.get_bbox().y / 2;				}				if (c.test(ralign::RB)) {					pos -= draft.get_bbox();				}				if (c.test(ralign::LB)) {					pos.y -= draft.get_bbox().y;				}				if (c.test(ralign::RT)) {					pos.x -= draft.get_bbox().x;				}				print.draw_text(out, pos + vec2i(-1, 0), draft, clipper);				print.draw_text(out, pos + vec2i(1, 0), draft, clipper);				print.draw_text(out, pos + vec2i(0, -1), draft, clipper);				print.draw_text(out, pos + vec2i(0, 1), draft, clipper);				draft.cached_str = prev;				print.draw_text(out, pos, draft, clipper);				return draft.get_bbox() + vec2i(2, 2);			}

void Player::HitAbove(){    const Tile & B = Level->GetBlockAt(GridLocationExt - vec2i(0,1));    if (B.BlockID == 15)    {        Level->SetBlockAt(GridLocationExt-vec2i(0,1),Tile(0,false));    }}

static vec2i GetWindowSize() {  if (UseHardwareScaling()) {    return vec2i(kAndroidMaxScreenWidth, kAndroidMaxScreenHeight);  } else {    return vec2i(std::numeric_limits<int>::max(),                 std::numeric_limits<int>::max());  }}

/// Tesselate Mesh one time/// @param mesh The Mesh to tesselate/// @return The tesselated MeshMesh* _tesselate_mesh_once(Mesh* mesh) {    auto tesselation = new Mesh();    // Set up the hashtable for adjacency    auto adj = EdgeHashTable(mesh->triangle, mesh->quad);    // Add vertices to the tessellation    tesselation->pos = mesh->pos;    // tesselation->norm = mesh->norm;    // tesselation->texcoord = mesh->texcoord;    // Add edge vertices to the tessellation    int evo = tesselation->pos.size();    for(auto e : adj.edges) {        tesselation->pos.push_back(mesh->pos[e.x]*0.5+mesh->pos[e.y]*0.5);        // if(not tesselation->norm.empty()) tesselation->norm.push_back(normalize(mesh->norm[e.x]*0.5+mesh->norm[e.y]*0.5));        // if(not tesselation->texcoord.empty()) tesselation->texcoord.push_back(mesh->texcoord[e.x]*0.5+mesh->texcoord[e.y]*0.5);    }    // Add face vertices to the tessellation    int fvo = tesselation->pos.size();    for(auto f : mesh->quad) {        tesselation->pos.push_back(mesh->pos[f.x]*0.25+mesh->pos[f.y]*0.25+mesh->pos[f.z]*0.25+mesh->pos[f.w]*0.25);        // if(not tesselation->texcoord.empty()) tesselation->texcoord.push_back(mesh->texcoord[f.x]*0.25+mesh->texcoord[f.y]*0.25+mesh->texcoord[f.z]*0.25+mesh->texcoord[f.w]*0.25);    }    // Add triangles to the tessellation    for(auto f : mesh->triangle) {        auto ve = vec3i(adj.edge(f.x, f.y),adj.edge(f.y, f.z),adj.edge(f.z, f.x))+vec3i(evo,evo,evo);        tesselation->triangle.push_back(vec3i(f.x,ve.x,ve.z));        tesselation->triangle.push_back(vec3i(f.y,ve.y,ve.x));        tesselation->triangle.push_back(vec3i(f.z,ve.z,ve.y));        tesselation->triangle.push_back(ve);    }    // Add quads to the tessellation    for(int fid = 0; fid < mesh->quad.size(); fid ++) {        auto f = mesh->quad[fid];        auto ve = vec4i(adj.edge(f.x, f.y),adj.edge(f.y, f.z),adj.edge(f.z, f.w),adj.edge(f.w, f.x))+vec4i(evo,evo,evo,evo);        auto vf = fid+fvo;        tesselation->quad.push_back(vec4i(f.x,ve.x,vf,ve.w));        tesselation->quad.push_back(vec4i(f.y,ve.y,vf,ve.x));        tesselation->quad.push_back(vec4i(f.z,ve.z,vf,ve.y));        tesselation->quad.push_back(vec4i(f.w,ve.w,vf,ve.z));    }    // Add lines to the tessellation    if(mesh->_tesselation_lines.size() > 0) {        for(auto l : mesh->_tesselation_lines) {            int ve = adj.edge(l.x, l.y)+evo;            tesselation->_tesselation_lines.push_back(vec2i(l.x,ve));            tesselation->_tesselation_lines.push_back(vec2i(ve,l.y));        }    }    return tesselation;}

// staticvoid InputImpl::init() {	mousePos = vec2i(0, 0);	mouseWheelPos = vec2i(0, 0);	relativeMouse = false;	for(int i = 0; i < Keyboard::KeyCount; i++)		keyPresses[i] = false;	for(int i = 0; i < Mouse::ButtonCount; i++)		mouseButtonPresses[i] = false;}

void tile_picker::scroll_event(int newx, image *screen){  int yo=y,ya=pich(),xw=picw(),c=get_current(),xo;  image im(vec2i(xw, ya));  last_sel=newx;  screen->bar(x,y,x+l-1,y+h-1,wm->black());  for (int i=newx; i<newx+th*wid; i++)  {    xo=x+((i-newx)%wid)*xw;    yo=y+((i-newx)/wid)*ya;      int blank=0;      if (i<t)      {    switch (type)    {      case SPEC_FORETILE :      {        if (foretiles[i]<0) blank=1;        else        {          im.clear();          the_game->get_fg(i)->im->PutImage(&im,vec2i(0,0));          if (rev)          {        screen->bar(xo,yo,xo+xw-1,yo+ya-1,wm->bright_color());        scale_put_trans(&im,screen,xo,yo,xw,ya);          }          else scale_put(&im,screen,xo,yo,xw,ya);        }      } break;      case SPEC_BACKTILE :      {        if (backtiles[i]<0) blank=1;        else          scale_put(the_game->get_bg(i)->im,screen,xo,yo,xw,ya);      } break;      case SPEC_CHARACTER :      {        figures[i]->get_sequence(stopped)->get_figure(0)->forward->PutImage(&im,vec2i(0,0));        scale_put(&im,screen,xo,yo,xw,ya);      } break;    }      } else blank=1;      if (i==c)        screen->rectangle(xo,yo,xo+xw-1,yo+ya-1,wm->bright_color());  }}

Player::Player(const vec2f & Location) : EntityBase(Location){    CurrentSprite = R->LoadSprite("fario",vec2i(17,17),vec2i(0,0));    AnimationList = R->LoadAnimationSet("Fario");    PlayAnimation("idle");    SpriteOffset=vec2i(8,17);    JumpSound = R->LoadSound("MarioJump");    LandSound = R->LoadSound("FarioLandB");    //BrickDestroyed = R.LoadSound("BrickDestroyed");    AirControl = 0.4;    Accel = 0.25;    Height=1;}

void Service::drawWidgets() {	core::BufferAllocator glyphBuffer(sizeof(rendering::text::Glyph)*128,&services::tasking()->threadContext().frameAllocator(),core::BufferAllocator::GrowOnOverflow);			events::Draw drawEvent;	drawEvent.layerId = 0;	drawEvent.renderer = renderer_;	drawEvent.glyphExtractionBuffer = &glyphBuffer;	drawEvent.position = vec2i(0,0);	drawEvent.size = vec2i(rootSize_.x,rootSize_.y);	Widget widget;	widget.addComponent(root_);	widget.draw(drawEvent);	renderer_->prepareRendering();}

/*!    /fn SqlGameTable::getPlayerGameTime( uint32_t _nTableID, uint32_t &_nGameTime ) */bool SqlGameTable::getPlayerGameTime( uint32_t _nTableID, uint8_t _nPlayerNum, uint32_t &_nGameTime ){	TVecChar vecData;	const char* cszFieldName = 0;	if (_nPlayerNum == 0)	{		cszFieldName =  "Player0GameTime";	}	else if (_nPlayerNum == 1)	{		cszFieldName =  "Player1GameTime";	}	else	{		return false;	}	if( !SelectToStr( cszFieldName, "TableID", CMyStr( _nTableID ).c_str(), &vecData ) )	{		return false;	}    _nGameTime = vec2i( &vecData );	return true;}

static inline void boxVerticesToScreenVertices(vec4f vertices[8],const vec4f& screenCenterMul,vec2i screenCenter){#ifdef ARPHEG_ARCH_X86	__m128 screenSpaceMul = _mm_load_ps((float*)&screenCenterMul.x);	__m128 screenCenterOffset = _mm_setr_ps(float(screenCenter.x),float(screenCenter.y),0,0);	__m128 nearClip = _mm_setzero_ps();	for(uint32 i = 0;i<8;++i){		__m128 hv = _mm_load_ps((float*)(vertices + i));				__m128 w  = _mm_shuffle_ps(hv,hv,_MM_SHUFFLE(3,3,3,3)); //get the w component		__m128 z  = _mm_shuffle_ps(hv,hv,_MM_SHUFFLE(2,2,2,2));		hv = _mm_div_ps(hv,w); //Project XYZW to clip space (divide by w)				hv = _mm_mul_ps(hv,screenSpaceMul); //XY to screen space    [-width/2,-height/2 -> width/2,height/2]		hv = _mm_add_ps(hv,screenCenterOffset);//XY to screen space [0,0 -> width,height]		__m128 mNoNearClip = _mm_cmpge_ps(z, nearClip );		//Set to all-0 if near-clipped		hv = _mm_and_ps(hv, mNoNearClip);		_mm_store_ps((float*)(vertices + i),hv);	}#else	//TODO	ScreenSpaceVertex* screenVerts= (ScreenSpaceVertex*)vertices;	for(uint32 i =0;i<8;++i){		vertices[i] = vertices[i] * (1.0f/vertices[i].w) ;		auto v = vertices[i] * screenCenterMul;		screenVerts[i].pos = vec2i(int32(v.x),int32(v.y))+screenCenter;	}#endif}

void LDEgui_elements::addCombobox( LDEgui_combobox *arg ){	combobox.push_back( arg );		LDEuint pointer = combobox.size()-1;		combobox[pointer]->button.font = font_elements;	combobox[pointer]->button.texture_rel = texture_combobox;	combobox[pointer]->button.texture_coi = texture_combobox_hover;    combobox[pointer]->button.texture_pre = texture_combobox_pressed;	combobox[pointer]->button.name = "?";		combobox[pointer]->font_item = font_elements;	combobox[pointer]->texture_item = texture_button_rel;	combobox[pointer]->texture_item_hover = texture_button_coi;    combobox[pointer]->texture_item_pressed = texture_button_pre;		combobox[pointer]->size = vec2i( 80, 16 );    	combobox[pointer]->button.uv_up = 8;    combobox[pointer]->button.uv_down = 8;    combobox[pointer]->button.uv_left = 9;    combobox[pointer]->button.uv_right = 14;    	combobox[pointer]->menu_item = menu_item;}

bool Texture::load(const std::string &filePath) {	//load image	sf::Image image;	if (!image.loadFromFile(filePath)) {		std::cout << "#ERROR " << filePath << " didn't load" << std::endl;		return false;	}	size = vec2i(image.getSize().x,image.getSize().y);		//get handle	GLuint tex_handle;	glGenTextures(1, &tex_handle);	handle = tex_handle;		//bind handle and set to image	bind();	glTexImage2D(				GL_TEXTURE_2D, 0, GL_RGBA,				image.getSize().x, image.getSize().y,				0,				GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr()				);	setFilter(GL_NEAREST);	setWrap(GL_REPEAT);	return true;}

	void D3D11RenderTarget::captureDepthBuffer(DepthImage32& result, const mat4f& perspectiveTransform)	{		captureDepthBuffer(result);		const mat4f inv = perspectiveTransform.getInverse();		//result.setInvalidValue(std::numeric_limits<float>::infinity());	//the default is -INF		for (unsigned int y = 0; y < result.getHeight(); y++)	{			for (unsigned int x = 0; x < result.getWidth(); x++)	{				float &v = result(x, y);				if (v >= 1.0f)					v = result.getInvalidValue();				else				{					//float dx = math::linearMap(0.0f, result.getWidth() - 1.0f, -1.0f, 1.0f, (float)x);					//float dy = math::linearMap(0.0f, result.getHeight() - 1.0f, -1.0f, 1.0f, (float)y);					//v = (inv * vec3f(dx, dy, v)).z;										vec2f p = D3D11GraphicsDevice::pixelToNDC(vec2i(x, y), result.getWidth(), result.getHeight());					v = (inv * vec3f(p.x, p.y, v)).z;				}			}		}	}

void Vizzer::drawText(ApplicationData &app, vector<string> &text){    int y = 0;    for (auto &entry : text)    {        font.drawString(app.graphics, entry, vec2i(10, 5 + y++ * 25), 24.0f, RGBColor::Red);    }}

bool EditorHandler::mousePassiveMotion(int x, int y){    if (editors.empty()) {        return false;    }    lastPos = vec2i(x, y);    return false;}

void LDEgui_drawable::draw( vec2i cursor, LDEfloat frametime ){	coi = cursorOnIt( cursor );		//glEnable(GL_SCISSOR_TEST);	//LDEscissor(pos.x, pos.y, size.x, size.y);	scene( vec2i(pos.x+x,pos.y+y), size, test_coi && coi ? 1 : 0, frametime );	//glDisable(GL_SCISSOR_TEST);}

  LocalFrameBuffer::LocalFrameBuffer(const vec2i &size,                                     ColorBufferFormat colorBufferFormat,                                     const uint32 channels,                                     void *colorBufferToUse)    : FrameBuffer(size, colorBufferFormat, channels)      , tileErrorRegion(hasVarianceBuffer ? getNumTiles() : vec2i(0))  {    Assert(size.x > 0);    Assert(size.y > 0);    if (colorBufferToUse)      colorBuffer = colorBufferToUse;    else {      switch (colorBufferFormat) {      case OSP_FB_NONE:        colorBuffer = nullptr;        break;      case OSP_FB_RGBA8:      case OSP_FB_SRGBA:        colorBuffer = (uint32*)alignedMalloc(sizeof(uint32)*size.x*size.y);        break;      case OSP_FB_RGBA32F:        colorBuffer = (vec4f*)alignedMalloc(sizeof(vec4f)*size.x*size.y);        break;      }    }    depthBuffer = hasDepthBuffer ? alignedMalloc<float>(size.x*size.y) :      nullptr;    accumBuffer = hasAccumBuffer ? alignedMalloc<vec4f>(size.x*size.y) :      nullptr;    const size_t bytes = sizeof(int32)*getTotalTiles();    tileAccumID = (int32*)alignedMalloc(bytes);    memset(tileAccumID, 0, bytes);    varianceBuffer = hasVarianceBuffer ? alignedMalloc<vec4f>(size.x*size.y) :      nullptr;    normalBuffer = hasNormalBuffer ? alignedMalloc<vec3f>(size.x*size.y) :      nullptr;    albedoBuffer = hasAlbedoBuffer ? alignedMalloc<vec3f>(size.x*size.y) :      nullptr;    ispcEquivalent = ispc::LocalFrameBuffer_create(this,size.x,size.y,                                                   colorBufferFormat,                                                   colorBuffer,                                                   depthBuffer,                                                   accumBuffer,                                                   varianceBuffer,                                                   normalBuffer,                                                   albedoBuffer,                                                   tileAccumID);  }

TileEntity::TileEntity(const vec2i&Location) : EntityBase(vec2i()){	TileLocation = Location;    this->Location = TileLocation*16;    this->GridLocation = Location;    this->GridLocationExt = Location;    Physic = PHYS_None;}

void LocalFrameBuffer::clear(const uint32 fbChannelFlags){    if (fbChannelFlags & OSP_FB_ACCUM) {        // it is only necessary to reset the accumID,        // LocalFrameBuffer_accumulateTile takes care of clearing the        // accumulation buffers        memset(tileAccumID, 0, tiles*sizeof(int32));        // always also clear error buffer (if present)        if (hasVarianceBuffer) {            for (int i = 0; i < tiles; i++)                tileErrorBuffer[i] = inf;            errorRegion.clear();            // initially create one region covering the complete image            errorRegion.push_back(box2i(vec2i(0), vec2i(tilesx, divRoundUp(size.y, TILE_SIZE))));        }    }}

    vec2i Material::getParam(const char *name, vec2i defaultVal)     {      ParamMap::iterator it = params.find(name);      if (it != params.end()) {        assert( it->second->type == Param::INT_2 && "Param type mismatch" );        return vec2i(it->second->i[0], it->second->i[1]);      }      return defaultVal;    }

bool SqlGameTable::getBet( uint32_t _nTableID, uint32_t& bet ){    TVecChar vecData;    if( !SelectToStr( "Bet", "TableID", CMyStr( _nTableID ).c_str(), &vecData ) )        return false;    bet = vec2i( &vecData );    return true;}

void init(){    _log::init();    srand(time(0));    glfwSetErrorCallback(_glfwError);    glfwInit();    window::createWindow(vec2i(1024, 600), "123");    render::initRender();    glEnable(GL_LINE_SMOOTH);}

void cWorld::unloadAll(){	for (int y = 0; y < LIMIT_MAP; y++)	{		for (int x = 0; x < LIMIT_MAP; x++)		{			if (map[x][y].isLoaded) {				unloadChunk(vec2i(x, y));			}		}	}}