//----------------------------------------------------------------------------
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);
}
}
//----------------------------------------------------------------------------
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 CurveCtrl::Select (bool select)
{
if (mSelected == select)
return;
if (mSelected)
{
APoint scale = mDragBox->LocalTransform.GetScale();
mDragBox->LocalTransform.SetScale(APoint(scale.X(), 1.0f, scale.Z()));
}
mSelected = select;
Float3 color = mCurve->GetCurveColor();
if (mSelected)
{
color = Float3::YELLOW;
APoint scale = mDragBox->LocalTransform.GetScale();
mDragBox->LocalTransform.SetScale(APoint(scale.X(), 1.5f, scale.Z()));
}
VertexBufferAccessor vba(mDragBox);
for (int i=0; i<vba.GetNumVertices(); i++)
{
vba.Color<Float3>(0, i) = color;
}
Renderer::UpdateAll(mDragBox->GetVertexBuffer());
OnCtrlChanged (false);
}
//----------------------------------------------------------------------------
void EditRenderView_TimeLine::FitViewToSelected()
{
CurveCtrl *ctrl = PX2_EDIT.GetTimeLineEdit()->GetSelectedCurveCtrl();
Camera *camera = mUIViewGrid->GetCamera();
CameraNode *cameraNode = mUIViewGrid->GetCameraNode();
if (!ctrl) return;
float inMin = Mathf::MAX_REAL;
float inMax = -Mathf::MAX_REAL;
PX2_EDIT.GetTimeLineEdit()->GetInRange(inMin, inMax);
float outMin = Mathf::MAX_REAL;
float outMax = -Mathf::MAX_REAL;
PX2_EDIT.GetTimeLineEdit()->GetOutRange(outMin, outMax);
float inLength = inMax - inMin;
float outLength = outMax - outMin;
if (inLength == 0.0f)
{
inLength = 10.0f;
}
if (outLength == 0.0f)
{
outLength = 10.0f;
}
float rightWidth = (float)mSize.Width - mLeftWidth;
float leftOverWidth = (float)mLeftWidth / (float)mSize.Width;
float allOverRight = (float)mSize.Width / rightWidth;
inLength *= allOverRight;
PX2_UNUSED(leftOverWidth);
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;
uMax = outLength / 2.0f * 1.5f;
uMin = -uMax;
camera->SetFrustum(dMin, dMax, uMin, uMax, rMin, rMax);
APoint camPos = camera->GetPosition();
APoint ctrPos = ctrl->GetOutVal();
camPos.X() = ctrPos.X();
camPos.Z() = ctrPos.Z();
mUIViewGrid->GetCameraNode()->LocalTransform.SetTranslate(camPos);
mUIViewGrid->GetCameraNode()->Update(GetTimeInSeconds(), 0.0f);
_RefreshGrid(true);
}
//----------------------------------------------------------------------------
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;
}
//----------------------------------------------------------------------------
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;
}
//----------------------------------------------------------------------------
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;
}
//----------------------------------------------------------------------------
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::_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 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);
}
}
//----------------------------------------------------------------------------
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::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();
}
}
}
//----------------------------------------------------------------------------
bool InputPushTransformController::TransScope(APoint &pos)
{
if (mMinPos.X() > mMaxPos.X() || mMinPos.Y() > mMaxPos.Y() ||
mMinPos.Z() > mMaxPos.Z() || mMinPos == mMaxPos)
{
return false;
}
if (mMinPos.X() > pos.X())
{
pos.X() = mMinPos.X();
mVelocity.X() = 0.0f;
}
if (mMinPos.Y() > pos.Y())
{
pos.Y() = mMinPos.Y();
mVelocity.Y() = 0.0f;
}
if (mMinPos.Z() > pos.Z())
{
pos.Z() = mMinPos.Z();
mVelocity.Z() = 0.0f;
}
if (pos.X() > mMaxPos.X())
{
pos.X() = mMaxPos.X();
mVelocity.X() = 0.0f;
}
if (pos.Y() > mMaxPos.Y())
{
pos.Y() = mMaxPos.Y();
mVelocity.Y() = 0.0f;
}
if (pos.Z() > mMaxPos.Z())
{
pos.Z() = mMaxPos.Z();
mVelocity.Z() = 0.0f;
}
return true;
}
//----------------------------------------------------------------------------
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 MovableTransProperty::OnChange (wxPropertyGridEvent &event)
{
if (!mProperty)
return;
wxPGProperty *id = event.GetProperty();
const wxString &name = event.GetPropertyName();
std::string stdName = std::string(name);
wxVariant variant = id->GetValue();
if (0 == id)
return;
if (variant.IsNull())
return;
APoint value;
if (mPropertyTranslate == id)
{
value = APointRefFromVariant(variant);
mTrans->SetTranslate(value);
}
else if (mPropertyRotation == id)
{
value = APointRefFromVariant(variant);
mTrans->SetRotate(Matrix3f().MakeEulerXYZ(
value.X(), value.Y(), value.Z()));
}
else if (mPropertyScale == id)
{
value = APointRefFromVariant(variant);
if (value.X()!=0.0f && value.Y()!=0.0f && value.Z()!=0.0f)
{
mTrans->SetScale(value);
}
}
Event *ent = 0;
ent = EditEventSpace::CreateEventX(EditEventSpace::ObjectTransformChanged);
ent->SetData<Object*>(mObject);
EventWorld::GetSingleton().BroadcastingLocalEvent(ent);
}
//----------------------------------------------------------------------------
void EU_CanvasStage::_MoveCamera(float horz, float vert)
{
if (!Project::GetSingletonPtr()) return;
Scene *scene = PX2_PROJ.GetScene();
if (!scene) return;
if (mStageCameraNode)
{
APoint position = mStageCameraNode->LocalTransform.GetTranslate();
AVector rVector;
AVector dVector;
AVector uVector;
mStageCameraNode->LocalTransform.GetRDUVector(rVector, dVector, uVector);
if (mViewType == VT_PERSPECTIVE)
{
dVector.Z() = 0.0f;
dVector.Normalize();
rVector.Z() = 0.0f;
rVector.Normalize();
position += dVector * vert;
position -= rVector * horz;
}
else if (mViewType == VT_TOP)
{
position.Y() += vert * 1.0f;
position.X() -= horz * 1.0f;
}
else if (mViewType == VT_LEFT)
{
position.Z() += vert * 1.0f;
position.Y() += horz * 1.0f;
}
else if (mViewType == VT_FRONT)
{
position.Z() += vert * 1.0f;
position.X() -= horz * 1.0f;
}
mStageCameraNode->LocalTransform.SetTranslate(position);
}
}
//----------------------------------------------------------------------------
void EditRenderView_Scene::_MoveCamera(float horz, float vert)
{
Scene *scene = PX2_PROJ.GetScene();
if (!scene) return;
CameraActor *camActor = scene->GetUseCameraActor();
if (camActor)
{
APoint position = camActor->LocalTransform.GetTranslate();
AVector rVector;
AVector dVector;
AVector uVector;
camActor->GetRDUVector(rVector, dVector, uVector);
if (mViewType == VT_PERSPECTIVE)
{
dVector.Z() = 0.0f;
dVector.Normalize();
rVector.Z() = 0.0f;
rVector.Normalize();
position += dVector * vert;
position -= rVector * horz;
}
else if (mViewType == VT_TOP)
{
position.Y() += vert * 1.0f;
position.X() -= horz * 1.0f;
}
else if (mViewType == VT_LEFT)
{
position.Z() += vert * 1.0f;
position.Y() += horz * 1.0f;
}
else if (mViewType == VT_FRONT)
{
position.Z() += vert * 1.0f;
position.X() -= horz * 1.0f;
}
camActor->LocalTransform.SetTranslate(position);
}
}
//----------------------------------------------------------------------------
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);
}
//----------------------------------------------------------------------------
void Actor::SetRotation (APoint &rolate)
{
mRotation = rolate;
if (mMovable)
{
mMovable->LocalTransform.SetRotate(Matrix3f().MakeEulerXYZ(
rolate.X(), rolate.Y(), rolate.Z()));
}
}
//----------------------------------------------------------------------------
void Actor::SetRotation (const APoint &rolate)
{
if (rolate == mRotation)
return;
mRotation = rolate;
if (mMovable)
{
mMovable->LocalTransform.SetRotate(Matrix3f().MakeEulerXYZ(
rolate.X(), rolate.Y(), rolate.Z()));
}
if (mHelpMovable)
{
mHelpMovable->LocalTransform.SetRotate(Matrix3f().MakeEulerXYZ(
rolate.X(), rolate.Y(), rolate.Z()));
}
}
//-----------------------------------------------------------------------------
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()));
}
//----------------------------------------------------------------------------
AVector InputPushTransformController::GetSmallTransDir()
{
Movable *movable = DynamicCast<Movable>(mObject);
if (!movable)
AVector::ZERO;
APoint curPos = movable->LocalTransform.GetTranslate();
AVector moveDir = AVector::ZERO;
if (curPos.X() < mMinPosSmall.X())
{
moveDir.X() = mMinPosSmall.X() - curPos.X();
}
if (curPos.Y() < mMinPosSmall.Y())
{
moveDir.Y() = mMinPosSmall.Y() - curPos.Y();
}
if (curPos.Z() < mMinPosSmall.Z())
{
moveDir.Z() = mMinPosSmall.Z() - curPos.Z();
}
if (curPos.X()>mMaxPosSmall.X())
{
moveDir.X() = mMaxPosSmall.X() - curPos.X();
}
if (curPos.Y() > mMaxPosSmall.Y())
{
moveDir.Y() = mMaxPosSmall.Y() - curPos.Y();
}
if (curPos.Z() > mMaxPosSmall.Z())
{
moveDir.Z() = mMaxPosSmall.Z() - curPos.Z();
}
return moveDir;
}
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 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;
}
