自学教程：C++ APoint类代码示例

//----------------------------------------------------------------------------Vector2f RenderStep::PointWorldToViewPort(const APoint &point,	bool *isInBack){	Rectf viewPort = mViewPort;	if (viewPort.IsEmpty())		viewPort = Rectf(0.0f, 0.0f, mSize.Width, mSize.Height);	HMatrix matProjView = mCamera->GetProjectionMatrix() * mCamera->GetViewMatrix();	HPoint hPoint(point.X(), point.Y(), point.Z(), point.W());	HPoint tempPoint = matProjView * hPoint;	if (isInBack)	{		if (tempPoint.Z() <= 0)			*isInBack = true;		else			*isInBack = false;	}	float wInv = 1.0f / tempPoint.W();	//投影坐标范围为[-1,1]要变成[0,1]	Vector2f screenPoint;	screenPoint.X() = (1.0f + tempPoint.X()*wInv) / 2.0f;	screenPoint.Y() = (1.0f + tempPoint.Y()*wInv) / 2.0f;	//投影坐标范围为[0,1]要变成视口内坐标	screenPoint.X() = viewPort.Left + screenPoint.X()*viewPort.Width();	screenPoint.Y() = viewPort.Bottom + screenPoint.Y()*viewPort.Height();	return screenPoint;}

//----------------------------------------------------------------------------void EU_CanvasStage::OnLeftUp(const APoint &worldPos){	if (!IsEnable())		return;	const Rectf &rectWorld = GetWorldRect();	if (!rectWorld.IsInsize(worldPos.X(), worldPos.Z()))		return;	UICanvas::OnLeftUp(worldPos);	if (IsCameraDraging())	{		SetCameraDraging(false);	}	else	{		Camera *camera = mSceneNodeCtrlCanvas->GetOverCamera();		if (mSceneNodeCtrl)			mSceneNodeCtrl->OnLeftUp(camera, worldPos, GetSize());		Edit::EditMode em = PX2_EDIT.GetEditMode();		if ((Edit::EM_TRANSLATE == em || Edit::EM_ROTATE == em			|| Edit::EM_SCALE == em) && mIsSelectMovableTransChanged)		{			PX2_URDOM.PushUnDo(mURDoCommand);			mIsSelectMovableTransChanged = false;		}	}}

//----------------------------------------------------------------------------void EditRenderView_TimeLine::_TrySelectCurveCtrlPoint(const APoint &pos){	APoint origin;	AVector direction;	mRenderStep->GetPickRay(pos.X(), pos.Z(), origin, direction);	Node *gridNode = PX2_EDIT.GetTimeLineEdit()->GetCurveEditNode_Grid();	Picker picker;	picker.Execute(gridNode, origin, direction, 0.0f, Mathf::MAX_REAL);	if ((int)(picker.Records.size()) > 0)	{		Movable *mov = picker.GetClosestNonnegative().Intersected;		CurveCtrl *ctrl = PX2_EDIT.GetTimeLineEdit()->TrySelectCurve(mov);		if (ctrl)		{			//UnToggleAllInterps();			//EnableInterps(true);			//ToggleInterp(ctrl->GetInterpCurveMode());			PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(ctrl);		}		else		{			PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(0);		}	}	else	{		PX2_EDIT.GetTimeLineEdit()->SetSelectedCurveCtrl(0);	}}

//----------------------------------------------------------------------------void EditRenderView_TimeLine::OnLeftDClick(const APoint &pos){	EditRenderView::OnLeftDClick(pos);	Rectf rect(0, 0, mLeftWidth, mSize.Height);	bool leftContain = rect.IsInsize(Float2(pos.X(), pos.Z()));	bool isCtrlDown = PX2_EDIT.IsCtrlDown;	if (!leftContain && isCtrlDown)	{		UICurveGroup *uiCurveGroup = PX2_EDIT.GetTimeLineEdit()->GetSelectedUICurveGroup();		if (!uiCurveGroup) return;		Camera *camera = PX2_EDIT.GetTimeLineEdit()->GetTimeLineRenderStep_Grid()->GetCamera();		APoint camPos = camera->GetPosition();		Vector2f camScreenPos = mUIViewGrid->PointWorldToViewPort(camPos);		float xDissCam = pos.X() - camScreenPos.X();		float zDissCam = pos.Z() - camScreenPos.Y();		float xDissCamReal = xDissCam / mPixelOverCamIn;		float zDissCamReal = zDissCam / mPixelOverCamOut;		APoint pointPos = camPos + AVector(xDissCamReal, 0.0f, zDissCamReal);		CurveGroup *curveGroup = uiCurveGroup->GetCurveGroup();		curveGroup->AddPoint(pointPos);	}}

