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

//==== Scale Bounding Box ====//void BndBox::Scale( const vec3d & scale_xyz ){    vec3d center = GetCenter();    for ( int i = 0 ; i < 3 ; i++ )    {        m_Min[i] = center[i] + ( m_Min[i] - center[i] ) * scale_xyz[i];        m_Max[i] = center[i] + ( m_Max[i] - center[i] ) * scale_xyz[i];    }}

SuperPill* GOFactory::CreateSuperPill(Tile* p_tile, GameStats* p_gameStats){	fVector3 pos = GetCenter(p_tile, 0.19f); 	fVector2 size = GetScaledSize(p_tile, 1.5f);	SpriteInfo* spriteInfo = CreateSpriteInfo("../Textures/Item_SuperCheesy.png",		pos, size, NULL);	return new SuperPill(spriteInfo, p_tile, p_gameStats, CreateSoundInfo("../Sounds/use_power-up.wav",100));}

void EBox::MoveRel(float x, float y) {	_x += x;	_y += y;	_center = GetCenter();		for (int i=0; i<_vChilds.size(); i++) {		_vChilds[i]->MoveRel(x,y);	}}

void Item::RenderCollisionRegions(){	for(unsigned int i = 0; i < m_vpBoundingRegionList.size(); i++)	{		BoundingRegion* pRegion = m_vpBoundingRegionList[i];		m_pRenderer->PushMatrix();			m_pRenderer->TranslateWorldMatrix(GetCenter().x, GetCenter().y, GetCenter().z);			Matrix4x4 justParentRotation;			justParentRotation.SetRotation(DegToRad(m_rotation.x), DegToRad(m_rotation.y), DegToRad(m_rotation.z));			m_pRenderer->MultiplyWorldMatrix(justParentRotation);			m_pRenderer->ScaleWorldMatrix(m_renderScale, m_renderScale, m_renderScale);			pRegion->Render(m_pRenderer);		m_pRenderer->PopMatrix();	}}

void	Enemy_01_01::OnWipped(){	Enemy::OnWipped();	if (IsInScreen())	{		gm.AddObject(new EffectEnemyDead(GetCenter()));		dsMgr.playSound(rm.GetSoundBuffer(SOUND_ENEP));	}}

void Heroes::Redraw(Surface & dst, bool with_shadow) const{    const Point & mp = GetCenter();    const Interface::GameArea & gamearea = Interface::Basic::Get().GetGameArea();    s16 dx = gamearea.GetMapsPos().x + TILEWIDTH * (mp.x - gamearea.GetRectMaps().x);    s16 dy = gamearea.GetMapsPos().y + TILEWIDTH * (mp.y - gamearea.GetRectMaps().y);    Redraw(dst, dx, dy, with_shadow);}

