1. Recompile the mxsdotNet.dlx file using Visual Studio 2010.
2. Modify the 3dsMax.exe.config file.
3. Install the Visual C++ 2010 components.

I'll describe each in detail below, but first I should mention that this is not officially supported by Autodesk.  So if you run into trouble because of it, you're on your own.  Kind of like hacking your video card to make it run faster.

I've been running Max 2011 with .Net 4.0 WPF tools running within it for a couple months now without any noticable issues.  But I can't gaurantee that this will be the case for everyone.  And I've only been using the 64-bit version, although I can't think of why this wouldn't work with the 32-bit version as well.  As for versions of Max before 2011, I have no idea if this will work or not.

So, on to the instructions...

1. Recompiling the mxsdotNet plugin is pretty straighforward.  Just install the SDK, open the ...\samples\maxscript\mxsdotNet\mxsdotNet.sln file and compile.  If you don't have Visual Studio 2010, you can download the already recompiled 64-bit version below.

2. Open the ...\Autodesk\3ds Max 2011\3dsmax.exe.config file in a text editor and add the following lines right before the closing </configuration> tag...

<startup useLegacyV2RuntimeActivationPolicy="true">
  <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>

3.  Lastly, if you haven't already installed Visual Studio 2010, you'll need to manually install the Visual C++ 2010 components.  But if you have, then these should be installed for you already.  You can download the installers here...

32-bit
64-bit

And that's it.  Once you've got all the necessary files modified correctly, you'll be able to load and use .Net 4.0 assemblies directly in Max.  The DataGridView control alone is worth the effort.

Download 64-bit .Net plugin and config file here.

------------------
local doRefresh = true

on eh Paint args do
(
    if doRefresh then
    (
       doRefresh = false
       eh.refresh()
       doRefresh = true
     )
)
-------------------

Now the WPF control will redraw itself whenever it needs to.  The full script can be downloaded here.

I was recently directed to a great HDR toolset called Smart IBL.  It's basically a system for creating HDR images with a bunch of imbedded information that makes it really easy to set up a realistic rendering environment inside of any (well most) 3D apps.

The main application is called sIBL-GUI.  It's a browser for your sIBL set, and the interface for connecting to the 3D app.  It's really easy to set up with Max so that all you have to do is download or create some sIBL files, add them to the sIBL-GUI database, select one, and then click a button to have a light (or lights), a ground plane, and environment settings all created automatically.

The other tool, sIBL-Edit, is also useful, but the automated script for creating the Max environment isn't as up to date as the sIBL-GUI version.  So use GUI for 3D app interop, and Edit for modifying the embedded information.

I've been having a lot of fun with both of these lately, and have even contributed to the Max template in the GUI app.  So if you're doing any HDR rendering, give it a shot.

Links:

Smart IBL
IBL Tools
HDR Labs Home

This will be a short post.  I just wanted to finish up this series about hosting a WPF control inside of Max by showing how, as one final method, you can also use a WPF window instead of either the MaxForm window or the rollout.  The script code is basically the same as the MaxForm version, minus the ElementHost.  You don't need it because the WPF control is being loaded into a WPF window.  No host needed.

-------------------------------------------------------------------------
dotNet.loadAssembly @"<folder name>\ProgressBar\ProgressBar\bin\Debug\ProgressBar.dll"

bar = dotNetObject "ProgressBar.UserControl1"
frm = dotnetobject "System.Windows.Window"

frm.title = "Progress"
frm.width = bar.width + 16
frm.height = bar.height + 34
frm.windowStartupLocation = frm.windowStartupLocation.centerScreen
frm.windowStyle = frm.windowStyle.toolWindow

frm.content = bar

frm.show()
-------------------------------------------------------------------------

There are a couple of extra drawbacks though. One, you need to manage all of the foreground and background colors yourself if you want it to look like it's part of Max.  Same goes for assigning the parent window as Max itself, so that it will follow along with Max as you maximize/minimize or navigate away to different programs.  Otherwise it just kinds of floats off by itself and is easy to lose.

Finally, and probably most importantly, you need to set the "accelerators" state depending on whether the window has focus or not.  Accelerators are just another name for hotkeys.  And if don't manually manage this, the user won't be able to type into any text boxes in your tool.  So in the "GotFocus" event you'll want to turn hotkeys off with "enableAccelerators = false".  And then turn them back on in the "LostFocus" event.