//----------------------------------------------------------------------------void EU_CanvasStage::_UpdateBrushPos(const APoint &scrPos){	Project *proj = Project::GetSingletonPtr();	if (!proj) return;	Scene *scene = proj->GetScene();	if (!scene) return;	Terrain *terrain = scene->GetTerrain();	if (!terrain) return;	Movable *pickObject = terrain;#ifdef _DEBUG	pickObject = PX2_GR.GetXYPlane();	pickObject->WorldTransform.SetTranslate(APoint::ORIGIN);#endif	Camera *camera = mStageCameraNode->GetCamera();	APoint origin;	AVector direction;	camera->GetPickRay(scrPos.X(), scrPos.Z(), GetSize(), origin, direction);	Picker picker;	picker.Execute(pickObject, origin, direction, 0.0f, Mathf::MAX_REAL);	if ((int)picker.Records.size() > 0)	{		PX2::PickRecord pickRecord = picker.GetClosestToZero();		PX2::APoint dest = origin + direction*pickRecord.T;		PX2_EDIT.GetTerrainEdit()->GetBrush()->SetPos(dest);	}}

//----------------------------------------------------------------------------void ApplicationBase::OnProjectSize (int width, int height){	mUIManager->GetDefaultView()->SetSize((float)width, (float)height);	APoint curPos = mUIManager->GetDefaultView()->GetCamera()->GetPosition();	mUIManager->GetDefaultView()->GetCamera()->SetPosition(APoint((float)width/2.0f, 		curPos.Y(), (float)height/2.0f));}

//----------------------------------------------------------------------------Vector2f Renderer::PointWorldToViewPort (const  APoint &point, bool *isInBack){	HMatrix matProjView = GetProjectionMatrix() * GetViewMatrix();	HPoint hPoint(point.X(), point.Y(), point.Z(), point.W());	HPoint tempPoint = matProjView * hPoint;	if (isInBack)	{		if (tempPoint.Z() <= 0)			*isInBack = true;		else			*isInBack = false;	}	float wInv = 1.0f / tempPoint.W();	//投影坐标范围为[-1,1]要变成[0,1]	Vector2f screenPoint;	screenPoint.X() = (1.0f + tempPoint.X()*wInv)/2.0f;	screenPoint.Y() = (1.0f + tempPoint.Y()*wInv)/2.0f;	//投影坐标范围为[0,1]要变成视口内坐标	int viewX, viewY, viewW, viewH;	GetViewport(viewX, viewY, viewW, viewH);	screenPoint.X() = viewX + screenPoint.X()*viewW;	screenPoint.Y() = viewY + screenPoint.Y()*viewH;	return screenPoint;}

//----------------------------------------------------------------------------void EU_CanvasStage::OnRightUp(const APoint &worldPos){	if (!IsEnable())		return;	const Rectf &rectWorld = GetWorldRect();	if (!rectWorld.IsInsize(worldPos.X(), worldPos.Z()))		return;	Project *proj = Project::GetSingletonPtr();	if (!proj)		return;	if (IsCameraDraging())	{		SetCameraDraging(false);	}	else	{		if (mIsRightPressed)		{			CreateMenuOnSelect(worldPos);		}	}	UICanvas::OnRightUp(worldPos);}

//----------------------------------------------------------------------------void EditRenderView_Scene::_ClickSelectPos(const APoint &scrPos){	Scene *scene = PX2_PROJ.GetScene();	RenderStep *renderStep = PX2_PROJ.GetSceneRenderStep();	APoint origin;	AVector direction;	renderStep->GetPickRay(scrPos.X(), scrPos.Z(), origin, direction);	ActorPicker actorPicker;	actorPicker.Execute(scene, origin, direction, 0.0f, Mathf::MAX_REAL);	if (actorPicker.Records.size() > 0)	{		const ActorPickRecord &record = actorPicker.GetClosestToZero();		mSelectPoint = origin + direction*record.T;		PX2_EDIT.SetPickPos(mSelectPoint);	}	else	{		PX2::TriMesh *xyPlane = PX2_GR.GetXYPlane();		xyPlane->WorldTransform.SetTranslate(APoint::ORIGIN);		Picker picker;		picker.Execute(xyPlane, origin, direction, 0.0f, Mathf::MAX_REAL);		if ((int)picker.Records.size() > 0)		{			const PickRecord &rec = picker.GetClosestToZero();			mSelectPoint = origin + direction*rec.T;			PX2_EDIT.SetPickPos(mSelectPoint);		}	}}

