Torque3D-clone/Templates/BaseGame/game/tools/meshRoadEditor/meshRoadEditorGui.tscript

//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

$MeshRoad::wireframe = true;
$MeshRoad::showSpline = true;
$MeshRoad::showReflectPlane = false;
$MeshRoad::showRoad = true;
$MeshRoad::showRoadProfile = false;

$MeshRoad::breakAngle = 3.0;

// MeshRoadEditorGui Script Methods

//-----------------------------------------------------------------------------

function MeshRoadEditorGui::maxSize(%this, %window)
{      
   // Resize the windows to the max height
   // and force these to the right side if set
   if(EditorSettings.value( "WorldEditor/forceSidebarToSide" ) == 1 && %this.resizing == true)
   {  
      // prevent onResize after a resize
      %this.resizing = false;
      
      %fixedWindow = MeshRoadEditorTreeWindow;
      %fluidWindow = MeshRoadEditorOptionsWindow;
      %offset = -1; // tweak the vertical offset so that it aligns neatly
      %top = EditorGuiToolbar.extent.y + %offset;
      %bottom = %top + 59;
      %maxHeight = Canvas.extent.y - %top - %bottom;
      
      // --- Fixed window (top) ------------------------------------------------
      // put it back if it moved
      %fixedWindow.position.x = Canvas.extent.x - %fixedWindow.extent.x;
      %fixedWindow.position.y = %top;
      
      // don't go beyond the canvas
      if(%fixedWindow.extent.y > %maxHeight)
         %fixedWindow.extent.y = %maxHeight - %fluidWindow.extent.y;

      %position = %fixedWindow.position.x SPC %fixedWindow.position.y;
      %extent = %window.extent.x SPC %fixedWindow.extent.y;
      %fixedWindow.resize(%position.x, %position.y, %extent.x, %extent.y);
      
      // --- Fluid window (bottom) ---------------------------------------------
      // position is relative to the top window
      %position = %fixedWindow.position.x SPC %fixedWindow.extent.y + %top;
      %extent = %window.extent.x SPC Canvas.extent.y - %fixedWindow.extent.y - %bottom;
      %fluidWindow.resize(%position.x, %position.y, %extent.x, %extent.y);
      
      // --- AssetBrowser window  ----------------------------------------------
      if(isObject(AssetBrowserWindow))
      {
         // Only resize the AssetBrowser if it's docked
         if(AssetBrowserWindow.docked == true)
         {
            // The width is relative to the sidepanel
            %browserWidth = Canvas.extent.x - %extent.x;
            %browserHeight = AssetBrowserWindow.extent.y;
            %browserPosY = Canvas.extent.y - AssetBrowserWindow.extent.y - 33;
            AssetBrowserWindow.resize(0, %browserPosY, %browserWidth, %browserHeight);
         }
      }
      // --- Windowed Console --------------------------------------------------
      if(isObject(windowConsoleControl))
      {
         // Only resize the AssetBrowser if it's docked
         if(windowConsoleControl.docked == true)
         {
            // The width is relative to the sidepanel
            %consoleWidth = Canvas.extent.x - %extent.x;
            %consoleHeight = windowConsoleControl.extent.y;
            %consolePosY = Canvas.extent.y - windowConsoleControl.extent.y - 33;
            windowConsoleControl.resize(0, %consolePosY, %consoleWidth, %consoleHeight);
         }
      }
   }
}

function MeshRoadEditorTreeWindow::onMouseDragged(%this)
{
   %parent = MeshRoadEditorGui;
   
   if(%parent.panelHidden == true)
   {
      %parent.showSidePanel();
   }
   
   if(%parent.resizing == false && %parent.docked == true)
   {
      %parent.resizing = true;
      %parent.maxSize(%this);
   }
}

