QMenu

Customizable quadrant menu system for Softimage

Stefan Kubicek & Eugen Sares

This customizable menu system for Softimage was inspired by 3ds max’s quad menus. It’s purpose is to speed up the overall workflow by reducing mouse travel – bringing frequently used functions and commands close to the mouse cursor. It can be configured in a user friendly way (that is: through clicking only), and yet it is also extendable through scripting if a higher level of flexibility is needed, even beyond what 3ds max’ quad menus offer. In fact, many aspects of QMenu are script based so that it can be customized on a very low level without having to change the actual plugin source code.

Gallery of example screenshots

Motivation

We are always looking for ways to improve our workflow. We asked: What is the single most time consuming aspect when operating DCC software? Answer: Selecting the objects and components you intend to manipulate. We think Softimage is already pretty good at that. So what’s the second most time consuming aspect? In our opinion, it is navigating the UI to find the functions to manipulate what is currently selected. Being able to streamline the UI for certain tasks is crucial for productivity in modern production scenarios. Many applications therefore feature customizable GUIs. Softimage is lucky to have a quite convenient and well laid out default GUI. Yet, unfortunately, it cannot be customized as easily or as fully as others, so we thought it was time to do something about this. After all, UI designers and developers can never foresee everything.

Others have attempted to implement custom Pop-up menus in Softimage, too, but they all have one thing in common: they are quite difficult to use because they all rely heavily on the users ability to script. Instead, QMenu can be configured through a graphical user interface (a custom PPG) via menus and buttons (that is: with your mouse only).

Steven Hawking once wrote in his famous book, A Brief History of Time: “I was told that every mathematical formula in my book will reduce it’s potential number of readers by 50%.” In analogy we can say that the same is true about any art tool, hence QMenu. The more scripting knowledge you need to make use of it, the less people will use it. Therefore, we tried to come up with a system that does not require any scripting, at least for as long as you are happy with simple 3DS-Max-level Quad menu functionality. If you think that your work could benefit having your tools closer to your mouse, which results in less time used for mouse movement over the screen, or if you just missed that feeling of working with Quad Menus, chances are good that you will find QMenu helpful in your daily work.

What started out as a little feasibility test and coding exercise soon turned into a project that consumed a substantial part of our spare time of the last one and a half years. Not because it is so immensely feature rich, but we really wanted to make it fit into Softimage as seamlessly as possible, and because there are some SDK limitations, missing features and bugs to work around, as in any 3d software. We took the time to not only record these bugs and missing features, but also make suggestions for future improvements of the Softimage SDK to facilitate easier customization of Softimage’s native menu system and even better QMenu integration. These are documented in the sections further down on this page.

Features

• Unlimited number of context-sensitive quad menus per view.
• Softimage look and feel.
• Sticky key support (QMenu stays open if key is only shortly pressed, or when pressed for longer, disappears once released) .
• User friendly customization interface (a custom PPG) to edit Quad menus without scripting (you can script most aspects for advanced and extended functionality, but you don’t need to in order to use it’s main functions).
• Infinite nestability of menus and submenus (Recursive nesting is supported, contrary to 3dsMax, which crashes when you try to nest a menu in itself )
• Menus can contain Softimage commands, scripted menu items and switches, or other menus.
• Quads can be displayed using either commands assigned to hotkeys of your choice, or  ”display events”, which can be defined and edited in the QMenu Configurator.
• Easy command-repetition of last used command or script item by clicking on one of the menu titles at the center of the Quad (3dsMax-Style).
• Loading and saving of XML-based configuration files. The last saved configuration is automatically  loaded at startup. When overwriting an existing configuration file, a backup with a unique time stamp is created of the existing file before it is overwritten -> You can play around and always return to a previous version if you mess things up.
• Custom QMenu preference to store per-user QMenu configuration settings, like the configuration file name and path, or whether QMenu is activated or deactivated.
• Extensive set of ready-to-use and customizable menu sets for viewport manipulation, modeling, rendering & shading. More menu sets (e.g. for animation) are currently WIP.
• Extensive set of predefined ready-to-use context objects for your own new menu sets or to extend and customize existing menu sets.
• Dynamic menu content (scriptable). E.g. menus could hold one menu item per light object in the scene for quick selection, or inspection, etc, depending on the content of the current scene.
• Scriptable contexts, menu items, switches and menus. All of them support either Python, JScript or VBScript as scripting language.
• Supported Platforms: Softimage 7.0 to 2011.5 on Windows XP, Vista, 7, 32 and 64 bit. Yeah, sorry, no Linux yet . This has a couple of reasons. Please also check out the Bug Reports and Missing Features section below for more information and on how you can help to resolve this limitation.
• On the fly editing of scripted items. Change your code and test your changed menu, menu item, switch or context right away . No need to restart Softimage or reload the plugin.
• Association of Quad menus and views is not hard coded . If you have created your own relational view or custom view, you can easily add a QMenu to it.
• New in 0.95: Editing of Menus in Render Tree and ICE Tree “on the fly.