//----------------------------------------------------------------------------void EU_CanvasStage::_ClickSelectScene(const APoint &scrPos){	if (!Project::GetSingletonPtr()) return;	Scene *scene = PX2_PROJ.GetScene();	if (!scene) return;	SelectMode mode = SM_SINGLE;	if (PX2_EDIT.IsCtrlDown) mode = SM_MULTI;		Camera *camera = mStageCameraNode->GetCamera();	APoint origin;	AVector direction;	camera->GetPickRay(scrPos.X(), scrPos.Z(), GetSize(), origin, direction);	Picker picker;	picker.Execute(scene, origin, direction, 0.0f, Mathf::MAX_REAL);	if ((int)picker.Records.size() > 0)	{		const PickRecord &record = picker.GetClosestToZero();		Object *recordObj = record.Intersected;		mSelectPoint = origin + direction*record.T;		PX2_EDIT.SetPickPos(mSelectPoint);		if (SM_SINGLE == mode)		{			int numObjs = PX2_SELECTM_E->GetNumObjects();			if (1 == numObjs && recordObj == PX2_SELECTM_E->GetFirstObject())			{				PX2_SELECTM_E->Clear();			}			else			{				PX2_SELECTM_E->Clear();				PX2_SELECTM_E->AddObject(recordObj);			}		}		else if (SM_MULTI == mode)		{			if (PX2_SELECTM_E->IsObjectIn(recordObj))			{				PX2_SELECTM_E->RemoveObject(recordObj);			}			else			{				PX2_SELECTM_E->AddObject(recordObj);			}		}	}	else	{		if (SM_SINGLE == mode)		{			PX2_SELECTM_E->Clear();		}	}}

//----------------------------------------------------------------------------void Actor::SetRotation (APoint &rolate){	mRotation = rolate;	if (mMovable)	{		mMovable->LocalTransform.SetRotate(Matrix3f().MakeEulerXYZ(			rolate.X(), rolate.Y(), rolate.Z()));	}}

//----------------------------------------------------------------------------APoint SizeNode::WorldPosToViewPortPos(const APoint &worldPos){	Rectf worldRect = GetWorldRect();	APoint viewPortPos;	viewPortPos.X() = worldPos.X() - worldRect.Left;	viewPortPos.Z() = worldPos.Z() - worldRect.Bottom;	return viewPortPos;}

//-----------------------------------------------------------------------------wxAPoint3Property::wxAPoint3Property (const wxString &label, const wxString &name,									  const APoint &value)									  :wxPGProperty(label, name){	SetValue(APointToVariant(value));	AddPrivateChild(new wxFloatProperty(wxT("X"),wxPG_LABEL,value.X()));	AddPrivateChild(new wxFloatProperty(wxT("Y"),wxPG_LABEL,value.Y()));	AddPrivateChild(new wxFloatProperty(wxT("Z"),wxPG_LABEL,value.Z()));}

//----------------------------------------------------------------------------void FMODSound::SetPosition (const APoint &position){    FMOD_VECTOR pos;    pos.x = position.X();    pos.y = position.Y();    pos.z = position.Z();    if (mChannel)        mChannel->set3DAttributes(&pos, 0);}

//----------------------------------------------------------------------------Rectf SizeNode::GetWorldRect() const{	Rectf rect = GetLocalRect();	const APoint worldPos = WorldTransform.GetTranslate();	rect.Left += worldPos.X();	rect.Right += worldPos.X();	rect.Bottom += worldPos.Z();	rect.Top += worldPos.Z();	return rect;}