function MeshRoadEditorOptionsWindow::onMouseDragged(%this)
{
   %parent = MeshRoadEditorGui;
   
   if(%parent.panelHidden == true)
   {
      %parent.showSidePanel();
   }
   
   if(%parent.resizing == false && %parent.docked == true)
   {
      %parent.resizing = true;
      %parent.maxSize(%this);
   }
}

function MeshRoadEditorGui::onResize(%this, %newPosition, %newExtent)
{
   // Window to focus on (mostly the fluid window)
   %window = MeshRoadEditorOptionsWindow;
   
   if(%window.panelHidden == true)
   {
      %window.showSidePanel();
   }
   
   if(%this.resizing == false && %this.docked == true)
   {  
      // Only resize once
      %this.resizing = true;
      %this.maxSize(%window);
   }
}

function MeshRoadEditorGui::dockSidePanel()
{
   %parent = MeshRoadEditorGui;
   %fixedWindow = MeshRoadEditorTreeWindow;
   %fluidWindow = MeshRoadEditorOptionsWindow;
   
   if(%parent.docked == true)
      return;
   
   // Move and resize the window(s)
   %parent.resizing = true;
   %parent.maxSize(%fluidWindow);
      
   %parent.docked = true;
   %fluidWindow.onMouseDragged();

   // Lock the windows in place
   %fixedWindow.canCollapse = "0";
   %fixedWindow.canMove = "0";
   
   %fluidWindow.canCollapse = "0";
   %fluidWindow.canMove = "0";
   
   MeshRoadEditorGui_UnDockBtn.Visible = "1";
   MeshRoadEditorGui_DockBtn.Visible = "0";
   
   MeshRoadEditorGui_showBtn.Visible = "0";
   MeshRoadEditorGui_hideBtn.Visible = "1";
}

function MeshRoadEditorGui::releaseSidePanel()
{      
   %parent = MeshRoadEditorGui;
   %fixedWindow = MeshRoadEditorTreeWindow;
   %fluidWindow = MeshRoadEditorOptionsWindow;
   
   if(%parent.docked == false)
      return;
   
   // Unlock the windows so that be moved
   %fixedWindow.canCollapse = "1";
   %fixedWindow.canMove = "1";
   
   %fluidWindow.canCollapse = "1";
   %fluidWindow.canMove = "1";
   
   MeshRoadEditorGui_UnDockBtn.Visible = "0";
   MeshRoadEditorGui_DockBtn.Visible = "1";
   
   MeshRoadEditorGui_showBtn.Visible = "0";
   MeshRoadEditorGui_hideBtn.Visible = "0";
   
   // Let's do a small resize so it's visually clear we're undocking
   %position = %fixedWindow.position.x - 6 SPC %fixedWindow.position.y + 6;
   %extent = %fixedWindow.extent.x SPC %fixedWindow.extent.y;
   %fixedWindow.resize(%position.x, %position.y, %extent.x, %extent.y);

   %position =  %fluidWindow.position.x - 6 SPC  %fluidWindow.position.y + 6;
   %extent = %fluidWindow.extent.x SPC %fluidWindow.extent.y - 12;
   %fluidWindow.resize(%position.x, %position.y, %extent.x, %extent.y);
   
   %parent.docked = false;
   %parent.resizing = false;
}

function MeshRoadEditorGui::hideSidePanel()
{
   %parent = MeshRoadEditorGui;
   %fixedWindow = MeshRoadEditorTreeWindow;
   %fluidWindow = MeshRoadEditorOptionsWindow;
   
   MeshRoadEditorGui_showBtn.Visible = "1";
   MeshRoadEditorGui_hideBtn.Visible = "0";
   
   // hide the content of the panels
   %fixedWindow.titleText = %fixedWindow.text;
   %fluidWindow.titleText = %fluidWindow.text;
   
   %fixedWindow.text = "";
   MeshRoadEditorRoadsPanel.Visible = "0";
   
   %fluidWindow.text = "";
   MeshRoadNodesPanel.Visible = "0";
   MeshRoadPropertiesPanel.Visible = "0";
   MeshRoadInspectorPanel.Visible = "0";
   MeshRoadFieldInfoControl.Visible = "0";
   
   // Let's do a resize so that the panel is collapsed to the side
   %position = Canvas.extent.x - 24 SPC %fixedWindow.position.y;
   %extent = %fixedWindow.extent.x SPC %fixedWindow.extent.y;
   %fixedWindow.resize(%position.x, %position.y, %extent.x, %extent.y);

   %position =  Canvas.extent.x - 24 SPC %fluidWindow.position.y;
   %extent = %fluidWindow.extent.x SPC %fluidWindow.extent.y;
   %fluidWindow.resize(%position.x, %position.y, %extent.x, %extent.y);
   
   %parent.panelHidden = true;
}