void TMesh::Rotate(vector axis, float theta) {	vector center = GetCenter();	for (int vi = 0; vi < vertsN; vi++){	//vector d = center - axis;		verts[vi].rotatePoint(center, axis, theta);		normals[vi].rotateVector(axis, theta);	}	SetAABB();}

bool AABB::InsideOf(const Plane& n) const{	vec3 h = (Max - Min)*.5f;	vec3 pn(fabs(n.a), fabs(n.b), fabs(n.c));	float e = Dot(h, pn);	float s = Dot(GetCenter(), n) + n.d;	if(s-e > 0) return true;	if(s+e < 0) return false;	return true;}

BOOL Bounds::LineIntersection(const Vect &v1, const Vect &v2, float &fT) const{    float tMax = M_INFINITE;    float tMin = -M_INFINITE;    Vect rayVect = (v2-v1);    float rayLength = rayVect.Len();    Vect rayDir = rayVect*(1.0f/rayLength);    Vect center = GetCenter();    Vect E = Max-center;    Vect T = center-v1;    for(int i=0; i<3; i++)    {        float e = T.ptr[i];        float f = rayDir.ptr[i];        float fI = 1.0f/f;        if(fabs(f) > 0.0f)        {            float t1 = (e+E.ptr[i])*fI;            float t2 = (e-E.ptr[i])*fI;            if(t1 > t2)            {                if(t2 > tMin) tMin = t2;                if(t1 < tMax) tMax = t1;            }            else            {                if(t1 > tMin) tMin = t1;                if(t2 < tMax) tMax = t2;            }            if(tMin > tMax) return FALSE;            if(tMax < 0.0f) return FALSE;        }        else if( ((-e - E.ptr[i]) > 0.0f) ||                 ((-e + E.ptr[i]) < 0.0f) )        {            return FALSE;        }        if(tMin > rayLength) return FALSE;    }    if(tMin > 0.0f)    {        fT = (tMin/rayLength);        return TRUE;    }    else    {        fT = (tMax/rayLength);        return TRUE;     }}

void Heroes::FadeIn(void) const{    const Point & mp = GetCenter();    const Interface::GameArea & gamearea = Interface::Basic::Get().GetGameArea();    if(!(gamearea.GetRectMaps() & mp)) return;    Display & display = Display::Get();    bool reflect = ReflectSprite(direction);    s32 dx = gamearea.GetMapsPos().x + TILEWIDTH * (mp.x - gamearea.GetRectMaps().x);    s32 dy = gamearea.GetMapsPos().y + TILEWIDTH * (mp.y - gamearea.GetRectMaps().y);    const Sprite & sprite1 = SpriteHero(*this, sprite_index, reflect, false);    Point dst_pt1(dx + (reflect ? TILEWIDTH - sprite1.x() - sprite1.w() : sprite1.x()), dy + sprite1.y() + TILEWIDTH);    const Rect src_rt = gamearea.RectFixed(dst_pt1, sprite1.w(), sprite1.h());    LocalEvent & le = LocalEvent::Get();    int alpha = 0;    while(le.HandleEvents() && alpha < 250)    {        if(Game::AnimateInfrequentDelay(Game::HEROES_FADE_DELAY))        {            Cursor::Get().Hide();	    for(s32 y = mp.y - 1; y <= mp.y + 1; ++y)		for(s32 x = mp.x - 1; x <= mp.x + 1; ++x)    		    if(Maps::isValidAbsPoint(x, y))	    {        	const Maps::Tiles & tile = world.GetTiles(Maps::GetIndexFromAbsPoint(x, y));        	tile.RedrawTile(display);        	tile.RedrawBottom(display);        	tile.RedrawObjects(display);    	    }    	    sprite1.Blit(alpha, src_rt, dst_pt1, display);	    for(s32 y = mp.y - 1; y <= mp.y + 1; ++y)		for(s32 x = mp.x - 1; x <= mp.x + 1; ++x)    		    if(Maps::isValidAbsPoint(x, y))	    {        	const Maps::Tiles & tile = world.GetTiles(Maps::GetIndexFromAbsPoint(x, y));        	tile.RedrawTop(display);    	    }	    Cursor::Get().Show();	    display.Flip();            alpha += 10;        }    }}

VOID Bound::Merge( const Bound& Other ){    Sphere OtherSphere;    OtherSphere.Center = Other.GetCenter();    OtherSphere.Radius = Other.GetMaxRadius();    if( m_Type == Bound::No_Bound )    {        SetSphere( OtherSphere );        return;    }    Sphere ThisSphere;    if( m_Type != Bound::Sphere_Bound )    {        // convert this bound into a sphere        ThisSphere.Center = GetCenter();        ThisSphere.Radius = GetMaxRadius();    }    else    {        ThisSphere = GetSphere();    }    XMVECTOR vThisCenter = XMLoadFloat3( &ThisSphere.Center );    XMVECTOR vOtherCenter = XMLoadFloat3( &OtherSphere.Center );    XMVECTOR vThisToOther = XMVectorSubtract( vOtherCenter, vThisCenter );    XMVECTOR vDistance = XMVector3LengthEst( vThisToOther );    FLOAT fCombinedDiameter = XMVectorGetX( vDistance ) + ThisSphere.Radius + OtherSphere.Radius;    if( fCombinedDiameter <= ( ThisSphere.Radius * 2 ) )    {        SetSphere( ThisSphere );        return;    }    if( fCombinedDiameter <= ( OtherSphere.Radius * 2 ) )    {        SetSphere( OtherSphere );        return;    }    XMVECTOR vDirectionNorm = XMVector3Normalize( vThisToOther );    XMVECTOR vRadius = XMVectorSet( ThisSphere.Radius, OtherSphere.Radius, 0, 0 );    XMVECTOR vThisRadius = XMVectorSplatX( vRadius );    XMVECTOR vOtherRadius = XMVectorSplatY( vRadius );    XMVECTOR vCombinedDiameter = vThisRadius + vDistance + vOtherRadius;    XMVECTOR vMaxDiameter = XMVectorMax( vCombinedDiameter, vThisRadius * 2 );    vMaxDiameter = XMVectorMax( vMaxDiameter, vOtherRadius * 2 );    XMVECTOR vMaxRadius = vMaxDiameter * 0.5f;    ThisSphere.Radius = XMVectorGetX( vMaxRadius );    vMaxRadius -= vThisRadius;    XMVECTOR vCombinedCenter = vThisCenter + vMaxRadius * vDirectionNorm;    XMStoreFloat3( &ThisSphere.Center, vCombinedCenter );    SetSphere( ThisSphere );}

void ObjMine::Detection(){  uint current_time = GameTime::GetInstance()->ReadSec();  if (escape_time == 0) {    escape_time = current_time + static_cast<MineConfig&>(cfg).escape_time;    MSG_DEBUG("mine", "Initialize escape_time : %d", current_time);    return;  }  if (current_time < escape_time || animation)    return;  //MSG_DEBUG("mine", "Escape_time is finished : %d", current_time);  Double tmp = PIXEL_PER_METER*static_cast<MineConfig&>(cfg).detection_range;  int detection_range = tmp*tmp;  FOR_ALL_LIVING_CHARACTERS(team, character) {    if (GetCenter().SquareDistance(character->GetCenter()) < detection_range) {      Weapon::Message(Format(_("%s is next to a mine!"), character->GetName().c_str()));      StartTimeout();      return;    }  }  Double speed_detection = static_cast<MineConfig&>(cfg).speed_detection;  Double norm, angle;  FOR_EACH_OBJECT(it) {    PhysicalObj *obj = *it;    if (obj != this && GetName() != obj->GetName() &&        GetCenter().SquareDistance(obj->GetCenter()) < detection_range) {      obj->GetSpeed(norm, angle);      if (norm < speed_detection && norm > ZERO) {        MSG_DEBUG("mine", "norm: %s, speed_detection: %s",                  Double2str(norm).c_str(), Double2str(speed_detection).c_str());        StartTimeout();        return;      }    }  }}

 bool Ellipsoid::InEllipsoid(const NX::vector<float, 3> &point) const{     const NX::vector<float, 3> v = point - GetCenter();     const float lx = NX::Dot(v, GetAxisX());     const float ly = NX::Dot(v, GetAxisY());     const float lz = NX::Dot(v, GetAxisZ());     const float dx = lx / m_fSemiAxisX;     const float dy = ly / m_fSemiAxisY;     const float dz = lz / m_fSemiAxisZ;     return dx * dx + dy * dy + dz * dz <= kf1; }

int CPlayer::Damage(){	g_pResource->sndDamage.Play(0);	if(g_pConfig->effect)	{		g_effect.Add(new CEffect(&g_pResource->imgExplode1,GetCenter(),1,150));		g_effect.Add(new CEffect(&g_pResource->imgSmoke1,GetCenter(),2,140));	}	else	{		g_effect.Add(new CEffect(&g_pResource->imgExplode1,GetCenter(),0,150));	}	m_zanki--;	m_anmtime = 0;	m_state = 2;	if(m_zanki<0)		return 0;	return 1;}

//@cmember Set control window to foregroundHRESULT tomEdit::TxSetForegroundWindow() {    HWND host = GetCenter()->GetHost() ;    if (!SetForegroundWindow(host))    {        ::SetFocus(host);    }    return S_OK ;}

/***Handles the mouse move event*/void MyGraphicsView::mouseMoveEvent(QMouseEvent* event) {    if(!LastPanPoint.isNull()) {        //Get how much we panned        QPointF delta = mapToScene(LastPanPoint) - mapToScene(event->pos());        LastPanPoint = event->pos();        //Update the center ie. do the pan        SetCenter(GetCenter() + delta);    }}

void TMesh::ScaleToNewDiagonal(float newDiagonal) {    float oldDiagonal = (aabb->corners[1] - aabb->corners[0]).length();    float sf = newDiagonal / oldDiagonal;    V3 oldCenter = GetCenter();    Position(V3(0.0f, 0.0f, 0.0f));    Scale(sf);    Position(oldCenter);    SetAABB();}

bool OrientedBoxShape::Contains(const sf::Vector2f& Point)const{	AlignedBoxShape AlignedB(sf::Vector2f(0.0f, 0.0f), sf::Vector2f(GetHalfExtents().x * 2.0f, GetHalfExtents().y * 2.0f));	sf::Vector2f RotatedPoint = Point - GetCenter();	RotatedPoint = MathUtils::RotateVector(RotatedPoint, - GetRotation());	RotatedPoint = RotatedPoint + GetHalfExtents();	return AlignedB.Contains(RotatedPoint);}

void AABB::GetVertices(FloatDataAccessor & accessor) const{	Eigen::Vector3f vertices[8];	vertices[0] = GetCenter();	vertices[0][0] += GetExtent(0);	vertices[0][1] += GetExtent(1);	vertices[0][2] += GetExtent(2);	vertices[1] = GetCenter();	vertices[1][0] -= GetExtent(0);	vertices[1][1] += GetExtent(1);	vertices[1][2] += GetExtent(2);	vertices[2] = GetCenter();	vertices[2][0] -= GetExtent(0);	vertices[2][1] -= GetExtent(1);	vertices[2][2] += GetExtent(2);	vertices[3] = GetCenter();	vertices[3][0] += GetExtent(0);	vertices[3][1] -= GetExtent(1);	vertices[3][2] += GetExtent(2);	vertices[4] = GetCenter();	vertices[4][0] += GetExtent(0);	vertices[4][1] += GetExtent(1);	vertices[4][2] -= GetExtent(2);	vertices[5] = GetCenter();	vertices[5][0] += GetExtent(0);	vertices[5][1] -= GetExtent(1);	vertices[5][2] -= GetExtent(2);	vertices[6] = GetCenter();	vertices[6][0] -= GetExtent(0);	vertices[6][1] -= GetExtent(1);	vertices[6][2] -= GetExtent(2);	vertices[7] = GetCenter();	vertices[7][0] -= GetExtent(0);	vertices[7][1] += GetExtent(1);	vertices[7][2] -= GetExtent(2);	VEC3(accessor[0]) = vertices[0];	VEC3(accessor[1]) = vertices[1];	VEC3(accessor[2]) = vertices[2];	VEC3(accessor[3]) = vertices[3];	VEC3(accessor[4]) = vertices[4];	VEC3(accessor[5]) = vertices[5];	VEC3(accessor[6]) = vertices[6];	VEC3(accessor[7]) = vertices[7];}

CPlanet::CPlanet(){	spriteType_ = PLANET;		/* Imageresourcen manager */	CImageResource* imageResource = GetGameClass()->GetImgResource();		/* load pictures */	backgroundStatic_ = new sf::Sprite ( *imageResource->Get ( "images/planet/002.png" ) );	this->SetCenter ( backgroundStatic_->GetSize().x * 0.5, backgroundStatic_->GetSize().y * 0.5 );	backgroundStatic_->SetCenter ( GetCenter() );		shadow_ = new sf::Sprite ( *imageResource->Get ( "images/planet/shadow.png" ) );	shadow_->SetCenter ( GetCenter() );		cloud1_ = new sf::Sprite ( *imageResource->Get ( "images/planet/clouds_001.png" ) );	cloud1_->SetCenter ( GetCenter() );		cloud2_ = new sf::Sprite ( *imageResource->Get ( "images/planet/clouds_002.png" ) );	cloud2_->SetCenter ( GetCenter() );		atmosphere_ = new sf::Sprite ( *imageResource->Get ( "images/planet/atmosphere_001.png" ) );	atmosphere_->SetCenter ( GetCenter() );		/* Set color of planet TODO EXAMPLE DATA! */	planetColor_ = sf::Color ( 160, 220, 255, 255 );		backgroundStatic_->SetColor ( planetColor_ );	atmosphere_->SetColor ( planetColor_ );		/* Add to graphic list */	graphics_.Add ( backgroundStatic_ );	graphics_.Add ( atmosphere_ );	graphics_.Add ( cloud1_ );	graphics_.Add ( cloud2_ );	graphics_.Add ( shadow_ );		/* Set properties */	this->SetZoomFactor( 0.1 );	this->SetZoomLevel ( 0.2 );}

void Chunk::Render(){	if(visible_)	{		if(GFX->GetCamera()->GetFrustum()->SphereInFrustum(GetCenter(), chunkSize_/1.5f))		{			GFX->RenderMesh(meshID_, position_ );		}	}}

void CBBOX::Scale( float aScale ){    if( m_initialized == false )        return;    S3D_VERTEX scaleV  = S3D_VERTEX( aScale, aScale, aScale );    S3D_VERTEX centerV = GetCenter();    m_min = (m_min - centerV) * scaleV + centerV;    m_max = (m_max - centerV) * scaleV + centerV;}

void CSceneNodeAABB::Render() const{	if(!GetSingleton<CProgram>()->IsInWireFrameMode())	{		//glPushAttrib(GL_ALL_ATTRIB_BITS);		////glBegin();		//glEnable(GL_MAP2_VERTEX_3);		//vector3 r[4] = { 		//	m_aabb.first , 		//	vector3(m_aabb.first.x,m_aabb.second.y,m_aabb.first.z) ,		//	vector3(m_aabb.second.x,m_aabb.first.y,m_aabb.first.z) , 		//	vector3(m_aabb.second.x,m_aabb.second.y,m_aabb.first.z)		//};		//glMap2f( GL_MAP2_VERTEX_3,0.0f,1.0f,6,2,0.0f,1.0f,3,2,(GLfloat*)r);		//glMapGrid2f(10,0,1,20,0,1);		//glEvalMesh2(GL_FILL,0,10,0,20);		////glEnd();		//glPopAttrib();		vector3 dim(GetDim(m_aabb));		vector3 dx(dim.x,0,0);		vector3 dy(0,dim.y,0);		vector3 dz(0,0,dim.z);		unsigned int nx(dim.x*0.02+1);		unsigned int ny(dim.y*0.02+1);		unsigned int nz(dim.z*0.02+1);		DrawFace(m_aabb.first,dy,dx,ny,nx);		DrawFace(m_aabb.first,dx,dz,nx,nz);		DrawFace(m_aabb.first,dz,dy,nz,ny);		DrawFace(m_aabb.second,-dx,-dy,nx,ny);		DrawFace(m_aabb.second,-dy,-dz,ny,nz);		DrawFace(m_aabb.second,-dz,-dx,nz,nx);		return;	}	glPushAttrib(GL_TEXTURE_BIT);	glPushMatrix();	vector3 center(GetCenter(m_aabb)),dim(GetDim(m_aabb));	glTranslatef(center.x,center.y,center.z);	{		GLenum coord[2]={GL_S,GL_T};		for(int iCoord(0); iCoord<2; ++iCoord)		{			float f[4];			glGetTexGenfv(coord[iCoord],GL_OBJECT_PLANE,f);			f[0]*=dim.x*0.001f;			f[1]*=dim.y*0.001f;			f[2]*=dim.z*0.001f;			//f[2]*=1000;			glTexGenfv(coord[iCoord],GL_OBJECT_PLANE,f);		}	}	glScalef(dim.x,dim.y,dim.z);	glutSolidCube(1.0);	glPopMatrix();	glPopAttrib();}

Result PreResult2::GenerateFinalResult(storage::CountryInfoGetter const & infoGetter,                                       CategoriesHolder const * pCat,                                       set<uint32_t> const * pTypes, int8_t locale,                                       ReverseGeocoder const * coder) const{  string name = m_str;  if (coder && name.empty())  {    // Insert exact address (street and house number) instead of empty result name.    ReverseGeocoder::Address addr;    coder->GetNearbyAddress(GetCenter(), addr);    if (addr.GetDistance() == 0)      name = FormatStreetAndHouse(addr);  }  uint32_t const type = GetBestType(pTypes);  // Format full address only for suitable results.  string address;  if (coder)  {    address = GetRegionName(infoGetter, type);    if (ftypes::IsAddressObjectChecker::Instance()(m_types))    {      ReverseGeocoder::Address addr;      coder->GetNearbyAddress(GetCenter(), addr);      address = FormatFullAddress(addr, address);    }  }  switch (m_resultType)  {  case RESULT_FEATURE:  case RESULT_BUILDING:    return Result(m_id, GetCenter(), name, address, pCat->GetReadableFeatureType(type, locale),                  type, m_metadata);  default:    ASSERT_EQUAL(m_resultType, RESULT_LATLON, ());    return Result(GetCenter(), name, address);  }}

voidEllipseGeometry::Build (){	double rx = GetRadiusX ();	double ry = GetRadiusY ();	Point *pt = GetCenter ();	double x = pt ? pt->x : 0.0;	double y = pt ? pt->y : 0.0;		path = moon_path_renew (path, MOON_PATH_ELLIPSE_LENGTH);	moon_ellipse (path, x - rx, y - ry, rx * 2.0, ry * 2.0);}