Version History

0.95 – Aug. 3rd 2011: Update and bugfix release

New features video:

Installation

1. If you had an older version installed,  make a backup of the Configuration file(s) and uninstall the old addon.
2. Download the QMenu 0.95 xsiaddon from http://code.google.com/p/keyvis-dev/
3. Either drag and drop the addon into Softimage, which will install it in your user addons folder, or use File->Install Addon for more options (like installing in a Workgroup).
4. If all went well you should now see a new menu item called “QMenu” appearing in your main menu bar at the top of the Softimage window.
5. Restart Softimage to fully initialize QMenu.
6. In case you get an error message at some point that the Configuration file could not be found, it is most likely because you had an older version of QMenu installed in a different folder and the old path for the config file is still registered in your Preferences. Solution: Either point the Config File to the folder containing the config file that ships with QMenu  (in <Your Qmenu Plugin Folder>/Data/Preferences/) or point it to your old file, the press “Load” to actually load the config data from the file.
7. Enable QMenu from it’s pull-down menu or from it’s custom preference.
8. Assign display commands (QMenuDisplayMenuSet_0 to 3) or key events to hotkeys of your choice (See Hotkeys Tab in the QMenu Configurator for instructions).

Plugin Changes:

• Softimage 2012 compatible
• Menus in Render Tree and ICE tree can be edited on the fly without using the Conigurator
• More homogeneous and verbose Error reporting when executing Menu Item’s, Menus or Context’s code manually
• View Signatures can now be much shorter and generic. As a result, viewer menu sets need to be defined (e.g. the same menu set can be used for docked and floating PPGs instead of two separate ones)
• 2012 only: More reliable command execution by using a delayed timer event to ensure that clicked menu items are executed after any QMenu code has finished executing. Background: Pick sessions now work from within timer events, this seems to have been fixed in 2012, though it was never documented.
• 2012 only: Using new check mark feature in main QMenu menu to indicate if QMenu is activated or not instead of differently named menu items.
• Added QMenuGetGlobalObjectByName command
• Added more items to the scripting context object:  DisplayContexts, CurrentXSIView, ClickedMenu, ClickedMenuItemNumber, SoftimageMainVersion
• You can now specify a non-existing file in the Configurator’s or Custom preferences’ file browser. Previously a new name could only be specified in the edit line directly, the browser expected an existing file.
• OpenQMenuConfigurator will now open the PPG in Locked mode.
• Added “Move Up” and “Move Down” buttons for View reordering to the Configurator PPG
• Slight PPG facelift. Some Configurator Parameters, Buttons,  Headlines and descriptions were renamed or rephrased to make them easier to understand by new users.
• Introduced “Scan Depth” Parameters for Menu, Menu Item and Context objects as a means to speed up data collection of selected scene objects for the script context object in cases where many objects are selected (which could potentially take longer and cause delays in mennu rendering. Objects are now only scanned for useful data up to the greatest number specified in any of the QMenu objects during a menu display session.
• Renamed Command “Open QMenu Editor” back to “Open QMenu Configurator” for more consistency with existing QMenu class names.
• Bug fixes and code cleanup across the board.

Default configuration file changes

• Added Backface culling Switch Item to Views Menu Set
• Cleaned up and added more useful items to the Marked Params editing menu set
• Added scripting preferences menu over the script editor button. Includes a “Open Plugin Manager” item for faster access to the Plugin Manager.
• Arnold Standin item removed from shading Menu Set, Arnold standins are no longer a separate object in current versions of Arnold.
• Some Cosmetic changes to menu names and item order

Documentation changes

• Updated Softimage buglist  to reflect changes in Softimage 2012. See updated bug list below.
• Fixed some typos.

0.91 – Feb. 10th 201:  Initial public release

Installation

1. Download the QMenu 0.91 addon from http://code.google.com/p/keyvis-dev/
2. Either drag and drop the addon into Softimage, which will install it in your user addons folder, or use File->Install Addon for more options (like installing in a Workgroup).
3. If all went well you should now see a new menu item called “QMenu” appearing in your main menu bar at the top of the Softimage window.
4. Restart Softimage to fully initialize QMenu.
5. Enable QMenu from it’s pull-down menu or from it’s custom preference.
6. Assign display commands (QMenuDisplayMenuSet_0 to 3) to hotkeys of your choice, or define display events if zou don~t want to change your keyboard mapping.

Feature Videos

Workflows and general functionality – What’s already there?

Basic customisation  - The QMenu Editor

Advanced customisation – Scripting

- To be added, probably accompanied by a video.

Terminology

Menu Set

A Menu Set describes the sum of all context-sensitive top-level menus (a maximum of 4) in a Quad menu along with it’s  sub-menus. There can be as many sub-menus as you wish, and they can be nested as deeply as you wish.  Contexts are evaluated before a menu set is displayed on screen to determine which menu should be displayed in each of the four main menu quadrants,  depending on certain conditions (e.g. the type of currently selected objects), so a menu set usually consists of many more menus than those being displayed on screen at any given time. E.g. some menus are only visible when working with Curves, others when working with Polygons, etc.

View

You can associate menu sets with each window or part of a window in Softimage (e.g. main 3d views, the script editor toolbar, shape manager, etc). The window or window areas that have a menu set associated are simply called views. An unlimited amount of menu sets can be associated with any view.

Display Context

These are user-editable scripts assigned to menu sets which always evaluate to either True or False. QMenu ships with a great number of ready-to-use contexts of all kinds and for almost any object type to choose from. Advanced users can use any scripting language to write a display event, or simply use or alter one of the existing ones. All scripting languages are supported, with python being a little faster because the code is executed natively instead of using the ExecuteScriptCode command, which is pretty slow and can lead to slight delays in heavy and complex menus with lots of submenus and therefore lots of contexts to evaluate.

Display Context Example: A display context script may evaluate to True if the selected object is a polygon point. One could now associated a menu with this context that contains only operations suitable for polygon point editing. If there are potentially more than one display contexts evaluating to True in the current menu set for the current view, the menu associated with the first display context evaluating to True will be displayed. Therefore, the order in which display contexts are defined for a given view does matter. This order can be changed at any time by moving display contexts up and down in the Menu Set’s list of menus in a given quadrant to change the order in which they are evaluated. Contexts are evaluated bottom to top.

Menu

A menu contains the actual menu items a user can click on. A menu may have associated script code  which gets executed before the menu is displayed. Advanced users might find this useful to fill a menu with items on the fly (dynamically) depending on certain conditions or content in the scene. Menus usually contain fixed menu items that are saved to, and loaded from, the configuration file at startup or when the user saves or loads the configuration manually. It may also contain temporary (dynamic) menu items which do not get saved to the config file. Such dynamic menu items are usually created through the menu’s associated script code (see above).

Example: A menu could display a list of existing lights in the scene for quick selection or inspection.  Since such menu items are only meaningful in the current scene, they should be stored in the menu’s temporary menu items list so they don’t get saved in the current configuration file by accident once it is saved – the items would most likely not be meaningful in another scene where lights might have different names.

Menu item

These can be :

• Softimage commands (native or custom)

• Other Menus, which are displayed as sub-menus (but no native Softimage menus due to current limitations of the Softimage SDK)

• Scripted Menu Items  and Switches (a special type of scripted item to switch between boolean values, mostly used to change Softimage preference Values from a QMenu).

Display Events  and Display Commands

Changed in 0.95:  Display Events are now called Key Events

Menu Sets can be displayed either by calling one of the predefined custom display commands numbered QMenuDisplayMenuSet_1 to QMenuDisplayMenuSet_3, which can simply be bound to hotkeys, or by defining display events in the QMenu Configurator. Display events are faster to set up and override Softimage’s hotkey assignment for as long as QMenu is enabled. If you prefer regular hotkeys simply bind QMenuDisplayMenuSet_1 (to 4) to keys of your choice using the Keyboard Mapping editor. You may define as many display events as you wish, but we assume that usually no more than four should suffice as it becomes increasingly hard to remember the different keys needed to display different Menu Sets. Hence there are currently also only four QMenuDisplayMenuSet commands available. Should you ever need more, just let us know so we can implement more commands, or you can simply use display events, of which you can add as many as you need without having to alter the QMenu plugin code. You can of course also use a mixture of commands and display events.

Technical Information

Plugin components:

• QPop.32.dll  and QPop.64.dll,  C++/.Net plugins, compiled for Softimage 7.0 to 2011 – 32 and 64 bit. They  implement the QMenuRender command, which renders the menu set described by a string. It returns the menu number and item number clicked by the user.

• QMenuConfigurator.py, a Python plugin, which implements the QMenu Editor for menu configuration, QMenu Custom Preferences, as well as all QMenu object classes, commands, menus and events.

Future development and improvements

Qt-based QMenu editor

Benefits: QMenu elements could be displayed in a tree-like structure in which items could be associated and rearranged by dragging and dropping .  As a result the QMenu  Editor could be massively simplified and streamlined. Many buttons and list widgets would not be needed anymore. -> Increased usability.

Qt-based Menu Sets

Benefits: Immediate execution of items/multiple items/switches from a menu without having to close the menu set, no command needed to render menu, Linux support.

Enable mouse button support for Menu Set invokation

Menu Sets could be invoked using mouse events or a combination of mouse and keyboard events. This is dependent on the implementation of a missing feature that only Softimage/Autodesk can implement, see chapter on “Missing Features,  Bugs and Improvement suggestions” above.

Edit Softimage native menus with QMenu Editor

Ideally, the QMenu Editor would evolve into an Editor that allows to edit all menus in Softimage, not only QMenus. However, this requires not only some redesign and additions to the configurator’s GUI, but also the addition of several Object level methods and commands to access and modify Softimages native menu system. See the “Softimage lacks proper Object Model access to it’s menu system” bug description in the  ”Softimage bugs, SDK limitations and suggestions for improvement” section below.

Scripting Guide

To be filled with content – WIP

• The Context Object
• Scripted Menu Items
• Scripted Switch Menu items
• Scripted Menus
• Scripted Contexts
• QMenu Commands
• QMenu Classes

QMenu bugs and limitations

Please visit  our bug tracker on google code for a list and current status of known bugs, or to report bugs:

http://code.google.com/p/keyvis-dev/issues/list

.

QMenu is open source and can be checked out from google code via Subversion. If you have scripting and/or C++ coding experience, please feel free to contribute to the project by adding features or fixing bugs.

Softimage bugs, SDK limitations and suggestions for improvement

A) Limitations that have a direct effect on QMenu