function MeshRoadEditorGui::showSidePanel()
{
   %parent = MeshRoadEditorGui;
   %fixedWindow = MeshRoadEditorTreeWindow;
   %fluidWindow = MeshRoadEditorOptionsWindow;
   
   MeshRoadEditorGui_showBtn.Visible = "0";
   MeshRoadEditorGui_hideBtn.Visible = "1";
   
   // show the content of the panels
   // hide the content of the panels
   %fixedWindow.text = %fixedWindow.titleText;
   MeshRoadEditorRoadsPanel.Visible = "1";
   
   %fluidWindow.text = %fluidWindow.titleText;
   MeshRoadNodesPanel.Visible = "1";
   MeshRoadPropertiesPanel.Visible = "1";
   MeshRoadInspectorPanel.Visible = "1";
   MeshRoadFieldInfoControl.Visible = "1";
   
   %parent.resizing = true;
   %parent.maxSize(%fluidWindow);
   
   %parent.panelHidden = false;
}

//------------------------------------------------------------------------------
   
function MeshRoadEditorGui::onWake( %this )
{   
   $MeshRoad::EditorOpen = true; 
   
   // Maximize windows when set ------------------------------------
   %fixedWindow = MeshRoadEditorTreeWindow;
   %fluidWindow = MeshRoadEditorOptionsWindow;   
   
   if(EditorSettings.value( "WorldEditor/forceSidebarToSide" ) == 1)
   {
      // Let's dock the side panel to the right side
      %this.docked = false;
      %this.resizing = true;
      %this.dockSidePanel();
   }
   else
   {
      // Let's release the side panel so it can be moved
      %this.docked = true;
      %this.resizing = false;
      %this.releaseSidePanel();
   }
   // --------------------------------------------------------------
   
   %count = EWorldEditor.getSelectionSize();
   for ( %i = 0; %i < %count; %i++ )
   {
      %obj = EWorldEditor.getSelectedObject(%i);
      if ( %obj.getClassName() !$= "MeshRoad" )
         EWorldEditor.unselectObject();
      else
         %this.setSelectedRoad( %obj );
   }      
   
   //%this-->TabBook.selectPage(0);
     
   %this.onNodeSelected(-1);
}

function MeshRoadEditorGui::onSleep( %this )
{
   $MeshRoad::EditorOpen = false;    
}

function MeshRoadEditorGui::paletteSync( %this, %mode )
{
   %evalShortcut = "ToolsPaletteArray-->" @ %mode @ ".setStateOn(1);";
   eval(%evalShortcut);
}   
function MeshRoadEditorGui::onEscapePressed( %this )
{
   if( %this.getMode() $= "MeshRoadEditorAddNodeMode" )
   {
      %this.prepSelectionMode();
      return true;
   }
   return false;
}
function MeshRoadEditorGui::onRoadSelected( %this, %road )
{
   %this.road = %road;
   
   // Update the materialEditorList
   if( isObject( %road ) )
      $Tools::materialEditorList = %road.getId();
   
   MeshRoadInspector.inspect( %road );  
   MeshRoadTreeView.buildVisibleTree(true);
   if( MeshRoadTreeView.getSelectedObject() != %road )
   {
      MeshRoadTreeView.clearSelection();
      %treeId = MeshRoadTreeView.findItemByObjectId( %road );
      MeshRoadTreeView.selectItem( %treeId );  
   }
}

