//---------------------------------------------------------------------------- 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; }
//---------------------------------------------------------------------------- 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 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::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 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); } }
//---------------------------------------------------------------------------- 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::_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 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; }
//---------------------------------------------------------------------------- void EditRenderView_TimeLine::FitViewVertically() { if (!mRenderStep) return; Camera *camera = mRenderStep->GetCamera(); float outMin = Mathf::MAX_REAL; float outMax = -Mathf::MAX_REAL; PX2_EDIT.GetTimeLineEdit()->GetOutRange(outMin, outMax); float outLength = outMax - outMin; bool outLenghtZero = false; if (outLength == 0.0f) { outLength = 10.0f; outLenghtZero = true; } 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); uMax = outLength / 2.0f * 1.5f; uMin = -uMax; camera->SetFrustum(dMin, dMax, uMin, uMax, rMin, rMax); APoint pos = camera->GetPosition(); if (outLenghtZero) pos.Z() = outMin; else pos.Z() = outMin + outLength / 2.0f; mUIViewGrid->GetCameraNode()->LocalTransform.SetTranslate(pos); mUIViewGrid->GetCameraNode()->Update(GetTimeInSeconds(), 0.0f); _RefreshGrid(true); }
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); } } }
//---------------------------------------------------------------------------- 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 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(); } }