.) New: Material Manager is not a relational view?

Problem: Rendertree can’t be queried for the embedded Render Tree View, it has no “Views” to iterate over as normal Relational Views should have. Thus it is not possible to find out the currently displayed Render Tree container of the Material Manager.

.) New in 2012: New check mark functionality  does not update in torn-off menus

Problem: When  tearing off a menu that uses the newly exposed checkmark functionality of Softimage 2012 the check mark remains visible even after clicking the menu item and changing it’s state. It seems the menu isn’t updated after clicking.

.) Softimage lacks vital Object Model methods to fully access it’s menu system

The Softimage SDK help file says the following in chapter  ”What Can I Customize with Menus?”: “…Do I Have to Use Self-installing Menu Plug-ins? Yes. While menus can be scripted or compiled, they cannot be created on the fly (in the Script Editor). You must implement your custom menus as a self-installing plug-in using the correct callbacks.” In order to create menus and submenus from data stored in a configuration file (which is essentially what QMenu does, only for it’s own menus and menu items that exist besides the native Softimage menus), above limitation must fall. Additional commands, methods and properties for Menus and Menu Items need to be implemented by Autodesk to get and set menus and menu items callback code, create new menus and menu items and add or append to, or remove from, existing menus.

Benefits: Qmenu Editor could be generalised into Editor for all Menus, not just Qmenus. Qmenu could display and work with native Softimage menus. Qmenus could be created as standard Menus at startup instead of using alternative classes.