MovableTransProperty::MovableTransProperty (PropertyPage *parent, 	const std::string &name, const std::string &tag,	Transform *trans, Object *obj)	:Property(parent, name, tag, Property::PT_TRANSFORM, 0),	mIsRSMatrix(0),	mPropertyTranslate(0),	mPropertyRotation(0),	mPropertyScale(0),	mPropertyIsUniformScale(0),	mTrans(trans),	mObject(obj){	APoint position;	APoint rotation;	APoint scale(1.0f, 1.0f, 1.0f);	bool isRSMatrix = mTrans->IsRSMatrix();	if (isRSMatrix)	{		position = mTrans->GetTranslate();		Matrix3f mat = mTrans->GetRotate();		mat.ExtractEulerXYZ(rotation.X(), rotation.Y(), rotation.Z());		scale = mTrans->GetScale();		bool isUniformScale = mTrans->IsUniformScale();		mProperty = parent->mPage->Append(new wxStringProperty(			name, tag, wxT("<composed>")) );		mPropertyTranslate = parent->mPage->AppendIn(mProperty, 			new wxAPoint3Property("Translate", tag+"Translate",			position));		mPropertyRotation = parent->mPage->AppendIn(mProperty, 			new wxAPoint3Property("Rotate", tag+"Rotate", rotation));		mPropertyScale = parent->mPage->AppendIn(mProperty, 			new wxAPoint3Property("Scale", tag+"Scale", scale));		mPropertyIsUniformScale = parent->mPage->AppendIn(mProperty, 			new wxBoolProperty("IsUniformScale", tag+"IsUniformScale", isUniformScale));		mPropertyIsUniformScale->Enable(false);	}	else	{		mProperty = parent->mPage->Append(new wxStringProperty(			name, tag, wxT("<composed>")) );		mIsRSMatrix = parent->mPage->AppendIn(mProperty, 			new wxBoolProperty("IsRSMatrix", tag+"IsRSMatrix", false));		mIsRSMatrix->Enable(false);	}}

//----------------------------------------------------------------------------void EU_CanvasStage::OnRightDown(const APoint &worldPos){	if (!IsEnable())		return;	const Rectf &rectWorld = GetWorldRect();	if (!rectWorld.IsInsize(worldPos.X(), worldPos.Z()))		return;	UICanvas::OnRightDown(worldPos);	APoint viewPortPos = WorldPosToViewPortPos(worldPos);	_ClickSelectPos(viewPortPos);}

//----------------------------------------------------------------------------void Terrain::AddJunglers (Texture2D *tex, APoint center, float radius,	int num, float width, float height, float lower){	if (!tex)		return;	for (int i=0; i<mNumRows; i++)	{		for (int j=0; j<mNumCols; j++)		{			GetPage(i, j)->mAddingJObjs.clear();		}	}	for (int i=0; i<num; i++)	{		float unitRadius = Mathf::UnitRandom();		float fX0 = Mathf::SymmetricRandom();		float fY0 = Mathf::SymmetricRandom();		AVector normal0(fX0, fY0, 0.0f);		normal0.Normalize();		float fX1 = Mathf::SymmetricRandom();		float fY1 = Mathf::SymmetricRandom();		AVector normal1(fX1, fY1, 0.0f);		normal1.Normalize();		APoint pos = center + normal0*unitRadius*radius;		pos.Z() = GetHeight(pos.X(), pos.Y()) - lower;		JObj obj;		obj.Pos = pos;		obj.Normal = normal1;		obj.Width = width;		obj.Height = height;		TerrainPage *page = GetCurrentPage(obj.Pos.X(), obj.Pos.Y());		page->mAddingJObjs.push_back(obj);	}	for (int i=0; i<mNumRows; i++)	{		for (int j=0; j<mNumCols; j++)		{			TerrainPage *page = GetPage(i, j);			page->AddJunglers(tex, page->mAddingJObjs);		}	}}

//----------------------------------------------------------------------------int UIGridFrame::_UpdateAlignItems(){	int numValidChild = 0;	for (int i = 0; i < GetNumChildren(); i++)	{		Movable *mov = GetChild(i);		if (mov)		{			APoint pos;			if (ATT_SIZE_WIDTH == mAlignItemType)			{				int numWidth = (int)((mSize.Width - mBorderSize.Width*2.0f) / mItemSize.Width);				if (0 == numWidth)					numWidth = 1;				int xIndex = numValidChild % numWidth;				int zIndex = numValidChild / numWidth;				pos.X() = mBorderSize.Width + mItemSize.Width / 2.0f + mItemSize.Width*xIndex;				pos.Z() = mSize.Height - mBorderSize.Height - mItemSize.Height / 2.0f - mItemSize.Height*zIndex;			}			else if (ATT_NUM_WIDTH == mAlignItemType)			{				assertion(0.0f != mAlignItemNum[0], "");				assertion(0.0f != mAlignItemNum[1], "");				mItemSize.Width = (mSize.Width - mBorderSize.Width*2.0f) / mAlignItemNum[0];				mItemSize.Height = (mSize.Height - mBorderSize.Height*2.0f) / mAlignItemNum[1];				int numWidth = (int)mAlignItemNum[0];				int xIndex = numValidChild%numWidth;				int zIndex = numValidChild / numWidth;				pos.X() = mBorderSize.Width + mItemSize.Width / 2.0f + mItemSize.Width*xIndex;				pos.Z() = mSize.Height - mBorderSize.Height - mItemSize.Height / 2.0f - mItemSize.Height*zIndex;			}			mov->LocalTransform.SetTranslate(pos);			numValidChild++;		}	}	return numValidChild;}

