3D SDK and Scripting Mayhem

3ds Max and Stage Automation

Christopher Diggins — Mon, 06 May 2013 14:47:58 UTC

Stage automation is a growing industry that plays an important role in live entertainment events from music shows to Cirque du Soleil. What may come as a surprise is that thanks to a plug-in from Stage Technologies 3ds Max is playing an increasingly important role in designing, simulating, and visualizing automation for live events.

Stage Technologies is an Australian company specializing in live event automation, they sell a number products for managing and controlling numerous types of live event automations. Among their products is a 3ds Max plug-in called Sculptor Animation Toolkit. Sculptor toolkit turns 3ds Max into a tool for designing and preview automation and to receive feedback on what movements are impossible or dangerous. Once ready Sculptor Toolkit data can be sent directly from 3ds Max to the eChameleon automation software.

As an example Sculptor Toolkit can be used to define a trolley that travels along a track, add a revolving ring hanging from it, then add some winches below the revolving ring as linear axes; these winches might then act as pickups in a larger bridled system. Flight paths, either drawn or sourced from recorded joystick data can be imported and supplementary feedback is provided to the operator when refining these paths, ensuring the flown move will run safely.

The following video shows Sculptor Toolkit in action.

[video]http://www.youtube.com/watch?v=t3XW2Pq8LxQ[/video]

3ds Max and the Sculptor Toolkit have been used together to design and visualize live event productions from RadioHead to the Pan-American games opening ceremony to animating a giant robotic Gorilla for an upcoming musical about King Kong.

[video]http://vimeo.com/57498670[/video]

For more information on Sculptor Animation Toolkit see http://www.stagetech.com/press/sculptor-animation-toolkit.

3ds Max and Flash Working Together

Christopher Diggins — Tue, 23 Apr 2013 01:04:08 UTC

You may be familiar with FarmVille 2: it is currently the second most popular app on FaceBook with over 40,000,000 estimated monthly users (as of the date of this posting). What you may not know is that FarmVille is built using the Flare3D engine and 3ds Max.

The following video talks about the role of 3ds Max in FarmVille 2:

[video]http://www.youtube.com/watch?v=8iBjwLHyag4[/video]

This next video talks about the role of Flare3D in FarmVille 2:

[video]http://www.youtube.com/watch?v=nnNKko2ELKQ[/video]

Flare3D is a 3D engine that leverages a relatively new Flash technology called Stage3D (previously known as Molehill) to deliver GPU accelerated 3D graphics called Stage 3D. You can try Flare3D and the 3ds Max exporter for free here. The following video demonstrates the Flare3D exporter for lightmaps:

[video]http://www.youtube.com/watch?v=IG5acCdnz00[/video]

A popular open-source 3D engine for Flash is Away3D. The following video is the Away3D Demo reel presented at GDC:

[video]http://vimeo.com/62962084[/video]

Zynga, the makers of FarmVille 2, use Away3D in another popular Facebook game called Café World. Away3D was also used to build interactive 3D web applications to promote the Renault Megane and the Nissan Juke.

[EDIT: Rob Bateman from Away3D suggest that people also check out the Nissan Juke 3D configurator as it better showcases Away3D functionality, but unfortunately for me it only works on Google Chrome.].

One use case of 3ds Max and Away3D that I found particularly interesting was this iPad app (built with Adobe AIR) for a condo project called the Clarence.

There is a tutorial on the Adobe website for step by step instruction on how to create an interactive 3D application for 3ds Max using Away3D. If you want you can also download an Away3D exporter project Away3D file format (AWD) project on Google code.

3ds Max SDK and MAXScript CHMs now available

Christopher Diggins — Sat, 20 Apr 2013 13:47:26 UTC

We discontinued CHM support for SDK documentation two releases ago in order to focus on HTML-based help. However since many users asked us for CHMs on the 3ds Max feedback forums: http://3dsmaxfeedback.autodesk.com/forums/80701-sdk-and-scripting-enhancements/suggestions/2099795-compiled-maxscript-reference-chm- we have decided to bring back CHM for the 3ds Max SDK and MAXScript.

Check out the new help on our updated SDK help page at: http://www.autodesk.com/me-sdk-docs.

Sell or Share your Plug-ins, Tutorials, or other Content for 3ds Max and Maya via the Autodesk Exchange

Christopher Diggins — Fri, 19 Apr 2013 14:04:13 UTC

With the release of Maya 2014 and 3ds Max 2014 the Autodesk Exchange site makes it easier for plug-in, content, and tutorial developers to distribute and sell their content more easily to Autodesk customers.

The Autodesk Exchange for 3ds Max can be found at: http://apps.exchange.autodesk.com/3DSMAX/Home/Index
The Autodesk Exchange for Maya can be found at: http://apps.exchange.autodesk.com/MAYA/Home/Index

Both Maya 2014 and 3ds Max 2013 have direct links to the exchange app store from within the product under the help menu. In Maya go to "Help > Exchange Apps" in the main menu. In 3ds Max go to "Help > Autodesk Product Information > Exchange Apps".

According to the Autodesk Exchange developer center "apps" aren't restricted to plug-ins, and can be anything a customer will find useful. For example:

Plug-ins
Standalone applications
Training tutorials
E-books
Content

Note that at the current time there is no cost to sign-up and Autodesk is currently taking no commission, but may do so in the future. For more information on that see the Publisher FAQ.

If you have enough information and want to get started publishing your content for 3ds Max or Maya, you can go directly the following links:

Happy content publishing!

Embedding Qt Content in a 3ds Max Dockable Frame

Christopher Diggins — Thu, 04 Apr 2013 16:22:18 UTC

The 3ds Max API provides a custom Windows control called a CUIFrame that allows a plug-in developer to create dockable content. As part of a recent investigation I decided to figure out how to embed a Qt C++ dialog CUIFrame in CUIcontent. I created a helper class called "DockableWindow" that can be used as follows:

DockableWindow* DoStuff()
{
    DockableWindow* dock = DockableWindow::Create(_T("My QT Demo"));
    HWND h = dock->GetHWND();
    dlg = new QWinWidget(h);
    Ui::Dialog().setupUi(dlg);
    dock->SetWidget(dlg);
    return dock;
}

Here is the implementation of the DockableWindow class.