.) Some Text Editor attributes cannot be set via Python since XSI 7.0

The following Text Editor attributes cannot be set via Python, they simply have no effect. It does not make a difference whether the Softimage factory Python version or manually-installed Python is used. Example: Setting attributes on the Text Editor “oEditor” after it was added to a custom property…

• oEditor.SetAttribute(c.siUIFolding, True ) #Broken since XSI7.0 #Text folding icons do not appear on left side of Text Editor

• oEditor.SetAttribute(c.siUIKeywordFile, <KeywordsFile”) #No keyword color coding in the editor. Setting keywords explicitly instead of using a file does not work either.

• oEditor.SetAttribute(c.siUICommentColor, 0xFF00FF) #Comments are not color coded either

• oCodeEditor.SetAttribute(c.siUICapability, c.siCanLoad ) #No File->Load menu item in the File menu of the editor

.) Missing command or property to query for high lit objects.

Example: Create a poly object, switch to edge selection mode, but don’t select any edges yet.  Application.Selection() will be empty, even though there is clearly an object we are working with and are focusing on. In Maya, this object state is called “hilite” –  an object is “hilited” when a user can select it’s components. A similar feature is missing in Softimage, it is currently not possible to find out which objects are ready for component selection, i.e. highlighted directly.

.) Update: Timer event  will not wait for Pick sessions in versions prior to Softimage 2012

