Make Hollow?

by John Spivey · in Artist Corner · 07/07/2006 (5:32 pm) · 12 replies · tool

tool.activate(YourToolPackageName);
//
// csghollow.cs
//
// Defines the csghollow tool plug-in to hollow a brush by a specific amount.
//
// Revision History:
// July 19, 2006				David Wyand		Created script file
// B--

package CSGHollow
{
   //************************************************************************************
   //*** Standard Tool Functions
   //************************************************************************************
   
   //************************************************************************************
   // Activate()
   //
   // Called when the tool is activated.  %version holds the current version of this
   // tool type in Constructor to allow the tool to step down features if required.
   // %inst is actually a ScriptObject behind the scenes that allows for the tool's
   // instance to be attached to it -- which is typically a ScriptObject itself.
   // %static is a ScriptObject that allows anything to be attached to it that will
   // presist across tool instances.
   // Return a Tool Return Function to indicate success of the tool's activation.
   function Plugin::Activate(%this, %version, %inst, %static)
   {
      error("CSGHollow: Activate(" @ %version @ "," @ %inst @ "," @ %static @ ")");

      //*** Check for a valid version
      if(%version != 1)
      {
         return tool.FUNC_BADVERSION();
      }
      
      //*** This tool doesn't need to make use of the instance
      %inst.instance = 0;
            
      %inst.flagsInterface = tool.IFLAG_NONE(); // No special interface flags as there will be no interface
      %inst.flagsApply = tool.AFLAG_NONE();     // No special actions when tool is applied
      
      //*** Return that everything is OK
      return tool.FUNC_OK();
   }

   //************************************************************************************
   // Done()
   //
   // Called when the user is finished with the tool.  Typically any allocated
   // memory is freed here.  %inst and %static are the same as those in the
   // activation function.  This function does not return a value.
   function Plugin::Done(%this, %inst, %static)
   {
      error("CSGHollow: Done(" @ %inst @ "," @ %static @ ")");

      %plugin = %inst.instance;
      
      if(%plugin)
      {         
         //*** Delete our instance
         %plugin.delete();
         %inst.instance = 0;
      }
   }

   //************************************************************************************
   // Execute()
   //
   // This function is called to perform the actual work of the tool, and does not
   // return a value.
   function Plugin::Execute(%this, %inst)
   {
      error("CSGHollow: Execute(" @ %inst @ ")");

      //*** Hollow thickness hard coded at this point..
      %THICKNESS = "0.1";

      if(scene.getCurrentMap().getSelectedBrushes() $= "")
      {
         MessageBoxOK("No Brushes Selected", "Select at least 1 brush to hollow!");
         error("Select at least 1 brush");
      }
      else
      {
         //*** Lets start by making a copy of everything selected and scale it down
         //*** so we can use it for a cut brush
         select.copy(); //doing this opens the door for multiple hollows at once
         select.paste();
         %currMap = scene.getCurrentMap();
         %currBrushSelections = %currMap.getSelectedBrushes();
         %totalBrushesSelected = getWordCount(%currBrushSelections);
         
         for(%i = 0; %i < %totalBrushesSelected; %i++) //handles multiple hollows
         {
            select.clear();
            select.addItem(getWord(%currBrushSelections, %i));
            %currBrush = %currMap.getSelectedBrushes();  //focus on the current brush
            error("loop:" @ %i @ "Brush:" @ %currMap.getSelectedBrushes());

            %hollowScale = CSGHollow_GetScale(%currMap.getSelectedBrushesBounds(), %THICKNESS); //custom routine to get scale amount     
            %currMap.setBrushScale(%currBrush, %hollowScale);  //handy scale that keeps center

            //%currMap.performCSGSubtraction($currBrush);   //not sure why this didn't work?
            scene.getCurrentMap().performCSGSubtraction(scene.getCurrentMap().getSelectedBrushes());
            select.deleteSelection(%currBrush); //get rid of cut brush
         }
      }
      scene.notifyBrushRefresh();
   }
   
   //************************************************************************************
   //*** Tool Specific Functions
   //************************************************************************************
   
   //*** Get BrushSize from bounds box min and max
   function CSGHollow_GetBrushSize(%bbox)
   {
         %min[0] = getWord(%bbox,0);   //min x
         %min[1] = getWord(%bbox,1);   //min y
         %min[2] = getWord(%bbox,2);   //min z
         %max[0] = getWord(%bbox,3);   //max x
         %max[1] = getWord(%bbox,4);   //max y
         %max[2] = getWord(%bbox,5);   //max z
         
         %x = %max[0] - %min[0]; //max - min equals the size of x
         %y = %max[1] - %min[1];
         %z = %max[2] - %min[2];
         
         //error("SIZE:" @ %x SPC %y SPC %z);
         return(%x SPC %y SPC %z);  //send back x y z
   }
   
   //*** Get the correct scale to perform a hollow of a specific thickness
   //The %thickness is the actual thickness, so if you want walls that are 0.1
   //meters thick, just pass in 0.1
   function CSGHollow_GetScale(%bounds, %thickness)
   {
      %brushSize = CSGHollow_GetBrushSize(%bounds);   //turn bounds into xyz size
      %totalThickness = %thickness * 2;   //thickness is for one side only, so multiply by 2
      %x = getWord(%brushSize, 0);  //grab the x size
      %y = getWord(%brushSize, 1);
      %z = getWord(%brushSize, 2);
      
      %nx = %x - %totalThickness;   //subtract thickness from size
      %ny = %y - %totalThickness;
      %nz = %z - %totalThickness;
      
      %scaleX = %nx / %x;  //get correct scale by dividing new smaller size by original size
      %scaleY = %ny / %y;
      %scaleZ = %nz / %z;
      
      //error("NEWSCALE:" @ %scaleX SPC %scaleY SPC %scaleZ);
      return(%scaleX SPC %scaleY SPC %scaleZ);  //reutrn new xyz scale values
   }
};

tool.register("CSGHollow", tool.typeGeneric(), tool.RFLAG_NONE(), "CSG Hollow" );
//*** Go through each of the plug-in tool scripts and launch them
   $ToolManagerToolPluginFileName = "";
   $ToolManagerToolPluginType = "Plug-in";
   $ToolManagerToolUserPluginCounter = $StartOfUserPluginsMenuID;
   echo("Loading plug-ins...");
   for(%file = findFirstFile($UserPluginDirectory); %file !$= ""; %file = findNextFile([b]$UserPluginDirectory[/b]))
   {
      //*** Execute the plug-in's script
      $ToolManagerToolPluginFileName = %file;
      exec(%file);

      $ToolManagerToolUserPluginCounter++;
   }
   echo("...Done");
   $ToolManagerToolPluginFileName = "";
   $ToolManagerToolPluginType = "";

Game Development Community

Make Hollow?

About the author

Recent Threads