function MeshRoadEditorGui::onRoadCreation( %this )
{
   %this.road.TopMaterialAsset = "Core_GameObjects:DefaultDecalRoadMaterial";
   %this.road.SideMaterialAsset = "Core_GameObjects:DefaultRoadMaterialOther";
   %this.road.BottomMaterialAsset = "Core_GameObjects:DefaultRoadMaterialOther";
}

function MeshRoadEditorGui::onNodeSelected( %this, %nodeIdx )
{
   if ( %nodeIdx == -1 )
   {
      MeshRoadEditorOptionsWindow-->position.setActive( false );
      MeshRoadEditorOptionsWindow-->position.setValue( "" );    
      
      MeshRoadEditorOptionsWindow-->rotation.setActive( false );
      MeshRoadEditorOptionsWindow-->rotation.setValue( "" );
      
      MeshRoadEditorOptionsWindow-->width.setActive( false );
      MeshRoadEditorOptionsWindow-->width.setValue( "" ); 
      
      MeshRoadEditorOptionsWindow-->depth.setActive( false );
      MeshRoadEditorOptionsWindow-->depth.setValue( "" );  
   }
   else
   {
      MeshRoadEditorOptionsWindow-->position.setActive( true );
      MeshRoadEditorOptionsWindow-->position.setValue( %this.getNodePosition() );    
      
      MeshRoadEditorOptionsWindow-->rotation.setActive( true );
      MeshRoadEditorOptionsWindow-->rotation.setValue( %this.getNodeNormal() );
      
      MeshRoadEditorOptionsWindow-->width.setActive( true );
      MeshRoadEditorOptionsWindow-->width.setValue( %this.getNodeWidth() ); 
      
      MeshRoadEditorOptionsWindow-->depth.setActive( true );
      MeshRoadEditorOptionsWindow-->depth.setValue( %this.getNodeDepth() );  
   }
}

function MeshRoadEditorGui::onNodeModified( %this, %nodeIdx )
{
   MeshRoadEditorOptionsWindow-->position.setValue( %this.getNodePosition() );    
   MeshRoadEditorOptionsWindow-->rotation.setValue( %this.getNodeNormal() );
   MeshRoadEditorOptionsWindow-->width.setValue( %this.getNodeWidth() ); 
   MeshRoadEditorOptionsWindow-->depth.setValue( %this.getNodeDepth() );   
}

function MeshRoadEditorGui::editNodeDetails( %this )
{
   %this.setNodePosition( MeshRoadEditorOptionsWindow-->position.getText() );
   %this.setNodeNormal( MeshRoadEditorOptionsWindow-->rotation.getText() );
   %this.setNodeWidth( MeshRoadEditorOptionsWindow-->width.getText() );
   %this.setNodeDepth( MeshRoadEditorOptionsWindow-->depth.getText() );
}

function MeshRoadEditorGui::onBrowseClicked( %this )
{
   %filename = RETextureFileCtrl.getText();

   %dlg = new OpenFileDialog()
   {
      Filters        = "All Files (*.*)|*.*|";
      DefaultPath    = MeshRoadEditorGui.lastPath;
      DefaultFile    = %filename;
      ChangePath     = false;
      MustExist      = true;
   };
         
   %ret = %dlg.Execute();
   if(%ret)
   {
      MeshRoadEditorGui.lastPath = filePath( %dlg.FileName );
      %filename = %dlg.FileName;
      MeshRoadEditorGui.setTextureFile( %filename );
      MeshRoadEditorTextureFileCtrl.setText( %filename );
   }
   
   %dlg.delete();
}