Thanks to whoever fixed this at Softimage for 2012.

Whenever  a pick session is started from within a Timer the following error is thrown: “COM Error: Unspecified error (0x-7fffbffb)“.

Background: For various reasons we tried to decouple command calling from clicked menu items from the main QMenu chain of commands (which queries for user input, renders menu sets, etc) by delaying any command execution  to after Qmenu is entirely done doing it’s thing (essentially to after menus are closed and control has been returned to Softimage). This would have solved a couple of problems (e.g. the actual command to execute is the last one and thus properly appears in the edit menu as the repeatable item, along with potentially solving the modal PPG bug that prevents QMenu from being fully usable in immediate mode, see our bug tracker for details on those bugs: http://code.google.com/p/keyvis-dev/issues/detail?id=2#c0

Example plugin code: 

import win32com.client

import win32com.server

from win32com.client import constants as c

null = None

false = False

true = True

#==================Plugin Initialisation ====================================

def XSILoadPlugin( in_reg ):

in_reg.Author = “Stefan Kubicek”

in_reg.Name = “PickSessionTest”

in_reg.Email = “ste…@keyvis.at”

in_reg.URL = “mailto:ste…@keyvis.at”

in_reg.Major = 0

in_reg.Minor = 1

in_reg.RegisterTimerEvent( “ExecutePickSession”, 0, 1 ) #Create a timer event that runs only once with a delay of one millisecond

return True

def XSIUnloadPlugin( in_reg ):

strPluginName = in_reg.Name

Application.LogMessage (str(strPluginName) + str(” has been unloaded.”),c.siVerbose)

return true

def ExecutePickSession_OnEvent (in_ctxt):

Application.LogMessage(“ExecutePickSession_OnEvent called”)

Val = Application.GetUserPref(“ScriptingSessionActive”)

Application.LogMessage (“ScriptingSessionActive is: ” + str(Val))

Application.LogMessage(“Starting Pick-Session…”)

Application.PickElement( “CurveBoundary” , “Pick first Curve Boundary”, “Pick first Boundary”, “”, “”, 0, “” )

Application.LogMessage(“Executing code after the Pick-Session…”)

Safe that as a python file and load as Plugin. You will get above error message. However, launching just the pick session line from the script editor works fine, it seems the event just would not wait for the pick session to return.

Application.PickElement( “CurveBoundary” , “Pick first Curve Boundary”, “Pick first Boundary”, “”, “”, 0, “” ) #Works fine from script editor

Rearm timer event like this if needed: Timer = Application.EventInfos( “ExecutePickSession” ) #Find the timer event

Timer.Reset( 0, 1 ) #Reset it to re-execute the code

.) Missing or undocumented “isTearable” attribute or capability flag for menus.