class DockableWindow  
        : public CUIPosData, public CUIFrameMsgHandler 
    {
    HWND h;
    ICUIFrame* frame;
    QWidget* w;
    CUIPosData posData;

    DockableWindow(HWND hwndCuiFrame) 
            : h(hwndCuiFrame), w(NULL), frame(NULL) 
        {
        frame = ::GetICUIFrame(h);
        frame->InstallMsgHandler(this);
    }

    void ResizeFrameToContent() {
        RECT r = {0};
        if (w == NULL) return;
        GetWindowRect(h, &r);
        MoveWindow( h, r.left, r.top, w->width(), w->height(), TRUE );
    }

    void ResizeContentToFrame() {
        if (w == NULL) return;
        RECT r = {0};
        GetWindowRect(h, &r);
        int width = r.right - r.left;
        int height = r.bottom - r.top;
        w->resize(width, height);
    }

    virtual int GetWidth(int sizeType, int orient) { 
        switch (sizeType) {
        case CUI_MIN_SIZE: return 50;
        case CUI_MAX_SIZE: return 10000;
        }
        return w->width(); 
    }

    virtual int GetHeight(int sizeType, int orient) { 
        switch (sizeType) {
        case CUI_MIN_SIZE: return 50;
        case CUI_MAX_SIZE: return 10000;
        }
        return w->height(); 
    }

public:

    enum DockFlags {
        Top = 1 << 0,
        Bottom = 1 << 1,
        Left = 1 << 2,
        Right = 1 << 3,
        Horizontal = Left | Right,
        Vertical = Top | Bottom,
        All = Horizontal | Vertical,
    };

    virtual ~DockableWindow() {
        ::ReleaseICUIFrame(frame);
        delete w;
    }

    static DockableWindow* Create(MCHAR* name, DockFlags pos = All, DWORD initialPos = 0, 
        bool isDockedInitially = false, bool resizable = true, bool visible = true) {        
        HWND h = ::CreateCUIFrameWindow(
                    ::GetCOREInterface()->GetMAXHWnd(), name, 0, 0, 0, 0);
        if (!h) return NULL;
        DockableWindow* r = new DockableWindow(h);
        ICUIFrame* f = r->GetICUIFrame();
        DWORD flags = pos | CUI_FLOATABLE;
        if (resizable) flags |= CUI_SM_HANDLES;
        f->SetPosType(flags);
        if (isDockedInitially) r->Dock(initialPos);
        f->Hide(visible ? FALSE : TRUE);
        return r;
    }

    virtual int ProcessMessage (UINT message, WPARAM wParam, LPARAM lParam) {
        switch (message) {
        case CUI_POSDATA_MSG: {
                CUIPosData **cpd = (CUIPosData **)lParam;
                cpd[0] = this;
                return TRUE; 
            }
        case WM_SIZING: 
            ResizeContentToFrame();
            return FALSE;
        }
        return FALSE;
    }

    bool HasWidget() {
        return GetWidget() != NULL;
    }

    QWidget* GetWidget() {
        return w;
    }

    void SetWidget(QWidget* w) {
        delete(this->w);
        this->w = w;
        if (w == NULL) return;
        w->move(0, 0);
        ResizeFrameToContent();
        w->show();
    }

    void Dock(DWORD location) {
        if (location & Top) GetCUIFrameMgr()->DockCUIWindow(h, Top);
        else if (location & Bottom) GetCUIFrameMgr()->DockCUIWindow(h, Bottom);
        else if (location & Left) GetCUIFrameMgr()->DockCUIWindow(h, Left);
        else if (location & Right) GetCUIFrameMgr()->DockCUIWindow(h, Right);
    }

    void Float() {
        GetCUIFrameMgr()->FloatCUIWindow(h);
    }

    HWND GetHWND() {
        return h;
    }

    ICUIFrame* GetICUIFrame() {
        return frame;
    }
};

For more information see the QWinWidget Qt class and the following 3ds Max SDK classes:

Christopher's Thoughts on Technical Debt

Christopher Diggins — Wed, 13 Mar 2013 13:59:43 UTC

Manny Lehman’s Law

A well-known occurrence in software development is that as software evolves it structure deteriorates. This is called Manny Lehman’s law:

"As an evolving program is continually changed, its complexity, reflecting deteriorating structure, increases unless work is done to maintain or reduce it." — Meir Manny Lehman, 1980

The Technical Debt Metaphor

Ward Cunningham first used a metaphor of debt to describe how certain software development practices can accelerate the deterioration of software in an experience paper for OOPSLA 92:

"Although immature code may work fine and be completely acceptable to the customer, excess quantities will make a program unmasterable, leading to extreme specialization of programmers and finally an inflexible product. Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite. Objects make the cost of this transaction tolerable. The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object- oriented or otherwise." - Ward Cunningham, 1992

The Impact of Technical Debt

Since technical debt means an increase in overall system complexity this results in an increase in:

number of defects
defect complexity
defect fix time
cost to implement new feature
cost to address technical debt

The last point should drive home just how appropriate the debt analogy is, since like financial debt, technical debt will compound over time until it cripples development!

Kinds of Technical Debt

Generally speaking technical debt can be anything during the software development process that slows down a developer’s productivity. For example a bug fix in one module may have unintended consequences in other modules because previous work caused a tight coupling between the two modules; or perhaps removing a feature takes far longer than expected because the code is scattered among multiple modules due to poor code cohesion.

Technical debt can be categorized in the following types:

Process Debt – Processes become more complex and inefficient over time. Examples include builds, automated tests, check-ins, reviews, bug logging, bug tracking, etc.
Code Hygiene Debt – Examples included duplicated code, dead code, inadequate documentation, monolithic classes, inconsistent style, and cryptic symbol names.
Architectural Debt – Examples include high coupling of components, poor cohesion, poorly understood modules and systems, redundant systems, and unused systems.
Knowledge Debt – As products grow in complexity and team members come and go knowledge that is not written down gets lost. It takes longer for developers to become familiar with the inner workings of different systems. This can lead to cases where existing features are re-implemented.

When Technical Debt approaches Bankruptcy

Some signs that your project is nearly bankrupt with technical debt:

Fixing bugs regularly causes regressions
It is hard for developers predict what the effect of making a change to code will have
There are many duplicated systems
Developers are demoralized and disengaged
Simple changes to the software take a long time to make
It takes a long time before new team member can contribute to the project in a meaningful way
Losing a single developer devastates the team and product development plans; this is a sign of extreme specialization mentioned by Ward Cunningham

Software Development Misconceptions

Many programmers have some misconceptions that poor sofrware development practices are necessary for rapid software development. It is common to hear among developers statements like:

I don’t have time to document or test my code
I didn’t write that module
It is easier for me to write a brand new module than upgrading the existing one
I don’t understand that code so I’m not going to touch it
Cutting and pasting code is quicker
Shorter variable or function names saves me time typing
I don’t have time to break up the long function into several smaller ones.
I’ll go back and improve/fix/document/test it later
It is the QA responsibility to find bugs in my code
Anyone can tell what I’m doing from reading the code
I don’t care if someone understands it, it works.

These reasons and more are often used to justify a quick and dirty coding approach; however often what is quick in the short term only means quick to write and check-in. The total time it costs an organization to deal with the dirty code is often much longer than if the developer just followed good code.

Good software development practices can become nearly effortless with a bit of retraining. An intentional and good-faith effort has to be made to learn and to follow good coding guidelines for a period of time.

Mitigating Technical Debt

Technical debt is virtually impossible to avoid altogether, but there are several steps that a development team can take to minimize its introduction:

Agree and adhere to coding guidelines
Document the code and architecture
Always provide tests and samples for new features
Try to update and reuse existing systems, rather than introducing new similar system
If a new system has to be introduced that replicates functionality of an existing system, then the old system should be updated to use the new one
Conduct architecture reviews of proposed modules, features
Refuse to admit code into the code-base that violates the guidelines.
Use tools to detect violation of coding guidelines
NEVER cut and paste code: introduce a new function or class.

Reducing Technical Debt

The following are some ideas for how reducing technical debt

