void moveSelectedCmd(const cmd::ArgumentList& args)
{
if (args.size() != 1)
{
rMessage() << "Usage: moveSelectionVertically [up|down]" << std::endl;
return;
}
UndoableCommand undo("moveSelectionVertically");
std::string arg = boost::algorithm::to_lower_copy(args[0].getString());
if (arg == "up")
{
moveSelectedAlongZ(GlobalGrid().getGridSize());
}
else if (arg == "down")
{
moveSelectedAlongZ(-GlobalGrid().getGridSize());
}
else
{
// Invalid argument
rMessage() << "Usage: moveSelectionVertically [up|down]" << std::endl;
return;
}
}
void Selection_SnapToGrid (void)
{
StringOutputStream command;
command << "snapSelected -grid " << GlobalGrid().getGridSize();
UndoableCommand undo(command.toString());
if (GlobalSelectionSystem().Mode() == SelectionSystem::eComponent) {
GlobalSceneGraph().traverse(ComponentSnappableSnapToGridSelected(GlobalGrid().getGridSize()));
} else {
GlobalSceneGraph().traverse(SnappableSnapToGridSelected(GlobalGrid().getGridSize()));
}
}
AABB getDefaultBoundsFromSelection()
{
AABB aabb = GlobalSelectionSystem().getWorkZone().bounds;
float gridSize = GlobalGrid().getGridSize();
if (aabb.extents[0] == 0)
{
aabb.extents[0] = gridSize;
}
if (aabb.extents[1] == 0)
{
aabb.extents[1] = gridSize;
}
if (aabb.extents[2] == 0)
{
aabb.extents[2] = gridSize;
}
if (aabb.isValid())
{
return aabb;
}
return AABB(Vector3(0, 0, 0), Vector3(64, 64, 64));
}
void RadiantSelectionSystem::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "RadiantSelectionSystem::initialiseModule called.\n";
constructStatic();
SetManipulatorMode(eTranslate);
pivotChanged();
_sigSelectionChanged.connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChangedSelection)
);
GlobalGrid().signal_gridChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChanged)
);
GlobalRegistry().signalForKey(RKEY_ROTATION_PIVOT).connect(
sigc::mem_fun(this, &RadiantSelectionSystem::keyChanged)
);
// Pass a reference to self to the global event manager
GlobalEventManager().connectSelectionSystem(this);
// Connect the bounds changed caller
GlobalSceneGraph().signal_boundsChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::onSceneBoundsChanged)
);
GlobalRenderSystem().attachRenderable(*this);
}
/* greebo: This calculates and constructs the pivot point of the selection.
* It cycles through all selected objects and creates its AABB. The origin point of the AABB
* is basically the pivot point. Pivot2World is therefore a translation from (0,0,0) to the calculated origin.
*
* The pivot point is also snapped to the grid.
*/
void RadiantSelectionSystem::ConstructPivot() const {
if (!_pivotChanged || _pivotMoving)
return;
_pivotChanged = false;
Vector3 objectPivot;
if (!nothingSelected()) {
{
// Create a local variable where the aabb information is stored
AABB bounds;
// Traverse through the selection and update the <bounds> variable
if (Mode() == eComponent) {
GlobalSceneGraph().traverse(BoundsSelectedComponent(bounds));
}
else {
GlobalSceneGraph().traverse(BoundsSelected(bounds));
}
// the <bounds> variable now contains the AABB of the selection, retrieve the origin
objectPivot = bounds.origin;
}
// Snap the pivot point to the grid
vector3_snap(objectPivot, GlobalGrid().getGridSize());
// The pivot2world matrix is just a translation from the world origin (0,0,0) to the object pivot
_pivot2world = Matrix4::getTranslation(objectPivot);
// Only rotation and scaling need further calculations
switch (_manipulatorMode) {
case eTranslate:
break;
case eRotate:
if (Mode() == eComponent) {
matrix4_assign_rotation_for_pivot(_pivot2world, _componentSelection.back());
}
else {
matrix4_assign_rotation_for_pivot(_pivot2world, _selection.back());
}
break;
case eScale:
if (Mode() == eComponent) {
matrix4_assign_rotation_for_pivot(_pivot2world, _componentSelection.back());
}
else {
matrix4_assign_rotation_for_pivot(_pivot2world, _selection.back());
}
break;
default:
break;
} // switch
}
}
void hollowBrush(const BrushNodePtr& sourceBrush, bool makeRoom)
{
// Hollow the brush using the current grid size
sourceBrush->getBrush().forEachFace([&] (Face& face)
{
if (!face.contributes())
{
return;
}
scene::INodePtr parent = sourceBrush->getParent();
scene::INodePtr newNode = GlobalBrushCreator().createBrush();
BrushNodePtr brushNode = std::dynamic_pointer_cast<BrushNode>(newNode);
assert(brushNode);
// Add the child to the same parent as the source brush
parent->addChildNode(brushNode);
// Move the child brushes to the same layer as their source
brushNode->assignToLayers(sourceBrush->getLayers());
// Copy all faces from the source brush
brushNode->getBrush().copy(sourceBrush->getBrush());
Node_setSelected(brushNode, true);
FacePtr newFace = brushNode->getBrush().addFace(face);
if (newFace != 0)
{
float offset = GlobalGrid().getGridSize();
newFace->flipWinding();
newFace->getPlane().offset(offset);
newFace->planeChanged();
if (makeRoom)
{
// Retrieve the normal vector of the "source" face
brushNode->getBrush().transform(Matrix4::getTranslation(face.getPlane().getPlane().normal() * offset));
brushNode->getBrush().freezeTransform();
}
}
brushNode->getBrush().removeEmptyFaces();
});
// Now unselect and remove the source brush from the scene
scene::removeNodeFromParent(sourceBrush);
}
RadiantSelectionSystem::RadiantSelectionSystem() :
_requestWorkZoneRecalculation(true), _undoBegun(false), _mode(ePrimitive), _componentMode(eDefault), _countPrimitive(0),
_countComponent(0),
_translateManipulator(*this, 2, 64), // initialise the Manipulators with a pointer to self
_rotateManipulator(*this, 8, 64), _scaleManipulator(*this, 0, 64), _pivotChanged(false),
_pivotMoving(false)
{
SetManipulatorMode(eTranslate);
pivotChanged();
addSelectionChangeCallback(PivotChangedSelectionCaller(*this));
GlobalGrid().addGridChangeCallback(PivotChangedCaller(*this));
// Pass a reference to self to the global event manager
GlobalEventManager().connectSelectionSystem(this);
}
void PasteToCamera (void)
{
CamWnd& camwnd = *g_pParentWnd->GetCamWnd();
GlobalSelectionSystem().setSelectedAll(false);
UndoableCommand undo("pasteToCamera");
Selection_Paste();
// Work out the delta
Vector3 mid = selection::algorithm::getCurrentSelectionCenter();
Vector3 delta = vector3_snapped(camwnd.getCameraOrigin(), GlobalGrid().getGridSize()) - mid;
// Move to camera
GlobalSelectionSystem().translateSelected(delta);
}
void nudgeSelected(ENudgeDirection direction)
{
nudgeSelected(direction, GlobalGrid().getGridSize(), GlobalXYWndManager().getActiveViewType());
}
void Selection_MoveUp (void)
{
Selection_NudgeZ(GlobalGrid().getGridSize());
}
void Selection_MoveDown (void)
{
Selection_NudgeZ(-GlobalGrid().getGridSize());
}
/**
* @brief Create the user settable window layout
*/
void MainFrame::Create (void)
{
GtkWindow* window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
// do this here, because the commands are needed
_sidebar = new ui::Sidebar();
GtkWidget *sidebar = _sidebar->getWidget();
// Tell the XYManager which window the xyviews should be transient for
GlobalXYWnd().setGlobalParentWindow(window);
GlobalWindowObservers_connectTopLevel(window);
gtk_window_set_transient_for(ui::Splash::Instance().getWindow(), window);
#ifndef _WIN32
{
GdkPixbuf* pixbuf = gtkutil::getLocalPixbuf(ui::icons::ICON);
if (pixbuf != 0) {
gtk_window_set_icon(window, pixbuf);
g_object_unref(pixbuf);
}
}
#endif
gtk_widget_add_events(GTK_WIDGET(window), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_FOCUS_CHANGE_MASK);
g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(mainframe_delete), this);
m_position_tracker.connect(window);
g_MainWindowActive.connect(window);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
GlobalEventManager().connect(GTK_OBJECT(window));
GlobalEventManager().connectAccelGroup(GTK_WINDOW(window));
m_nCurrentStyle = eSplit;
// Create the Filter menu entries
ui::FiltersMenu::addItemsToMainMenu();
// Retrieve the "main" menubar from the UIManager
GtkMenuBar* mainMenu = GTK_MENU_BAR(GlobalUIManager().getMenuManager()->get("main"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(mainMenu), false, false, 0);
// Instantiate the ToolbarCreator and retrieve the standard toolbar widget
ui::ToolbarCreator toolbarCreator;
GtkToolbar* generalToolbar = toolbarCreator.getToolbar("view");
gtk_widget_show(GTK_WIDGET(generalToolbar));
GlobalSelectionSetManager().init(generalToolbar);
// Pack it into the main window
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(generalToolbar), FALSE, FALSE, 0);
GtkWidget* main_statusbar = create_main_statusbar(m_pStatusLabel);
gtk_box_pack_end(GTK_BOX(vbox), main_statusbar, FALSE, TRUE, 2);
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_widget_show(hbox);
GtkToolbar* main_toolbar_v = toolbarCreator.getToolbar("edit");
gtk_widget_show(GTK_WIDGET(main_toolbar_v));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(main_toolbar_v), FALSE, FALSE, 0);
// Connect the window position tracker
_windowPosition.loadFromPath(RKEY_WINDOW_STATE);
// Yes, connect the position tracker, this overrides the existing setting.
_windowPosition.connect(window);
int startMonitor = GlobalRegistry().getInt(RKEY_MULTIMON_START_MONITOR);
if (startMonitor < gtkutil::MultiMonitor::getNumMonitors()) {
// Load the correct coordinates into the position tracker
_windowPosition.fitToScreen(gtkutil::MultiMonitor::getMonitor(startMonitor), 0.8f, 0.8f);
}
// Apply the position
_windowPosition.applyPosition();
int windowState = string::toInt(GlobalRegistry().getAttribute(RKEY_WINDOW_STATE, "state"), GDK_WINDOW_STATE_MAXIMIZED);
if (windowState & GDK_WINDOW_STATE_MAXIMIZED)
gtk_window_maximize(window);
m_window = window;
gtk_widget_show(GTK_WIDGET(window));
// The default XYView pointer
XYWnd* xyWnd;
GtkWidget* mainHBox = gtk_hbox_new(0, 0);
gtk_box_pack_start(GTK_BOX(hbox), mainHBox, TRUE, TRUE, 0);
gtk_widget_show(mainHBox);
int w, h;
gtk_window_get_size(window, &w, &h);
// camera
m_pCamWnd = GlobalCamera().newCamWnd();
GlobalCamera().setCamWnd(m_pCamWnd);
GlobalCamera().setParent(m_pCamWnd, window);
GtkWidget* camera = m_pCamWnd->getWidget();
// Allocate the three ortho views
xyWnd = GlobalXYWnd().createXY();
xyWnd->setViewType(XY);
GtkWidget* xy = xyWnd->getWidget();
XYWnd* yzWnd = GlobalXYWnd().createXY();
yzWnd->setViewType(YZ);
GtkWidget* yz = yzWnd->getWidget();
XYWnd* xzWnd = GlobalXYWnd().createXY();
xzWnd->setViewType(XZ);
GtkWidget* xz = xzWnd->getWidget();
// split view (4 views)
GtkHPaned* split = create_split_views(camera, yz, xy, xz);
gtk_box_pack_start(GTK_BOX(mainHBox), GTK_WIDGET(split), TRUE, TRUE, 0);
// greebo: In any layout, there is at least the XY view present, make it active
GlobalXYWnd().setActiveXY(xyWnd);
PreferencesDialog_constructWindow(window);
GlobalGrid().addGridChangeCallback(FreeCaller<XY_UpdateAllWindows> ());
/* enable button state tracker, set default states for begin */
GlobalUndoSystem().trackerAttach(m_saveStateTracker);
gtk_box_pack_start(GTK_BOX(mainHBox), GTK_WIDGET(sidebar), FALSE, FALSE, 0);
// Start the autosave timer so that it can periodically check the map for changes
map::AutoSaver().startTimer();
}
void Selection_NudgeRight (void)
{
UndoableCommand undo("nudgeSelectedRight");
NudgeSelection(eNudgeRight, GlobalGrid().getGridSize(), GlobalXYWnd().getActiveViewType());
}
void Selection_MoveUp(const cmd::ArgumentList& args)
{
Selection_NudgeZ(GlobalGrid().getGridSize());
}