Some menus can be torn off, some don’t. If there is an attribute to enable or disable this functionality on a menu, it is not documented.

.) Update: Undocumented check mark functionality for menu items in versions prior to Softimage 2012

How to make a menu item that has a check mark or dot was undocumented before Softimage 2012.

.) Update: Undocumented View Descriptors in versions prior to Softimage 2012

Examples:  Application.OpenView(“Cache Manager”) opens the Cache Manager, but  “Cache Manager” was nowhere listed as a valid descriptor. The same goes for the “External Files Manager” and others. Documentation was added for 2012.

.) Problems with commands for editing view and camera properties

Softimage applies changes to camera attributes (eg. switching from wireframe to shaded display mode) based on which view the mouse is currently over. Invoking such a command from a QMenu menu that overlaps into another view in such a way that the command’s menu item is located over this other view (and thus also the mouse cursor after the menu item was clicked and the menu closed) will affect this other view instead of the view the menu was called from.

Possible solutions:

A) Autodesk changes the way view commands are handled.

Currently view commands acquire the current view and camera from the current mouse position and change attributes of that camera according to the command called. This would need to be changed so that the command changes the attribute(s) of the currently active view instead of the one under the mouse. To make sure that this still affects the view under the mouse (in order not to break the current behavior) the current view would need to be set according to the current mouse cursor position (view under mouse) prior to calling the command that changes the view attribute. This way the native command would now honor the active view instead of the view under the mouse and could be used in both native Softimage menus and QMenu menus. Alternatively, instead of changing the existing commands, new commands could be added that work along this paradigm. In any way, this can only be provided by Autodesk.

B) Write scripted menu items that mimic solution A described above.

This is what we did for now, check out the scripted menu items of the “Views” category. They work like this: First the active view is switched to the one currently under the mouse when a menu is invoked (actually just before it is rendered) . This is built-in QMenu functionality and not specific to any menu or menu item .  Then the clicked script item’s code is executed, which changes the currently active view or sets camera attributes, depending on what menu item was clicked. However, this is not very elegant or user friendly since already existing native Softimage functionality needs to be mimicked and scripting is required, which most user cannot do. Also, when new commands are added for views (as has happened in Softimage 2011), these changes need to be translated into scripted QMenu items too.

In short: Solution A would be more efficient, elegant and easier to use by users who cannot, or don’t have the time to, script, and in addition reduces maintenance requirements of QMenu for future Softimage versions.

.) Editor Windows are not uniquely identifiable

Problem: It is not reliable to use QMenu in the Render Tree, Texture Editor, and other, multiple-instance-capable editors because such editors are not uniquely identifiable when more than one of a type of such windows is open (e.g. multiple isntances of a Render Tree View).  As a workaround View.Rectangle could be used to iterate over all open windows and compare the values to those acquired via pyWin32, but unfortunately View.Rectangle returns slightly wrong coordinates (they are always off by a several pixels), which prevents the values to be comparable (almost overlapping windows could result in the wrong window to be identified). Also, this command does not exist for SI prior 2011. 

Solution: Implement a command or method that returns the topmost view object under the mouse cursor.

.) Incomplete command set for editing UV’S

Problem: For some of the menu entries in the texture editor there are no command counterparts, most of the logic seems to happen inside menu callbacks that call low-level UV manipulation commands instead.

Solution: The missing commands for each operation callable from the menu should be added.

Problem: The active UV channel(s)  (the one or ones being edited) is/are also query-able through the texture editor only, which makes it harder to use texturing commands outside the Texture Editor context.

Solution: It would be better if the currently active UV set(s) was a property of the object, which proofed to work well in Maya. It would then be possible to even create subprojections in a 3D view, and not necessarily in the Texture Editor only.

.) Commands cannot be flagged as non-repeatable

Problem: QMenu uses several commands to do it’s work, like displaying the menu set for example. Depending on user interaction, sometimes these commands are the last commands executed, which leads them to be displayed as the “Repeat” menu item in Softimage’s Edit Menu. This is not very nice. There are also lots of other commands in Softimage than can be used to do things “behind the curtain” in which the user is normally not interested, and which he would never want to know about, let alone repeat them manually. E.g. GetGlobal and  SetGlobal commands.