So overall, unless you're planning on doing something that you can't do with a regular window, like changing the shape or something crazy like that, I don't see any benefit to using a WPF window over either of the other two methods.

-------------------------------------------------------------------------

-- load the assemblies
dotNet.loadAssembly @"<folder name>\Projects\ProgressBar\ProgressBar\bin\Debug\ProgressBar.dll"
dotNet.loadAssembly @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\v3.0\WindowsFormsIntegration.dll"

-- create the rollout
bar = dotNetObject "ProgressBar.UserControl1"
size = [bar.width,bar.height]
frm = rollout progressBar_RLT "Progress" width:size.x height:size.y
(
    dotNetControl eh "Integration.ElementHost" width:size.x height:size.y align:#left offset:[-14,-5]
   
    on progressBar_RLT open do
    (
        eh.child = bar
    )
)

createDialog progressBar_RLT
cui.RegisterDialogBar progressBar_RLT

-------------------------------------------------------------------------

Once you have it loaded, the commands used in the previous post to make it progress through the steps work just the same, since the WPF assembly itself hasn't changed.

You might notice that the background is different now.  That's because when using the MaxForm window, the background of the window is set automatically to whatever color Max itself is set to, and all the controls contained in that window inherit that color for their background.  But this doesn't happen witha a rollout.

So if you want to maintain a consistent look to your UI, you'll need to set the background of the WPF control manually.  The best way to do that would be to set up the "Loaded" event for the UserControl on the code side of your project to query the background color from Max and then apply it.  Lone Robot has some great information on how do to just that here.

Some time ago I wanted to start getting my head around WPF, and especially how I could integrate tools made with WPF into Max.  So I decided to start with something simple, which was to take an existing script that displays a progress bar using standard Max controls and convert it to WPF.

I'm not going into the details of WPF programming because there's a ton of useful information on the interwebs already.  And if you want a good reference book, I can recommend Adam Nathan's "WPF Unleashed" (although you might want to wait for the new version).  But the WPF portion of this project is available for download at the bottom of this post.

A few things to note:

* The process I'm describing here only works with Max 2010 and up.

* If using VS 2010 to build your own projects, you'll need to build them using .Net 3.5 since Max doesn’t support 4.0 yet.  Do this by going to the project properties and changing the Target Framework to ".NET Framework 3.5".

* If you don’t want to load the VS project, the .dll you'll need is included with the project files in the “bin/debug” folder.

So the basic idea is that you create an ElementHost WinForms in either a rollout or MaxForm window, and then put the WPF control inside of that.

Here's the MaxScript portion needed to create the progress bar in Max...

-------------------------------------------------------------------------

-- load the progress bar library
dotNet.loadAssembly @"<folder location>\ProgressBar\ProgressBar\bin\Debug\ProgressBar.dll"

-- load the WPF Integration library needed to create the ElementHost control
dotNet.loadAssembly @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\v3.0\WindowsFormsIntegration.dll"

-- define controls
bar = dotNetObject "ProgressBar.UserControl1"
frm = dotNetObject "MaxCustomControls.MaxForm"
eh = dotNetObject "System.Windows.Forms.Integration.ElementHost"

-- make controls fill the form window
eh.dock = eh.dock.fill

-- create form
frm.text = "Progress"
frm.width = bar.width + 16
frm.height = bar.height + 34
frm.startPosition = frm.startPosition.centerScreen
frm.formBorderStyle = frm.formBorderStyle.fixedToolWindow

-- add ElementHost, which holds the WPF control
frm.controls.Add eh
-- add the WPF control
eh.child = bar
-- open the window
frm.showModeless()

-- set number of steps to use
bar.steps = 50

-- loop through the steps
for i = 1 to bar.steps do
(
    -- force the UI to update
    (dotNetClass "System.Windows.Forms.Application").DoEvents()
    -- increment one step and change label
    bar.DoStep()
    bar.ProgressLabel = "Thing " + i as string
    sleep .05
)

frm.close()

-------------------------------------------------------------------------

And here is the Visual Studio 2010 project.

< Edited to remove the UserControl, which I orginally had to hold the ElementHost, but isn't actually needed. >