//----------------------------------------------------------------------------void HMatrix::MakePerspectiveProjection (const APoint& origin,    const AVector& normal, const APoint& eye){    //     +-                                                 -+    // M = | Dot(N,E-P)*I - E*N^T    -(Dot(N,E-P)*I - E*N^T)*E |    //     |        -N^t                      Dot(N,E)         |    //     +-                                                 -+    //    // where E is the eye point, P is a point on the plane, and N is a    // unit-length plane normal.    float dotND = normal.Dot(eye - origin);    mEntry[ 0] = dotND - eye[0]*normal[0];    mEntry[ 1] = -eye[0]*normal[1];    mEntry[ 2] = -eye[0]*normal[2];    mEntry[ 3] = -(mEntry[0]*eye[0] + mEntry[1]*eye[1] + mEntry[2]*eye[2]);    mEntry[ 4] = -eye[1]*normal[0];    mEntry[ 5] = dotND - eye[1]*normal[1];    mEntry[ 6] = -eye[1]*normal[2];    mEntry[ 7] = -(mEntry[4]*eye[0] + mEntry[5]*eye[1] + mEntry[6]*eye[2]);    mEntry[ 8] = -eye[2]*normal[0];    mEntry[ 9] = -eye[2]*normal[1];    mEntry[10] = dotND- eye[2]*normal[2];    mEntry[11] = -(mEntry[8]*eye[0] + mEntry[9]*eye[1] + mEntry[10]*eye[2]);    mEntry[12] = -normal[0];    mEntry[13] = -normal[1];    mEntry[14] = -normal[2];    mEntry[15] = eye.Dot(normal);}

//-----------------------------------------------------------------------------int CellSpace::PositionToIndex(const APoint &pos) const{	float posA = pos.X();	float posB = pos.Y();	int index = (int)(posA / mCellLength) +		((int)(posB / mCellWidth) * mNumCellsLength);	if (index > (int)mCells.size() - 1)		index = (int)mCells.size() - 1;	if (index < 0)		index = 0;	return index;}

//----------------------------------------------------------------------------void HMatrix::MakeReflection (const APoint& origin, const AVector& normal){    //     +-                         -+    // M = | I-2*N*N^T    2*Dot(N,P)*N |    //     |     0^T            1      |    //     +-                         -+    //    // where P is a point on the plane and N is a unit-length plane normal.    float twoDotNO = 2.0f*origin.Dot(normal);    mEntry[ 0] = 1.0f - 2.0f*normal[0]*normal[0];    mEntry[ 1] = -2.0f*normal[0]*normal[1];    mEntry[ 2] = -2.0f*normal[0]*normal[2];    mEntry[ 3] = twoDotNO*normal[0];    mEntry[ 4] = -2.0f*normal[1]*normal[0];    mEntry[ 5] = 1.0f - 2.0f*normal[1]*normal[1];    mEntry[ 6] = -2.0f*normal[1]*normal[2];    mEntry[ 7] = twoDotNO*normal[1];    mEntry[ 8] = -2.0f*normal[2]*normal[0];    mEntry[ 9] = -2.0f*normal[2]*normal[1];    mEntry[10] = 1.0f - 2.0f*normal[2]*normal[2];    mEntry[11] = twoDotNO*normal[2];    mEntry[12] = 0.0f;    mEntry[13] = 0.0f;    mEntry[14] = 0.0f;    mEntry[15] = 1.0f;}

//----------------------------------------------------------------------------HPlane::HPlane (const AVector& normal, const APoint& p){	mTuple[0] = normal[0];	mTuple[1] = normal[1];	mTuple[2] = normal[2];	mTuple[3] = -p.Dot(normal);}