Solution: A capability flag for commands (e.g. “siIsRepeatable”)  could be introduced that prevents previously executed commands from showing up in the Edit menu as the repeatable menu item.

.) Custom commands can not be categorized

It is not possible to categorize custom commands, they will always be automatically assigned to the Custom category. Not very tidy or user friendly, especially with lots of custom commands installed. The hotkey editor would be easier to use if custom commands could be properly filtered by category like the factory Softimage commands.

.) OnKeyUp and OnKeyDown events do not support mouse buttons

This would be needed to allow menu set invocation through mouse buttons, or even a combination of mouse button and keyboard buttons events.

.) Update: It’s not possible to query for objects under the mouse in versions prior to Softimage 2012

There is no command or method to query 3D objects currently under the mouse. This functionality already seems to be there as it’s used in native Softimage context sensitive menus, but it’s not exposed yet. In 2012 this is now possible using the Tools Context SDK.

B) Other Bugs and Limitations we found

.) Remove Transform Group behaves unexpected

Behaviour: Calling Remove Transform Group() on objects also deletes non-Transform-Group objects, even when they are not in a Transform group.

Expected behavior: Only Transform Groups above currently selected objects should be removed.

.) Log Commands (CmdLog) preference cannot be disabled through scripting.

Application.SetValue(“preferences.scripting.cmdlog”, False, “”) doe not work. Instead, it will throw a warning that the setting was restored when Verbose Messaging is enabled. This is quite annoying. Preferences should be allowed to be changed via script.

.) Update: It’s not possible to write scripted “tools” in versions prior to Softimage 2012

Tools like the Add Edge Tool cannot be created, there is no interface exposed. E.g. it is not possible to display alternate cursors, or draw widgets, markers or lines in the 3D view. Since 2012 the Tools Context SDK can be used.

.) It’s not possible to get the currently active deformer when painting skin weights

When painting skin weights it is possible to select the deforming object for which weights are to be painted. However, it is not possible to get or set this information via scripting.

.) Paint Tool is not accessible through scripting

The paint tools have no exposed interface, atm they are totally black-boxed. Have a look at Maya or 3dsMax on how many custom tools have been written over the years that make use of painting features. In Softimage this is really sorely missed.

.) It is not possible to set/change the shader ball model on more than one shading node at a time in the Render Tree

When more than one node is selected the submenu to pick a shader ball model is not displayed.

.) Execute Script Code is insanely slow compare to executing the code directly

Application.ExecuteScriptCode () is very slow, it can hardly be used repeatedly in any code that’s performance relevant.

.) Pasting text into the Text Editor widget is incoherent

Pasting into the text editor from e.g. Notepad causes “\n” charcters to be replacd with “\n\r”

.) Some native menu items have no direct command counterpart

Examples: Remove Knot, Extract Edges As Curve, Merges Curves, Align Bezier Handles, Align Bezier Handles Back to Forward, Align Bezier Handles Forward to Back. Some UV editing menu items are also missing  dedicates commands.

.) Some Softimage commands are currently flagged as not hotkey assignable, even though they could perfectly work and make sense when assigned to a hotkey.

Example:  ”Local subdivision”

.) Some Softimage commands have duplicates with the same name

Problem: Using Application.Commands(“<CommandName>”).execute() is not deterministic for duplicate commands since Softimage will execute the first command matching that name. However, it is entirely non-transparent for the user if those duplicate commands really do exactly the same thing (especially for compiled plugins for which there is no source code to inspect), or if there are differences. Most of these commands even have the same GUID, which makes them even harder to differentiate.

Solution: Remove duplicate commands or give them unique names Found commands with duplicates in no particular order (by far not a complete list):

Name                                                            (Number of duplicates)

AlignBezierKnotsTangents                 (8)

InsertCurveKnot                                    (2 occurrences, 3 if you don’t take scripting names into account)

RandomizeMarkedParameters         (5 occurrences)

SetCurveKnotMultiplicity                  (3 occurrences, 4 if you don’t take scripting names into account )

DuplicateSingleMeshComponent    (2 occurrences)

Connect To Texture Support             (2)

Connect to Texture Projection         (2)

Connect to Texture Support              (3, 2 if scritping names are taken into account)

Create Texture Projection                  (3)

Low level Create Image Clip              (2)

Assign Flexible Envelope Locally   (2)