Delete code – The easiest way to refactor code is to remove it; find features that can be removed.
Address the biggest debt first – Areas of the software that impede developers the most should be addressed first.
Merge systems – If there are multiples systems doing similar things they should be merged into one.
Don’t be afraid to break things - As Jeff Atwood says “don’t be afraid to break things: paying off technical debt means refactoring code and taking risks. If refactoring is done properly it should be easier to identify and fix bugs, afterwards."

Last Words

Technical debt if left unaddressed will crush a project and the morale of the people working on it. Don't put your head in the sand regarding technical debt, confront it head on!

I'd love to hear your thoughts about this article and technical debt in general.

JSON Scene Description Language

Christopher Diggins — Thu, 14 Feb 2013 15:11:29 UTC

Today I'm presenting the first public draft an informal specification for a 3D scene description language designed specifically for web-services called the JSON Scene Description Language. I've tried to come up with a specification that is similar in spirit to JSON: as simple as possible, extremely generic, and very useful.

I'd appreciate any feedback you can provide, thanks!

JSON Scene Description Language

Draft Version, February 14th, 2013
by Christopher Diggins, Autodesk

Summary

JSON Scene Description Language (JSDL) is a specification for transmitting descriptions of 3D scenes via web services.

Introduction

Traditional representations of 3D scenes are monolithic static file formats (for example FBX and COLLADA) which do not lend themselves well to transmission over a network or for consumption by light-weight clients such as web-browsers.

JSDL is a specification for describing a scene hierarchy and the various scene elements (assets) contained within it. JSDL is open-ended in that it does not specify how to represent scene elements themselves. JSDL is compatible with any format for representing geometry, texture maps, materials, animation, particle effects, etc.

An important advantage of JSDL is that it supports multiple representations of the same scene element. An example of how this can be useful would be if a web-service wanted to present a custom binary mesh formats to certain clients that can support it, but to present more generic represesentations to other clients.

Overview

JSDL consists of the following parts:

Scene record - A JSON record describing a scene. It contains a scene graph and an array of asset descriptors.
Scene graph - A JSON representation of a tree of scene nodes. Each node has a transform, and may refer to one or more child objects.
Asset descriptors - An asset descriptor is a JSON record that contains meta-information about an asset and an array of the representations available.
Assets - An asset is a constituent part of a scene. An asset can be any kind of data. Typical examples of assets in 3D scenes include geometry, texture maps, materials, cameras, particle effects, animation tracks, and more.
Asset representations - An asset can have one or more representations. Each asset representation type has an identifier similar to a MIME type.

Asset URL

An asset is identified using a URL of the form:

[<scene_url>/]<asset_id>[/<asset_representation_id>]

The scene URL component is optional, if it is omitted then the asset ID is assumed to belong to the current scene. The asset ID component identifies the scene element (the "resource"). The asset representation ID component is also optional; if it is omitted then the JSON asset descriptor record is returned.

Scene Object

The scene object is a JSON object that describes a scene hierarchy and contains a list of all assets descriptors.

scene : {
  id : string,
  roots : [node],
  camera : string,
  assets : object,
}

The identifier is a string that can only contain letters, digits, and the underscore character, and cannot start with a digit. The roots field contains the top level scene nodes (i.e. those with no parents). The camera field is an optional asset URL or identifier that indicates the default camera. The assets field is an a dictionary of asset descriptors. Each asset key is an asset identifier that consists of letters, numbers, the "_" character, or the "-" character.

Scene Graph Node

A scene graph node:

node : {
  transform : [float],
  assets : [string],
  children : [node],
}

The transform is an optional four by four matrix indicating the nodes offset from the parent. The assets field is an array of asset URLs or asset identifiers. The children field contains an array of child nodes.

Asset Descriptor

The asset descriptor is a JSON record that identifies an asset and lists the avaialable representations.

asset : {
  representations : [string],
  default : { 
     type : string,
     value : object,
  }
}

The representations field is an array of asset representation type identifiers. A default representation may be embedded in the asset descriptor record if it is a JSON object. The "default.type" field is the type identifier, and the "default.value" is the JSON object.

Asset Representation Type Identifier

The asset representation type identifier is similar in concept to a “mime-type”. It is a string that represents a particular type of data. The asset representation identifier should start with a letter, and can consist of letters, numbers, and the '.' character.

Appendix: Predefined Asset Representation Type Identifiers

JSDL does not require specific asset representations, or representation identifiers. The following are some recommended identifiers for common asset representation types:

3ds – .3ds file, a legacy 3D Studio DOS file format (http://en.wikipedia.org/wiki/.3ds )
alembic – Alembic 3D data interchange format (http://code.google.com/p/alembic/)
autodesk.dwf – Autodesk design web format (http://en.wikipedia.org/wiki/Design_Web_Format)
autodesk.dwg – CAD file format compatible with AutoCAD (http://en.wikipedia.org/wiki/.dwg)
autodesk.dxf – Autodesk design exchange format (http://en.wikipedia.org/wiki/AutoCAD_DXF)
autodesk.fbx.binary – FBX binary format
autodesk.fbx.text – FBX ASCII format
autodesk.max – Autodesk 3ds Max file
autodesk.maya.text – Autodesk Maya ASCII file
autodesk.maya.binary – Autodesk Maya Binary file
autodesk.softimage – Autodesk Softimage file
awd – Away3D binary format (http://code.google.com/p/awd/)
collada – COLLADA file format ( http://www.khronos.org/collada/ )
image.bitmap – Bitmap file (http://en.wikipedia.org/wiki/Bitmap)
image.jpg – JPEG file format (http://en.wikipedia.org/wiki/Jpeg)
image.gif – Graphics Interchange file format (GIF) (http://en.wikipedia.org/wiki/Gif)
image.tif – Tagged Image File Format (TIFF) (http://en.wikipedia.org/wiki/Tagged_Image_File_Format)
image.png – Portable Network Graphics format (http://en.wikipedia.org/wiki/Portable_Network_Graphics)
ply – Stanford triangle format ( http://en.wikipedia.org/wiki/PLY_(file_format) )
stl.binary – STL binary file ( http://en.wikipedia.org/wiki/STL_(file_format))
stl.text – STL ASCII file ( http://en.wikipedia.org/wiki/STL_(file_format) )
threejs.camera.json – Three.JS camera object
threejs.geometry.json – Three.JS geometry object
threejs.light.json – Three.JS light object
threejs.material.json – Three.JS material object
wavefront.mtl - Wavefront .MTL file ( http://en.wikipedia.org/wiki/Wavefront_.obj_file )
wavefront.obj – Wavefront .OBJ file ( http://en.wikipedia.org/wiki/Wavefront_.obj_file )

The various threejs.X.json representations are defined as those formats that can be loaded by the Three.JS JSON loader.

Appendix: Example JSDL

The following is a JSDL file describing a scene with two instances of a square with a side of length 2.0. The second square is offset from the first square by [3, 4, 5].

The default representation of the square is a Three.JS compatible JSON format, the alternative formats are a Wavefront OBJ ASCII file format, and the Alembic binary format.

{
  "id" : "my_scene"
  "roots" : [  
    { 
      "assets" : ["Square"],
      "children" : 
      [
         "transform" : 
         [
            1, 0, 0, 3,
            0, 1, 0, 4,
            0, 0, 1, 5,
            0, 0, 0, 1
         ]
         "assets" : ["Square"],
      ],
    }
  ],
  "assets" : [
    "Square" : {
        "representations" : [
           "threejs.geometry.json", 
           "wavefront.obj", 
           "alembic"],
        "default" : { 
            "type" : "threejs.geometry.json",
            "value" : {
                "vertexes" : [
                    [-1, 1, 0],
                    [1, 1, 0],
                    [1, -1, 0],
                    [-1, -1, 0],
                ],
                "faces": [
                    [3, 2, 1],
                    [3, 1, 0],
                ]
            }
        }    
    }  
}

If this JSDL scene is hosted on a URL such as http://test.autodesk.com we would then be able expect the following URLs to exhibit specific behavior:

http://test.autodesk.com/my_scene - This would return the above JSON object.
http://test.autodesk.com/my_scene/Square – This would return the “assets.Square” JSON object.
http://test.autodesk.com/my_scene/Square/threejs.geometry.json – This would return the “assets.Square.default.value” JSON object.
http://test.autodesk.com/my_scene/Square/wavefront.obj - This would return an .obj text representation of the square object.
http://test.autodesk.com/my_scene/Square/alembic - This would return an alembic binary representation of the square object

Acknowledgements

A special thank you to Aaron Tarnow at Autodesk for reviewing this specification and his enthusiastic support. Thanks to Stephen Taylor, Robert Goulet, Andre Gauthier, Mark Davies, and Mathieu Mazerolle at Autodesk, Grayson Lang at Adobe, Paul Brunt of GLGE, and Rob Bateman of Away 3D. This specification would not be possible if they didn't generously share their knowledge and experience.

Creating a Procedural Tree in MAXScript

Christopher Diggins — Thu, 31 Jan 2013 18:59:31 UTC

The following is a two-part MAXScript video tutorial produced by the Autodesk 3ds Max YouTube learning channel. This is a beginner level introduction to MAXScript that will show you how to create, move, scale, and rotate objects. You'll learn how to create animations, use the for loop, and create random variations.

[video]http://www.youtube.com/watch?v=ZoIY5lT6IV4[/video]

[video]http://www.youtube.com/watch?v=NxI-ru5yAa0[/video]

Maya 2013 Extension 2: .NET and more

Christopher Diggins — Wed, 23 Jan 2013 18:24:37 UTC

A .NET API for Maya

Cyrille Fauvel from the Autodesk Developer Network gave the first public sneak peek of a .NET API for Maya back in December on his blog. I'm pleased to announce that it is now a reality for our subscription customers with the release of the Extension 2 Maya 2013 on the subscription site.

For fun here is a sample Hello World plug-in for Maya written in C#:

using System;
using Autodesk.Maya.Runtime;
using Autodesk.Maya.OpenMaya;

[assembly: MPxCommandClass(typeof(MayaNetPlugin.helloWorldCmd), "helloWorldCmd")]
[assembly: ExtensionPlugin(typeof(MayaNetPlugin.helloWorldPlugin), "Autodesk", "1.0", "Any")]

namespace MayaNetPlugin
{
    public class helloWorldPlugin : IExtensionPlugin
    {
        bool IExtensionPlugin.InitializePlugin() { return true; }
        bool IExtensionPlugin.UninitializePlugin() { return true;  }
        String IExtensionPlugin.GetMayaDotNetSdkBuildVersion()  { return ""; }
    }

    public class helloWorldCmd : MPxCommand,IMPxCommand
    {
        public override void doIt(MArgList argl)
        {
            MGlobal.displayInfo("Hello World\n");
        }
    }
}

Of course it gets much more interesting than that since there is support for docking WPF windows in Maya, and for using LINQ. Here is an example of how LINQ can be used to query the dependency graph for all selected objects with a mesh:

var meshes = from p in new MSelectionList()
             where p.hasFn(MFn.Type.kMesh) 
             select new MFnMesh(p);

In the Maya devkit/dotnet folder though you can find over 60 sample .NET plug-ins ported from the C++ API. For more information on the Maya .NET API you should check out the documentation.

Also note that the Autodesk Developer Network has made a C# plug-in wizard available on the Maya developer center page.

SDK Documentation Improvements

There has also been a number of improvements to the SDK documentation:

The Writing a Deformer Node chapter has been updated.
The Manipulators chapter has been updated.

For detailed information on the changes in the SDK and SDK documentation see the What's New in Extension 2 for Maya 2013 topic. There is also some information about other improvements to the Maya 2013 Extension 2 in the Maya user documentation.

SDK Documentation Translator Widget

Finally is a special treat for Maya users who don't speak English as a first language: the addition of a Microsoft Translation widget to the SDK documentation. This is a pilot project, that we first tried on Gameware customers and that we are now rolling to the larger audience of Maya SDK users.

I'd appreciate hearing your feedback regarding any or all of these improvements.

A very gentle introduction to MAXScript for Artists

Christopher Diggins — Thu, 17 Jan 2013 18:45:04 UTC

Embedded in one of the over 200 videos on the Autodesk 3ds Max learning channel on YouTube is a very practical introduction to MAXScript for people with no programming experience. At about 4 minutes into a video on using MassFX Amer shows how to use MAXScript to automate changing a property on over 300 objects. What is great about this is that Amer takes the time to explain everything that he is doing without assuming the audience is familiar with MAXScript.

What he shows introduces several basic concepts:

Using the MAXScript recorder to discover the necessary code how to change a desired property
What the "$" symbol means (currently selected object)
How to change a property of all objects in the currently selected set

Its a great example of how one line of MAXScript code can save an artist a lot of wear and tear on their wrist!

For convenience here is the video in its entirety.

[video]http://www.youtube.com/watch?v=nmdEMpblRqg[/video]

Creating an Undoable Python Command for Maya

Christopher Diggins — Tue, 15 Jan 2013 21:22:29 UTC

Autodesk's Maya learning channel on YouTube has released a new tutorial on how to make an undoable command plug-in for Maya using Python. The command creates a swarm of particles in a turbulence field.

Some of the commands demonstrated:

Some of the classes used:

You can download the code from the tutorial here.

[video]http://www.youtube.com/watch?v=BZyXe3MhEyI[/video]

Cross Platform C# Game Development with MonoGame

Christopher Diggins — Wed, 09 Jan 2013 17:13:41 UTC

I am (or rather was) a big fan of XNA, Microsoft's C# game development framework, and I had high hopes for it. I was particularly enthusiastic when Silverlight started supporting a subset of it. Unfortunately Microsoft has given no indication (as far as I am aware of) that they will be supporting XNA for Winows 8 Metro and Silverlight is apparently not being supported on Windows 8 metro. There have been a lot of speculation around the future of C#-based game development for Windows on various threads. For an interesting and informed discussion on the topic see this topic on gamedev.stackexchange.com.

When I first read the thread on GameDev several months ago I had skimmed past a post talking about an open-source project called MonoGame. Today I revisited the MonoGame web-site and I was impressed with the number of downloads, positive reviews, and the general momentum of the project.

Here is the MonoGame mission statement:

MonoGame is an Open Source implementation of the Microsoft XNA 4 Framework. Our goal is to allow XNA developers on Xbox 360, Windows & Windows Phone to port their games to the iOS, Android, Mac OS X, Linux and Windows 8 Metro. PlayStation Mobile development is currently in progress.

Imagine writing applications and games for all of those platforms at once in C#? Wouldn't that be amazing! To be honest I'm generally very skeptical when it comes to the success of open-source projects, but this group seems to be doing everything right. I also like their approach of building upon mature open-source projects like OpenTK and SlimDX.

However, what reaslly sold me were the trailers for ARMED! from SickHead games. This awesome looking game has been ported to Windows 8 Metro and Windows 7 Phone using MonoGame. I'm curious about the success they will have porting to other platforms!

At least for now I've become optimistic and enthusiastic about the prospect of serious game development in C# once again.

[video]http://www.youtube.com/watch?v=T4bEWO4-I2A[/video]

An Introduction to MAXScript

Christopher Diggins — Fri, 04 Jan 2013 20:57:03 UTC

This is a MAXScript tutorial in the form of a MAXScript program that you can download and run. The program demonstrates a simple procedural animation of a walking stick-figure and an animated camera associated with the viewport. For more information on some of the concepts used in this script the following links will bring you to the relevant online MAXScript documentation:

Here is the source code of the program.

/*
MAXScript Tutorial

This script demonstrates creating a procedural animation using MaxScript. 
It generates a simple stick man from cylinders and a sphere, and animates 
him in a simple walk cycle.

Other concepts demonstrated include:
* Create simple primitives
* Link objects
* Create animation frames
* Set node transform properties in local coordinate space. 
* Use the sine function to achieve smooth back and forth motion
* Creating a camera with a target and rotating it
* Setting the active viewport, and associating it with a camera
*/

/* Clear the scene */
delete objects

/* Initialize variables to help define the objects */
armlength     = 15
leglength     = 15
armradius     = 2
legradius     = 2

/* Create Body Parts */
body        = cylinder radius:5 height:20 
leftarm     = cylinder radius:armradius height:armlength 
rightarm    = cylinder radius:armradius height:armlength 
leftleg     = cylinder radius:legradius height:leglength 
rightleg    = cylinder radius:legradius height:leglength 
head        = sphere radius:5 

/* Set the arm positions */
leftarm.pos.x     = -body.radius - armradius
rightarm.pos.x    = body.radius + armradius
leftarm.pos.z     = body.pos.z + body.height 
rightarm.pos.z    = body.pos.z + body.height 

/* Set the leg positions */
leftleg.pos.x     = leftarm.pos.x
leftleg.pos.y     = leftarm.pos.y
rightleg.pos.x    = rightarm.pos.x
rightleg.pos.y    = rightarm.pos.y

/* Rotate the arms and legs by 180 degrees so that they point downwards */
leftarm.rotation.x_rotation     = 180
rightarm.rotation.x_rotation    = 180
leftleg.rotation.x_rotation     = 180
rightleg.rotation.x_rotation    = 180

/* Set the head location */
head.pos.z         = body.pos.z + body.height + head.radius

/* Link the body parts to the body */
leftarm.parent  = body
rightarm.parent = body
leftleg.parent  = body
rightleg.parent = body
head.parent     = body

/* Move the body up so the legs are aligned to the x/y plane. */
body.pos.z = leglength

/*
Animate the body to move along the local Y axis a small amount per frame
The "animate on" context expression automatically creates 
key frames when animatable properties are modified
*/
animate on (
    for t = 0 to 100 by 5 do (
        /* 
	    The "at time" context expression gets/sets animatable properties at a specific time frame.
        */
        at time t (        
            /* Assure that transforms occur in the node's local coordinate system */
            in coordsys local (
                move body [0, -2.5, 0]
            )
        )
    )
)

/*
Rotate arms and legs
In order to get the movement to change direction smoothly I use a sine function: 
*/
animate on (    
    swingArc = 45  /* The number of degress each arm and leg swings */
    spd = 10       /* Controls the speed at which the swing occurs */

    for t = 0 to 100 by 5 do (
        at time t (
            leftarm.rotation.x_rotation  = sin (t * spd) * swingArc + 180
            rightarm.rotation.x_rotation = sin (t * spd + 180) * swingArc + 180
            leftleg.rotation.x_rotation  = sin (t * spd + 180) * swingArc + 180
            rightleg.rotation.x_rotation = sin (t * spd) * swingArc + 180
        )
    )
)

/* Create a free camera targeted to the body */
cam = freeCamera pos:[100, -100, 50]
cam.target = body

/* Set the lower-right viewport as the active viewport */
viewport.activeViewport = 4

/* Associated the active viewport with the camera */
viewport.setCamera cam

/* Animate the camera around the origin while moving up. */
animate on (
    for t = 0 to 100 do (
        at time t (
            /* Rotate about the z_axis at the origin 
            Uses the "about" context expression to set the pivot to perform rotations.
            */
            about [0, 0, 0] ( rotate cam 1 z_axis )            
            /* Move the camera upwards */
            move cam [0, 0, 1]
            /* Update the roll_angle controller of the camera so that we stay level with the x/y plane */
            cam.transform.controller.Roll_Angle.controller.value = 0
        )
    )
)

Project Sci-Viz: Molecular Graphics in 3ds Max

Christopher Diggins — Fri, 23 Nov 2012 19:27:56 UTC

Project Sci-Viz

Project Sci-Viz is a preview on Autodesk Labs of experimental technology we developed to enable popular molecular graphics toolkits written in Python, namely ePMV and autoPack, in Autodesk 3ds Max 2013. Previously ePMV and autoPack technology were only available to users of Autodesk Maya or certain other software packages that shall remain nameless on my blog.

The ePMV tool allows a user to download molecular recipes from various online databases such as the Protein Data Bank (PDB) and display various representations of them within the host 3D modeling tool.

The autoPack and cellPack tool is based on volume filling algorithms, that are useful for packing molecules into cells with biologically relevant interactions to populate massive cell models with atomic or near-atomic details

The following is a short video (2:30) that shows how to use ePMV to download and display a Polio virus.

[video]http://www.youtube.com/watch?v=tcEHDUn_cC8[/video]

The next video (3:30) shows autoFill being used to create a representation of an HIV virus:

[video]http://www.youtube.com/watch?v=WpWSUphRzCI[/video]

If you are interested in a more in-depth tutorial on using ePMV the following video (8:00) is aimed at newcomers to molecular graphics.

[video]http://www.youtube.com/watch?v=qd3N3jTOwXc[/video]

For more videos and tutorials of using ePMV and autoFill see: http://www.autopack.org/documentation/tutorials.

Even if you aren't a scientist you may still find this to be interesting technology to use and experiment with. Please let us know in the comments if you are able to make any interesting renders or animation using the tools! The thumbnail for this blog for example is a render of an HIV virus made by our very own Kelly Michels, who has been a huge help in field testing the tools.

A big thank you to Ludovic Autin and Graham Johnson for their huge efforts in writing and porting ePMV and autoPack to 3ds Max, and making the extremely useful video tutorials.

MAXScript - Mouse Tools for Vertex Weighting during Skinning

Christopher Diggins — Fri, 02 Nov 2012 19:01:16 UTC

My colleague Amer Yassine recently finished posted his amazing 40 video tutorial on skinning and rigging for games on the 3ds Max learning channel on YouTube. The process of adjusting vertex weights during skinning is very repetitive so he asked me to help him come up with a MAXScript tool to help ease the process. MAXScript mouse tools are explained here in the MAXScript documentation.

macroScript QuickSkinVertexWeight category:"Custom Skin Tools"
tooltip:"Quick Vertex Weight Tool"
(
    tool AssignSkinVertexWeightTool
    (
        local original
        fn setweight wt = (
            if (wt < 0) then wt = 0
            if (wt > 1.0) then wt = 1.0
            skinOps.setWeight $.modifiers[#Skin] wt
            $.modifiers[#Skin].effect = wt
        )          
        on mousePoint clickno do (            
            if clickno > 1 then return #stop     
            original = $.modifiers[#Skin].effect
        )
        on mouseAbort clickno do (
            setweight original
        )
        on mouseMove clickno do (
            newval = (original + (gridDist.x  * 0.01))
            setweight newval
        )
    )
    startTool AssignSkinVertexWeightTool prompt:"Set Vertex Weight"
)

Here is the video where Amer first introduces the tool and explains how it works, enjoy!

[video]http://www.youtube.com/watch?v=Ya02rmjNsUM[/video]

Dynamically Compiling and Running C# Scripts for 3ds Max

Christopher Diggins — Fri, 26 Oct 2012 15:55:08 UTC

[EDIT: Nov. 12, 2012 I've updated the editor to fix a bug in the editor and include the source code]

For impatient 3ds Max developers the ability to compile and run C# programs from within 3ds Max without having to restart it can be very useful. Since I am about as impatient as they come I developed a simple plug-in for 3ds Max that allows me to edit and run C# programs as if they were scripts.

You can download the C# script editor plug-in and source code here. To install it copy the plug-in DLL file (and optionaly the PDB debug database) into the "\bin\assemblies" sub-folder of your 3ds Max 2013 installation. This should work on both 32-bit and 64-bit flavors of 3ds Max.

Next you will have to "unblock" the DLL (at least for Windows 7, I'm not sure if it is required for Vista). Right click on the file in Windows Explorer after copying it to the "bin\assemblies" folder and press the unblock window.

When you restart 3ds Max, you will have a new user action in the category ".NET Plug-ins" that you will need to associate with a shortcut key or menu item. The plug-in should work for both 32-bits and 64-bit flavors of 3ds Max, but won't work on 3ds Max 2012 or earlier.

I've also included a sample program called "DemoScript_BentCylinder.cs" that you should be able to run from the editor.

Implementation Details

The following code compiles the source code of one or more files each passed as a string.

/// Looks for and executes a public static function named Main by searching all types in the assembly.
/// If more than one Main function is found or no Main function is found an exception is thrown. 
public static void RunMain(Assembly asm, params string[] args)
{
    MethodInfo main = null;
    foreach (var t in asm.GetTypes())
        foreach (var mi in t.GetMethods(BindingFlags.Public | BindingFlags.Static))
            if (mi.Name == "Main")
                if (main != null)
                    throw new Exception("Multiple Main methods found");
                else 
                    main = mi;
    if (main == null)
        throw new Exception("No static public Main method found in assembly");
    main.Invoke(null, new object[] { args });
}

/// Compiles source code given the language provider (e.g. CSharpCodeProvider or VBCodeProvider). 
/// The named assemblies are referenced. The contents of each source code file is passed as a 
/// separate "input" string.  Returns the generated assembly if successful or a list of errors. 
public static CompilerResults Compile(CodeDomProvider provider, IEnumerable<string> assemblies, params string[] input) 
{ 
    var param = new System.CodeDom.Compiler.CompilerParameters(); 
    param.GenerateInMemory = true; 
    foreach (var asm in assemblies) 
        param.ReferencedAssemblies.Add(asm); 
    return provider.CompileAssemblyFromSource(param, input); 
}

If compilation is successful the generated assembly is returned as part of the CompilerResults. Once you have the assembly you can invoke the Main entry point as long as it is a public static method of any public type using the following bit of reflection magic:

        public static void RunMain(Assembly asm, params string[] args)
        {
            MethodInfo main = null;
            foreach (var t in asm.GetTypes())
                foreach (var mi in t.GetMethods(BindingFlags.Public | BindingFlags.Static))
                    if (mi.Name == "Main")
                        main = mi;
            if (main == null)
                throw new Exception("No static public Main method found in assembly");
            main.Invoke(null, new object[] { args });
        }

The rest of the code in the plug-in is pretty unremarkable but. I'd love to hear if this tool (or some derivation) finds its way into your toolbox.

SDK and Scripting Classes at Autodesk University

Christopher Diggins — Mon, 15 Oct 2012 18:53:11 UTC

Autodesk University is being held November 26th to November 29th at the Mandalay Bay Resort in Las Vegas. While Autodesk University starts officially on November 28th, the Autodesk Developer Network is holding a specialized conference for M&E users. If you are interested in the roadmap for our SDKs and meeting with some of the ADN API gurus then I encourage you to attend!

The following is a select list of classes at the main AU conference which should also be of interest to people who use the scripting API or SDKs of 3ds Max, Maya, and Softimage. For a more complete list of classes regarding M&E products go here.

The first two classes listed are being offered by Cyrille Fauvel and Kevin Vandecar from the Autodesk Developer Network.

CP2520 - Using .NET Programming in Autodesk® Maya®
Cyrille Fauvel , Autodesk (Autodesk Developer Network)

In this class, we will introduce you to .NET programming in Autodesk Maya software. We will present using the C# language, but the techniques can apply to any .NET programming language including Microsoft® Visual Basic®. We will cover how to create an assembly that will load into the Maya environment. We will show how to interface with other .NET Framework features that will include the Windows Presentation Foundation (WPF) and other features such as LINQ functionality. This class will be organized for those who want an introduction to these new APIs, including practical techniques. You do not need to know Maya programming, but some general programming experience will be helpful.

CP2177 - Autodesk® 3ds Max® .NET API Introduction and Techniques
Kevin Vandecar , Autodesk (Autodesk Developer Network)

Last year, with the release of the Autodesk® Subscription Advantage Pack for Autodesk 3ds Max 2012, .NET users gained access to significant enhancements in the Autodesk 3ds Max C++ SDK, enabling them to do more with Autodesk 3ds Max 2012 software. Now, these .NET APIs are available in the main product. In this class, we will introduce you to .NET API programming in 3ds Max. We will present using the C# language, but the techniques can apply to any .NET programming language, including Microsoft® Visual Basic®. We will cover how to create an assembly that will load into the 3ds Max environment. We will show how to interface with other .NET Framework features that will include the Windows Presentation Foundation (WPF) and other features such as LINQ functionality. This class will be organized for those who want an introduction to these new APIs, including practical techniques. You do not need to know 3ds Max programming, but some general programming experience will be helpful.

DG2443-P - Autodesk® 3ds Max® MAXScript + Microsoft® .NET: Discover a Bigger World
Paul Neale , PEN Productions

In 2009, Autodesk 3ds Max software opened up MAXScript to .NET to enhance user interface design and extend the capability of MAXScript beyond the confines of 3ds Max. With .NET, tool developers can create dynamic and comprehensive production tools to help manage scenes, characters, and data sets, as well as an infinite host of other possibilities. In this class, you will learn to inspect .NET classes and objects and use them to build comprehensive .NET tools in MAXScript. This is an intermediate MAXScript class—participants should have a good working knowledge of MAXScript and the fundamentals of coding, including a good understanding of function, for loops and data types.

DG2619-L - Autodesk® Softimage® Interactive Creative Environment: Making Math Accessible
Todd Akita , Psyop

An all-too-common complaint from most visual artists is that in school, mathematics wasn't taught with a specific application or goal in mind and was too abstract or difficult to visualize. The Interactive Creative Environment (ICE) in Autodesk Softimage software combines high performance with a user-friendly interface. This combination of fast visual feedback and ease of use makes it a great environment to apply mathematics towards problem-solving in a hands-on way. In this hands-on lab, we will first examine what ICE is and what it can do. Then, we will introduce and review essential math concepts (trigonometry, vectors, and matrices) and explore the application of those concepts in a production context. Attendees should be familiar with the Softimage interface, but non-users are welcome because the graphics-related material is general enough to be applicable to almost any software package.

DG2567-P - Autodesk® Maya® Scripting: MEL™ and Python
Roland Reyer , Autodesk

The script language MEL (Maya Embedded Language) is not only a feature of Autodesk Maya software, it is the foundation. Every function in Maya is a MEL command that can be accessed using menus, icons, buttons, marking menus, and other controls. In this class, we will cover MEL concepts, the possibilities and limitations of this scripting language, and the differences in the Maya API. We will work through some examples, and discuss the differences between MEL and Python and explain the advantages of using Python for Maya.

DG2176-P - Think Outside the Box: Custom Development with Autodesk® Entertainment Creation Suites
Laurent Abecassis , Di-O-Matic

During this class, you will learn the best practices and typical approaches involved when developing custom tools for Autodesk® 3ds Max®, Autodesk® Maya®, Autodesk® Softimage®, and Autodesk® MotionBuilder® software. We will cover scripting and programming languages and discuss the numerous APIs and SDKs available from Autodesk. This class will help you grasp what you can do beyond what is available out of the box in Autodesk entertainment creation suites.

AV3567 - Parametric Design Modeling with Autodesk® 3ds Max®
David Fano , CASE

This class will describe how to use Autodesk 3ds Max software modeling tools to build iterative parametric design systems. In this class, we will cover Autodesk 3ds Max geometry types such as Editable Mesh, Poly, Patch, and NURBS; combine modifiers to build complex systems; use wire parameters to quickly make geometric patterns; and provide an introduction to MAXScript. In this class, you will learn to reduce the amount of explicit modeling you do and instead build flexible design systems so you can focus more effort on design.

Please let me know if I am missing any SDK or scripting classes that you think would be of interest to Area members.

Embedding a Web Server in 3ds Max using .NET

Christopher Diggins — Tue, 09 Oct 2012 15:24:12 UTC

Controlling a .NET Application Remotely using a Web Server

The problem of controlling a .NET application such as 3ds Max from another process, or over a network, is similar to the challenge of controlling Python from C# just in the other direction. In this blog post I describe how to embed a simple web-server implemented in C# in 3ds Max that executes MAXScript code.

I have attached both the source code, and the .NET plug-in as a DLL.
Download WebServer.zip

To load the web-server plug-in you have to copy the assembly (MAXScriptWebServer.DLL) in the bin/assemblies sub-folder of 3ds Max 2013. Next you need start up 3ds Max in Administrator Mode. Now when you go to the "Customize menu" you should see the user action in the “.NET samples” category. You can then associate it with a short-cut key or menu option. For more information on registering custom actions see the 3ds Max documentation.

Why use a Web Server and not Sockets?

At first it might seem like overkill to embed a web-server in your application when you just want to send messages to it. As one of my colleagues asked, why not just use sockets?

When you get rigtht down to it, a web-server is effectively a wrapper around one end of a TCP/IP socket that uses HTTP as the application level communication protocol. Using HTTP provides you with a well-defined and widely available standard for sending data to and from a server, with protocols for both error handling and content encoding. For me the biggest win is the fact that I can use any web-browser as a client!

Fundamental Classes

Okay, now that we have gotten past your irrational fear of embedding a web-server in your .NET application let’s look at the building blocks:

System.Net.HttpListener – receiving and responding to HTTP requests
System.Web.HttpUtility – parsing query string data
System.Windows.Threading.Dispatcher – executing code on the main thread
System.Thread.Thread – executing http listening on a separate thread
Autodesk.Max.IGlobal – accessing the core interfaces of the 3ds Max .NET API, for example to execute MAXScript code.

Basics of Creating a CUI Action

I opted to create the server a custom .NET user action for 3ds Max 2013. To create a custom .NET action you have to create a class derived from UiViewModels.Actions.CUICommandAdapter. This is an abstract class that requires you to implement five methods:

string ActionText – A string property that represents the name of the action as shown on menus and buttons.
string InternalActionText – A non-localized version of ActionText
void Execute(object parameter) – The function called when the action is triggered by 3ds Max. For example if a menu item selected or short-cut key us pressed.
string Category – The name of the category the action can be found in the customize dialog.
string InternalCategory – A non-localized version of Category.

In your project you will have to first reference the following assemblies which can be found in the 3ds Max application folder:

Autodesk.Max.dll
UiViewModels.dll

It is very important that when you create the reference in your proejct that you set the “copy local” property to false. Be sure you also don’t make the same mistake I did and I link to the wrong version of 3ds Max.

Now you will need to add references to the following Microsoft assemblies:

PresentationCore
System.Web
System.Windows.Forms
WindowsBase

Finally you should set the output folder of the project to the “bin/assemblies” sub-folder of 3ds Max.

For more information on writing .NET plug-ins see the 3ds Max SDK documentation.

Starting the Web Server

When you start the web-server from the menu (or shortcut key depending on how you registered it) you will see the followigntext in the MAXScript listener:

Starting HTTP listener
HTTP listener started
Thread started

You can now point your browser to: http://localhost:8080/test and you will see something similar to the following screen shot:

Using the web Server from MAXScript

The user action class library can also be loaded from MAXScript. This can be useful if you want the server to start up with 3ds Max. The following code shows how to launch the web-server from a MAXScript script:

fn startWebServer = (
    Assembly = dotNetClass "System.Reflection.Assembly"
    maxroot = pathConfig.GetDir #maxroot
    Assembly.LoadFile (maxroot + "\\bin\\assemblies\\MaxScriptWebServer.dll")
    cls = dotNetClass "MaxScriptWebServer.MaxScriptWebServer"
    server = dotNetObject cls
    print "Created: " + server.actionText
    server.execute undefined
)
startWebServer ()

Highlights of the Web Server Code

The web-server is implemented primarily by the System.Net.HttpListener class. The implementation is based on the example shown on MSDN. The three most important things to note about the code are:

We want the web-server to run on its own thread so that 3ds Max remains responsive.
The MAXScript code comes from an HTML form URL encoded and has to be decoded.
We want the MAXScript code to be executed on the main thread.

First, to get the web-server to run on its own thread we use the System.Thread.Thread class.

   var t = new Thread(() => ListenLoop());
   t.Start();

Next to decode the MAXScript code sent from the web-page we need to use System.Web.HttpUtility to retrieve and decode the form text.

        public static string GetFormData(HttpListenerRequest request, string formName)
        {
            if (request == null || !request.HasEntityBody)
                return "";
            var body = request.InputStream;
            var encoding = request.ContentEncoding;
            var reader = new System.IO.StreamReader(body, encoding);
            var text = reader.ReadToEnd();
            body.Close();
            reader.Close();
            var queryVars = HttpUtility.ParseQueryString(text, encoding);
            return queryVars[formName];
        }

Finally to execute the MAXScript code on the main thread we use a System.Windows.Threading.Dispatcher

  // Execute the evaluation of the code as MAXScript on the main thread.
  Action a = () => global.ExecuteMAXScriptScript(code, false, null);
  dispatcher.Invoke(a);

Next Steps

If you are interested in a more sophisticated mechanism for controlling 3ds Max you might want to look into using XML RPC to control 3ds Max using the XML-RPC.NET library.

If you need full bi-directional communication between a server application and multiple clients and for some reason polling is not acceptable then I would recommend investigating using HTML5 Web sockets.

MAXScript - Baking Animation Transforms

Christopher Diggins — Tue, 02 Oct 2012 15:12:36 UTC

A colleague of mine, Amer Yassine, who manages the awesome 3ds Max YouTube learning channel recently asked me how to bake world space transforms to helper objects.

Amer provided me the example of an arm with three bones and three helper objects. Each helper object was parented to the bone and the bones were animated using an IK solution. When he collapsed the transform controllers on the point helpers it would create keyframes for the helpers but with 0 values. So when he unlinked the helper objects they were no longer animated. This makes sense because the position of helpers was in local space relative to the parent object, but what Amer wanted were position/rotation keys for the helpers based on the world-space data.

My first thought was to try and find some scripts on ScriptSpot.com to do what he wanted. However none seemed to work and at first I wasn't quite clear on what the precise problem we needed to solve was. Eventually I found a thread on CGSociety.com where a similar question was framed in a way that explained what Amer and I were looking for except it applied to a camera:

I have been fumbling around trying to find a way to bake out some animation I have on a camera. The camera is animated via three dummies in a hierarchy and I need to 'bake' in the animation at every keyframe in worldspace. Currently every method/script I have found bakes the animation in local space so when the dummies/point helpers have been deleted the camera does not retain any of the animation, yet I have a keyframes at every frame. Is there a way to create keyframes that would take the position/rotation of the camera in worldspace at everyframe and allow me to delete everything but the camera and retain all animation?

http://forums.cgsociety.org/archive/index.php/t-740206.html

Now I was getting somewhere, because I finally understood the problem! The ensuing thread didn't make much sense to either of us, but going back to first principles, I created a basic script that:

Un-parented the helper from the bone.
Created a key-frame for the helper object at each frame based on the bones position/rotation/scale.

The resulting solution is quite elegant using MAXScript:

-- Create keys for the selected objects from the world space transforms taken from the parents (bones). 
-- Also unlink each object from the parent. 
startTime = 0
endTime = 100
nthFrame = 5

-- For all selected objects 
for obj in $ do 
(
  -- Get the current parent (a bone) and unlink the object. 
  bone = obj.parent
  obj.parent = undefined
                
  -- Create animation keys
  for t in startTime to endTime by nthFrame do (
    animate on at time t (
      obj.transform = at time t bone.transform
    )
  )              
)

The magic in this script occurs in the "animate" context expression. Check out the MAXScript documentation on the animate keyword to learn how it works. In short it acts like the "autokey" mode in 3ds Max. Any animatable property you change (such as the transform) is automatically associated with a new key.

I hope the rest of the script is sufficiently clear for you to use and modify for your own work. It did the trick for Amer. :-)

By the way, if you use 3ds Max at all you should check out Amer's tutorial on rigging a character for games that he just recently started posting. It is an amazing tutorial series that will have 40 parts once it is all online!

Calling Python from C# using XML RPC

Christopher Diggins — Wed, 19 Sep 2012 17:14:53 UTC

I wanted a host .NET application (in this case 3ds Max, but it applies equally to any .NET API like AutoCAD) to inform a Python script running on the same machine but in a different process whenever a particular event occured.

I first rejected a number of possible solutions that were low-level and that would prevent me from moving the client to another computer.

Named pipes
Memory mapped files
Windows messages
DLL function invocation

Two remaining options seemed like possible candidates:

Web sockets
HTTP server running in the host

I liked the Web sockets approach, but the libraries for using them in C# and Python are not quite as mature or easy to use as I had hoped. Running an HTTP server and having the Python application poll it repeatedly seemed like the best option. However, I was concered about all of the wasted resource for the Python client to ping the host application repeatedly not to mention the potential for poor responsiveness.

After a bit of thought I realized that embedding the HTTP server in the Python application and treating the .NET application as the client would be a lot easier!

With an HTTP server running in the Python application, I was with a new set of possibilities for communicating data from the host application to the Python client.

Simple HTTP API using query strings
REST API
SOAP API
XML RPC API

After further investigation I decided the simplest out-of-the-box solution would be to use the SimpleXmlRpcServer module in Python and the System.Net.WebRequest class in .NET. After quickly scanning the information on XML RPC on Wikipedia and hacking the example in the documentation for WebRequest and SimpleXmlRpcServer I ended up with a working prototype with almost no effort:

Here is the sample .NET client:

using System;
using System.Text;
using System.Net;
using System.IO;

namespace SimpleXmlRpcClient
{
    class Program
    {
        static void Main(string[] args)
        {
            WebRequest request = WebRequest.Create("http://localhost:8000/RPC2");
            request.Method = "POST";
            string postData = @"<?xml version=""1.0""?>
<methodCall>
  <methodName>add
  <params>
    <param>
        <value><i4>21</i4></value>
    </param>
    <param>
        <value>21
    </param>
  </params>
</methodCall>";
            byte[] byteArray = Encoding.UTF8.GetBytes(postData);
            request.ContentType = "application/x-www-form-urlencoded";
            request.ContentLength = byteArray.Length;
            Stream dataStream = request.GetRequestStream();
            dataStream.Write(byteArray, 0, byteArray.Length);
            dataStream.Close();
            WebResponse response = request.GetResponse();
            Console.WriteLine(((HttpWebResponse)response).StatusDescription);
            dataStream = response.GetResponseStream();
            StreamReader reader = new StreamReader(dataStream);
            string responseFromServer = reader.ReadToEnd();
            Console.WriteLine(responseFromServer);
            reader.Close();
            dataStream.Close();
            response.Close();
            Console.WriteLine("Press any key to continue ...");
            Console.ReadKey();
        }
    }
}

Here is the sample Python host:

from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler

# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)

# Create server
server = SimpleXMLRPCServer(("localhost", 8000),requestHandler=RequestHandler)
server.register_introspection_functions()

# Register a function e
def adder_function(x,y):
    return x + y
server.register_function(adder_function, 'add')

# Run the server's main loop
server.serve_forever()

Hopefully this is enough to get your favorite .NET application talking to your favorite Python application. Happy hacking!