//----------------------------------------------------------------------------bool TriggerActor::IsPointIn(const PX2::APoint &point) const{	Transform trans = WorldTransform;	APoint localPoint = trans.Inverse() * point;	if (mAreaType == AT_SPHERE)	{		Sphere3f sphere;		sphere.Radius = mAreaParam[0];		if (InSphere<float>(localPoint, sphere))			return true;	}	else if (mAreaType == AT_BOX)	{		Box3f box;		box.Extent[0] = mAreaParam[0];		box.Extent[1] = mAreaParam[1];		box.Extent[2] = mAreaParam[2];		if (localPoint.X() >= -box.Extent[0] &&			localPoint.Y() >= -box.Extent[1] &&			localPoint.Z() >= -box.Extent[2] &&			localPoint.X() <= box.Extent[0] &&			localPoint.Y() <= box.Extent[1] &&			localPoint.Z() <= box.Extent[2])			return true;	}	return false;}

//----------------------------------------------------------------------------void EditRenderView_TimeLine::FitViewHorizontally(){	if (!mRenderStep) return;	Camera *camera = mRenderStep->GetCamera();	float inMin = Mathf::MAX_REAL;	float inMax = -Mathf::MAX_REAL;	PX2_EDIT.GetTimeLineEdit()->GetInRange(inMin, inMax);	float inLength = inMax - inMin;	bool inLenghtZero = false;	if (inLength == 0.0f)	{		inLength = 10.0f;		inLenghtZero = true;	}	float rightWidth = (float)mSize.Width - mLeftWidth;	float leftOverWidth = (float)mLeftWidth / (float)mSize.Width;	float allOverRight = (float)mSize.Width / rightWidth;	inLength *= allOverRight;	float dMin = 0.0f;	float dMax = 0.0f;	float uMin = 0.0f;	float uMax = 0.0f;	float rMin = 0.0f;	float rMax = 0.0f;	camera->GetFrustum(dMin, dMax, uMin, uMax, rMin, rMax);	rMax = inLength / 2.0f * 1.5f;	rMin = -rMax;	camera->SetFrustum(dMin, dMax, uMin, uMax, rMin, rMax);	APoint pos = camera->GetPosition();	if (inLenghtZero)		pos.X() = inMin;	else		pos.X() = inMin + inLength / 2.0f - inLength*leftOverWidth;	mUIViewGrid->GetCameraNode()->LocalTransform.SetTranslate(pos);	mUIViewGrid->GetCameraNode()->Update(GetTimeInSeconds(), 0.0f);	_RefreshGrid(true);}

//----------------------------------------------------------------------------void Transform::SetScale (const APoint& scale){	if (scale.X()==scale.Y() && scale.Y()==scale.Z())	{		SetUniformScale(scale.X());	}	else	{		assertion(mIsRSMatrix, "Matrix is not a rotation/n");		assertion(scale[0] != 0.0f && scale[1] != 0.0f && scale[2] != 0.0f,			"Scales must be nonzero/n");		mScale = scale;		mIsIdentity = false;		mIsUniformScale = false;		UpdateHMatrix();	}}

//----------------------------------------------------------------------------void E_MainFrame::TimeLine_SelectCtrl_OutValue(){	CurveCtrl *ctrl = PX2_EDIT.GetTimeLineEdit()->GetSelectedCurveCtrl();	if (!ctrl) return;	DlgSetCurveVal dlg(mTimeLineView);	dlg.SetVal(ctrl->GetOutVal().Z());	dlg.SetTitle(PX2_LM.GetValue("SetOutValue"));	dlg.SetLabel(PX2_LM.GetValue("NewOutValue"));	if (dlg.ShowModal() == wxID_OK)	{		float val = dlg.GetVal();		APoint outVal = ctrl->GetOutVal();		outVal.Z() = val;		ctrl->SetOutVal(outVal);	}}

//----------------------------------------------------------------------------void EU_CanvasStage::OnMouseWheel(const APoint &worldPos, float delta){	if (!IsEnable())		return;	const Rectf &rectWorld = GetWorldRect();	if (!rectWorld.IsInsize(worldPos.X(), worldPos.Z()))		return;	UICanvas::OnMouseWheel(worldPos, delta);	float delta1 = delta * 0.003f * PX2_EDIT.GetCameraMoveSpeed();	_ZoomCamera(delta1);	if (mSceneNodeCtrl)	{		Camera *camera = mSceneNodeCtrlCanvas->GetOverCamera();		mSceneNodeCtrl->OnMouseWheel(camera, delta1, GetSize());	}}