function MeshRoadInspector::inspect( %this, %obj )
{
   %name = "";
   if ( isObject( %obj ) )
      %name = %obj.getName();   
   else
      MeshRoadFieldInfoControl.setText( "" );
   
   //RiverInspectorNameEdit.setValue( %name );
   Parent::inspect( %this, %obj );  
}

function MeshRoadInspector::onInspectorFieldModified( %this, %object, %fieldName, %arrayIndex, %oldValue, %newValue )
{
   // Same work to do as for the regular WorldEditor Inspector.
   Inspector::onInspectorFieldModified( %this, %object, %fieldName, %arrayIndex, %oldValue, %newValue );   
}

function MeshRoadInspector::onFieldSelected( %this, %fieldName, %fieldTypeStr, %fieldDoc )
{
   MeshRoadFieldInfoControl.setText( "<font:" @ $Gui::fontTypeBold @ ":16>" @ %fieldName @ "<font:" @ $Gui::fontTypeItalic @ ":16> (" @ %fieldTypeStr @ ") " NL "<font:" @ $Gui::fontTypeRegular @ ":16>" @ %fieldDoc );
}

function MeshRoadTreeView::onInspect(%this, %obj)
{
   MeshRoadInspector.inspect(%obj);   
}

function MeshRoadTreeView::onSelect(%this, %obj)
{
   MeshRoadEditorGui.road = %obj; 
   MeshRoadInspector.inspect( %obj );
   if(%obj != MeshRoadEditorGui.getSelectedRoad())
   {
      MeshRoadEditorGui.setSelectedRoad( %obj );
   }
}

function MeshRoadEditorGui::prepSelectionMode( %this )
{
   %mode = %this.getMode();
   
   if ( %mode $= "MeshRoadEditorAddNodeMode"  )
   {
      if ( isObject( %this.getSelectedRoad() ) )
         %this.deleteNode();
   }
   
   %this.setMode( "MeshRoadEditorSelectMode" );
   ToolsPaletteArray-->MeshRoadEditorSelectMode.setStateOn(1);
}

//------------------------------------------------------------------------------
function ESettingsWindow::getMeshRoadEditorSettings(%this)
{
   SettingsInspector.startGroup("Defaults");
   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultWidth", "Width", "string", "");
   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultDepth", "Depth", "string", "");
   SettingsInspector.addSettingsField("MeshRoadEditor/DefaultNormal", "Normal", "string", "");
   
   SettingsInspector.addSettingsField("MeshRoadEditor/TopMaterialName", "Top Material", "string", "");
   SettingsInspector.addSettingsField("MeshRoadEditor/BottomMaterialName", "Bottom Material", "string", "");
   SettingsInspector.addSettingsField("MeshRoadEditor/SideMaterialName", "Side Material", "string", "");
   SettingsInspector.endGroup();
   
   SettingsInspector.startGroup("Colors");
   SettingsInspector.addSettingsField("MeshRoadEditor/HoverSplineColor", "Hover Spline", "colorI", "");
   SettingsInspector.addSettingsField("MeshRoadEditor/SelectedSplineColor", "Selected Spline", "colorI", "");
   SettingsInspector.endGroup();
}
//------------------------------------------------------------------------------
function EMeshRoadEditorSelectModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorAddModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorMoveModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorRotateModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorScaleModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorInsertModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function EMeshRoadEditorRemoveModeBtn::onClick(%this)
{
   EditorGuiStatusBar.setInfo(%this.ToolTip);
}

function MeshRoadDefaultWidthSliderCtrlContainer::onWake(%this)
{
   MeshRoadDefaultWidthSliderCtrlContainer-->slider.setValue(MeshRoadDefaultWidthTextEditContainer-->textEdit.getText());
}

function MeshRoadDefaultDepthSliderCtrlContainer::onWake(%this)
{
   MeshRoadDefaultDepthSliderCtrlContainer-->slider.setValue(MeshRoadDefaultDepthTextEditContainer-->textEdit.getText());
}