Convert Shape Reference Mode       (2)

CurveDirectManip                                 (2)

DeformByCage                                         (2)

Deform By Cluster Center With Nulls Creation (2,3)

Deform By Spine                                     (2)

Lock Envelope Deformer Weights   (2)

Remove Flexible Envelope                (2)

Select Shape Key                                     (2)

SmoothEnvelopeWighting                  (2)

Store Shape Key                                      (2)

Decrease Manipulator Size                 (2)

Increase Manipulator Size                 (2)

.) Some commands have an empty scripting name

Problem: This makes it impossible to call them via Application.<ScriptingNameOfCommand> (Parameters)

Solution: Define scripting names for the following commands: Cycle Selection Mode, Show Hide Grid, OBJ Import… ,Show Previous Manipulator, Obstalce Pop-up Menu, MoveComponent Tool, Pick Session Tool, Paint Tool, Frame Contextual, Maximize/Restore Current Viewport, 2D Chain Tool, Frame Preview Active Camera, Freeze Selected, Goal Pop-up Menu, Ispect Rendering Preferences, Delete Selected Branch, Mesh Filter, Redo Camera (alternate), Toggle Grid Snap, Zoom In, Invert Polygons, MarkObjectDirty, Frame Selection, Remove Key Hot Key, Delete Selected, Force Pop-up Menu, Transform Set New, Texture Pop-up Menu, Paint Properties, Save Zero Key Hot Key, 3D Chain Tool, Parent Tool, InspectUVW, Toggle Point Snap, Frame All, Move Component Tool, Delete Objects Tool, Slice Polygons Tool, Delete Components, Redo (alternate), Toggle Manipulator mode, Open SE for Link With Deform, Perspective View, Undo (alternate), Dice Object/Polygons, Get default camera, Bottom View, Duplicate/Extrude Multiple, Event Pop-up Menu, Clip, Toggle Proportional, Scene Camera View, Camera Visibility Options, Add property extended, Split Polygon Tool, Undo Camera (alternate), Duplicate/Extrude Single, InspectAllUVW, Particle Type Pop-up Menu, Left View, Isometric View, Add Surface Point Tool, Front View, Open SE on Override parent, Hide Back Facing Polygons, Turn ON Interactive SRT, Turn OFF Interactive SRT, Modify Texture Pop-up Menu, Save Key Hot Key, Add Polygon Tool, Toggle AutoKey, Toggle Curve Snap, Polygon Cluster Visibility Property, Move Joint Tool, Rectangle Select Tool, Lasso Select Tool, Raycast Select Tool, Activate Group/Cluster Select Tool using Filter, Center Selection, Escape Pick Session, Add Edge Tool, Show Next Manipulator, Subdivide, Paint Tool, Back View, Emission Pop-up Menu, DoNothing, Rectangle Raycast Select Tool, Top View, Right View, XYZ Transform, Toggle Pixel Zoom, Triangulate, Zoom Out, Activate Current Select Tool using Filter, Escape Pick Session, Toggle Snapping, Toggle Field Guide, Freeform Select Tool

.) Commands not supporting key assignment are still listed in the keyboard mapping command list

Problem: Commands flagged as not supporting key assignment appear in the hotkey editor. Should they better not be listed? There is usually a reason to flag a command as not assignable.

Solution: Only show commands supporting key assigment in the list

.) NURRBS modeling error prone or freezing Softimage

Problem: Many NURBS modeling operations are unreliable or can freeze Softimage

• Fillet Surfaces freezes XSI when setting too low a Start Radius value
• Trim by Projection does not always produce a proper trim when moving trim curve (sometimes only on back side)
• Open/Close Surface freezes XSI when closing both u and v on a cylinder
• Snip crahses XSI when selecting two Iso curves on a surface, call Snip, then adjust the Position parameter (which will set both positions to the same value, freezing XSI
• Snip crashes XSI when selecting an opened cone surface and calling Snip, then adjusting the snip parameter

Solution: Refactor NURBS modeling commands, maybe also operator PPG to prevent potentially dangerous values from being entered.

.) The “Package Location” feature does not support packing a workgroup folder into an  xsiaddon

Packing an xsidaddon using the pack location feature is unnecessarily cumbersome because only user Addon folders can be packed, but no Workgroup folders.