GetCOREInterface

Forge Design Automation for 3ds Max went into production on October 28th! Join us for a webinar to learn more.

Have you heard?! Forge Design Automation for 3ds Max went into production on October 28^th. To learn more about this service and how you can batch process your 3ds Max tasks, check out the webinar series here: https://forge.autodesk.com/blog/design-automation-api-webinar-series-register-now. You can register for the 3ds Max webinar, as well as the other Design Automation engines (including AutoCAD, Revit, and Inventor).

What can you do with 3ds Max Design Automation? Any sort of automated processing! 3ds Max desktop software already includes a tool called 3ds Max Batch. This tool allows local automation of tasks and is a good way to test your automation before using the Design Automation system. See here for the 3ds Max 2020 Batch details: http://help.autodesk.com/view/3DSMAX/2020/ENU/?guid=GUID-0968FF0A-5ADD-454D-B8F6-1983E76A4AF9

Anything that runs in the 3ds Max Batch tool is possible to run in the 3ds Max Design Automation engine. You can also include plug-ins that can be automated. Typically, you would provide a MAXScript that would execute the automation, but the code itself could live in a C++ or a .NET plug-in. Of course, the MAXScript could also contain the automation code. The Design Automation API also supports the ability to pass parameters into the script code, that can also be passed into the automation code. This will allow very flexible workflows with the ability to provide configurations and data to the automation job. For example, you could have a configurator website that takes information from your customer, then using 3ds Max Design Automation you could auto-generate a max model to give back to your customer. Using other Forge APIs, you could also preview the model using the Forge Model Derivative service and the Forge Viewer.

Forge Design Automation for 3ds Max step-by-step tutorial and SIGGRAPH 2019

3ds Max Design Automation tutorials and samples

The engineering product team has produced a step-by-step tutorial that our docs team recently published. Check it out here. Design Automation V3 is still listed in beta, but we have had a lot of great feedback for the three new engines: Inventor, Revit and 3ds Max. Because we are still in beta, remember when browsing into the V3 docs you will have to pay attention to version. For example, when going into the Developer's Guide, you will typically land here. For the beta version 3, change the v2->v3 and you'll come into the new docs. Also notice there are new step-by-step guides for Revit and Inventor. This content will change throughout the beta cycle, so come back regularly and don't be surprised to find more improvements and changes here in coming weeks.

A couple of things to note... This step-by-step tutorial is currently showing 3ds Max 2019 as an example. Currently 2018, 2019 and 2020 are all available. We have two other resources for .NET Core/ASP here and as part of the "Learn Forge" site here. Both of those are using 3ds Max 2020 (and the .NET plugin needs 2020, unless you make a few code changes. (Ping me if you need help)). One of our engineering guys also has a nice postman tutorial here.  I am also considering to move the "explode geometry" app store example to 3ds Max Design Automation. Is there anyone out there who has other ideas for design automation activities? If so, feel free to comment below, or send me email.

SIGGRAPH 2019

SIGGRAPH 2019 is also only a week away. If you are planning to attend, the Forge ADN DevTech M&E team will be there! Myself, Chen Xi Li, Denis Grigor, and Lanh Hong will be in the Autodesk booth during the week demoing Forge topics, including Forge Design Automation for 3ds Max. We also have a talk during the Autodesk Sponsored Vision series. For the full Autodesk agenda check out here. We will be in the Autodesk booth during the following exhibition hours: Tues 11-12, 2-3, 5-6; Wed 11-12, 2-3, 5-6; Thur 11-12, 2-3. Stop by and say hi! Hope to see you there!

 

Announcing 3ds Max 2020! - Customization Update

On Wednesday 3ds Max 2020 started to roll out to customers and partners. The most important news is that 3ds Max 2020 is a binary breaking release and bumps the developer environment to Visual Studio 2017, so C++ plugins will need to be minimally recompiled. There was not a lot of change to the SDK, so rebuilding should not be an issue.

To start, it's important to know what came into 3ds Max during the 2019 cycle, which is of course all included in the 20202 release. Here is a list of links to feature updates that came from 2019 Update 1 through 3ds Max 2020.

Feature Updates

• What’s new in 3ds Max 2019 Update 1 here
• What’s new in 3ds Max 2019 Update 2 here
• What’s new in 3ds Max 2019 Update 3 here
• What’s new in 3ds Max 2020 here
• Also see the current AREA new feature blogs here.

Plugin Package Format (aka App Store bundle format)

The 3ds Max product team also released a Forge 3ds Max Design Automation engine into beta last fall. See here for that info. The Plugin Package Format is an important aspect of the 3ds Max DA functionality, but it also extends to the entire 3ds Max product (3ds Max, 3dsmaxbatch, and 3ds Max DA). If you are someone who customizes 3ds Max, especially as a commercial developer, or a tools developer, where you need to redistribute the customization routines/plugins, this format can be very helpful. It is completely independent of the 3ds max install and profile locations. You can place this anywhere, and 3ds Max can be configured to use it and as a default location as well. It also helps you to keep your file set in a standalone folder structure.

Changes to Plugin Package format for 3ds Max 2020 are mentioned here in the change listing. One thing to note is that UpgradeCode is now a required value. This help ensures there are no clashes between like-named packages. Make sure to read the important changes to that aspect. Packages without an UpgradeCode will not load in 3ds Max 2020 (but did in prior releases). The package format and MSI that are generated for the App Store are using Microsoft standards (see here). The UpgradeCode is explained in greater detail there. See these sections for complete details:

• 3ds Max 2020 Plugin Package changes
• Packaging Plugins
• Plugin Package Format
• Plugin Package Example

We also have two examples showing this Plugin Package Format for the Autodesk App Store:

• https://github.com/ADN-DevTech/3dsMax-Bake-Radiosity (C++ utility plugin)
• https://github.com/ADN-DevTech/3dsMax-Explode-Geometry (.NET plugin)

This format is used by any of the applications that are supported in the App Store. This means products like Revit, AutoCAD, and Inventor all use this format as well. If you are developing apps for other products, it can be helpful to manage all the apps in a similar way. Of course there are some product specific features, but the overall idea is the same. 3ds Max, Revit, Inventor, and AutoCAD all now have Forge Design Automation engines as well, so a lot of possibility!

What’s new in the 3ds Max 2020 SDK

For all the changes in 3ds Max 2020 SDK, see here. 

Important Details for C++ developers!

For complete SDK requirements, see here.

SDK Break

The 3ds Max 2020 SDK is not binary backward compatible with the 3ds Max 2019 SDK. Plugins will need to be re-compiled to work in 3ds Max 2020.

Microsoft Visual Studio 2017

3ds Max 2020 has been compiled with Microsoft Visual Studio 2017 version 15.8.3, Platform Toolset v141. The Windows Platform SDK version is 10.0.17134.0. Plugins need to be built using the same Platform Toolset version. Any version of Microsoft Visual Studio can be used where the main requirement is to use the Platform Toolset v141. Although other Platform SDK versions may work, it is also suggested to use 10.0.17134.0. The SDK property sheets refer to this, so if you change to a newer version or some reason, you will have to update the property sheet.

Qt Framework

3ds Max 2020 is based on Qt 5.11.2. Although Qt guarantees that minor releases are binary and source backward compatible, we recommend using the same Qt version as 3ds Max uses for plugin development.  Qt Support for parameter blocks-based UI and also the Plugin Wizard has been added.

Other highlights

Recently 3ds Max switched from “fast math” to “precise math” compiler settings. There is an interesting MS blog article that explains the differences here.  

3ds Max 2020 also adds OSL Shader API for 3rd party renderers.

If you are developing Modifiers, make sure to see the Modifier Plugin Class Changes to Support Pb1 to Pb2 Migration section of SDK changes. There were also two new functions added to help find nodes from within the Modifier APIs.

Make sure to review the entire article here for complete 3ds Max 202 SDK changes, here. 

MAXScript

Again, there were several changes made during the 2019 cycle. For those details, see here. 

For 3ds Max 2020, all the changes are listed here. One thing to note, is that to support the Plugin Package format and changes, the ExchangeStorePackageManager has been renamed to PluginPackageManager. The old name will continue to work as a global variable, but I would encourage you to get used to the new name for the overall system.

Python

The Python version used by 3ds Max has been upgraded to 2.7.15. The Pyside2 version included with 3ds Max is updated to 5.11.2.

The pymxs docs (starting in 2019.3) are being updated to add more examples, and explanation of how to handle edge cases and known issues.

.NET API

There were no changes to the .NET API, and .NET Framework remains at 4.7

Forge 3ds Max Design Automation is in public Beta!

At Forge DevCon 2018 in Las Vegas a few weeks ago, we announced the Forge 3ds Max Design Automation service is now available in beta. Find the main announcement here: https://forge.autodesk.com/blog/forge-3ds-max-design-automation-public-beta. 

What is Forge Design Automation? Well it allows you to run automation jobs in the Forge cloud services, and make use of cloud processing. This allows all sorts of options! From commercial configurator type websites, to internal company automation processing that frees up local licenses for real work. :-)

If you are not familiar with Autodesk Forge cloud services, see here: https://forge.autodesk.com/

If you do not have any prior Forge experience, to get started, I would recommend going through some of the basic tutorials first. These can be found here: https://forge.autodesk.com/developer/getting-started. The account setup and OAuth authentication APIs are the same for all Forge services. Once you have that basic understanding, then you can follow the Forge blog announcement post to get started with a 3ds Max Design Automation sample that uses NodeJS. 

If you are interested in the Forge related classes at Autodesk University, check it out here: Forge AU Classes, and see here for all the 3ds Max AU Classes. 

Just think of all the possibilities for using Design Automation! 

Forge DevCon 2018 coming to AU Las Vegas Nov.12+13

 

If you are planning to come to Autodesk University, or if just interested in the Forge APIs, then the Forge DevCon is something you should attend. Remember early bird ends October, 15 and you can register for AU and/or DevCon today.

DevCon is occurring conveniently on November 12+13 adjacent to Autodesk University. There are ~35 Forge DevCon classes scheduled on Monday November 12 and Tuesday November 13^th. Also note that Forge DevCon will overlay the Connect and Construct summit and there is an option to purchase of a two-day DevCon pass allowing you to attend both Monday/Tuesday content, including the AU keynote, DevLab, and Expo on Tuesday, without purchasing a full AU conference pass.

Denis and I will be teaching a class as well. A good chance to come by and meet us! Our class SD226781 – Advanced Techniques for Using the Forge Viewer, will be on Tuesday morning. Of course there will be a variety of other courses including these interesting ones: CS223617 - A Tinkerer's Experience Getting Off the Ground with Forge, FDC223831 - Move to Forge and the Cloud With Your Existing .NET Experience, FDC231761 - The Future of Forge: An overview of the Evolution of the Forge Platform, and FDC196412 - Creating Flexible Offline Workflows Using Autodesk Forge. 

We will also be around in the Forge Village/Expo on Monday. In the Village (again shared with Connect and Construct) there will be technology showcases, including an AR VR area. We will demonstrate some AR and VR technology using the Forge toolkit. The toolkit currently supports Unity, and they will be a sponsor at AU this year, including having a booth in the Forge Village. Here is a related class: SD225860 - Hit the Ground Running with Unity and Forge.

Why are we discussing this in a 3ds Max developer blog? Well... APIs are APIs! but, more importantly the 3ds Max (*.max) format is now supported in the Forge Model Derivative service. For some supporting details about how the *.max translations work, see some tips by Denis on our Forge blog and on stackoverflow. Moreover, the recent 3ds Max Shared Views feature is powered by Forge, and Forge DevCon is an excellent opportunity to understand how you can also use these parts and build for 3ds Max. You can understand how the Shared Views works and how to create a similar experience on your own web site. In addition to the AutoCAD Design Automation, you will hear about new Design Automation for Revit and Design Automation for Inventor services. With those clearly on the horizon, I can only guess that 3ds Max Design Automation will be coming soon. :-)

Hope to see you there!

3ds Max Public Debug Symbols - Updated with complete instructions

Hi All, Almost 5 years ago, I wrote the original article here about public debug symbols. I had some recent questions about debug symbols and realized that a link in the original article was not working, so wanted to complete the whole story here again. Autodesk 3ds Max is a unique product in the company's portfolio. The engineering team for 3ds Max is keen on helping the developer community as much as possible. With that, they are providing 3ds Max debug symbols via an online symbol server. These are public symbols that are stripped, so there is no source code information. However, the symbols can show you very quickly were a problem may be coming from, especially given the many different ways you can derive C++ plugins and utilize the virtual callbacks from 3ds Max.

This article describes the steps to setup and use the symbols to get extra call stack details when debugging. To setup the Visual Studio to use the public symbol server, first click the debug menu and choose options. Then follow these steps in the Debug Options dialog:

1. In the left list, choose Debugging -> Symbols
2. Click the folder Icon in upper right
3. In the blank space added, enter http://symbols.autodesk.com/symbols , and make sure the check box is checked.
4. If you want to store the symbols offline in a different location from default, enter the location in the "Cache Symbols in this directory"
5. Select the "All Modules, unless excluded" option to load all the 3ds Max modules during a debug session. Note this applies to all the symbol locations checked. For example, the default includes Microsoft Symbol Servers, so those will also load as needed. You can hone this down by using the "Only specified modules" but it takes more time to setup and figure out. You can also check/uncheck the symbol servers as a whole to control other servers (like uncheck Microsoft Symbol Servers) if you only want to use 3ds Max symbols.
   
   See the below screen capture:

After the setup, you can set breakpoints, and then start debugging. First, remember that even though we are debugging a plugin in 3ds Max, using the production version, we need to use the "hybrid" configuration so that the various run-times are production, and not debug. When starting 3ds Max in a hybrid debug mode, you will see in the output window whether the symbols are loading for each module. For example:

After 3ds Max is fully started, you can now start debugging and you can stop in break points within your plugin, and if 3ds Max symbols have call stack information in the context of your debugging session, it will be displayed in the call stack window. For example, in a basic UtilityObj plugin, during the BeginEditParams routine, you can get the following enhanced call stack:

Without the symbols being loaded, the same location will look like below, and you will only see memory locations.

 

When public symbols first became available, FCS symbols were the only versions uploaded, but since around 2015, update versions have also been included. The symbol server should always contain all public releases with matching symbols. If you run into trouble about symbols loading, make sure all the options are correct, and after double checking if they are not loading, feel free to ping me and I can double-check they are present on the symbol server. 

 

Hope it helps! Happy Fall!

Introducing 3ds Max 2019 and SDK Changes

3ds max 2019 is coming very soon! You can find the help is now online, with the new features discussed here. If you are a subscriber, you should see it listed in https://manage.autodesk.com soon (if not already there).

One of the first things you will notice is that 3ds Max 2019 is introducing support for the Open Shading Language (OSL). We have already started a github repo that will allow community members to share and contribute shaders. See here: https://github.com/ADN-DevTech/3dsMax-OSL-Shaders. For the overview and 3ds Max specific information pertaining to OSL shaders, see here: Open Shading Language (OSL) Support. Also check out the general OSL github repo and docs here.

Make sure to check out this AREA blog article announcing 3ds Max 2019:
https://area.autodesk.com/blogs/the-3ds-max-blog/meet-3ds-max-2019/

From the SDK perspective, this release is again a binary breaking release. Although the SDK itself did not change too much, you will have to recompile your plugins. The same development environment is specified as was in 2018, so mainly Microsoft Visual Studio 2015 Update 3, Platform Toolset v140, and Windows SDK 10.0.10586. Due to some new components, the .NET Framework is bumped to 4.7 and now Qt 5.6.3 or 5.6.2 can be used. See SDK Requirements here for complete details.

Highlights from the SDK changes include:

• Improved support for loading binary dependencies (DLLs in same folder as plug-in)
• Support for Autodesk Application Plug-in Packages, this is the same structure that the Autodesk App store uses
• Improved parameter block validation
• Improved support for saving to previous scene file versions of PB1 plugins migrated to PB2
• Thread Safe EvalXXX Methods improvements
• Vertex Velocity Interface
• New Double precision geometric primitives

For complete details, please see: What's New: 3ds Max 2019 SDK. 

 

Highlights from the MAXScript environment include:

• OSL Suport
• Shape Booleans
• Improvements to the Alembic import and export plug-ins are exposed to MAXScript

For complete details, please see: What's New in MAXScript in 3ds Max 2019

 

The Python version used by 3ds Max continues to be 2.7.12.

 

The .NET SDK now requires .NET Framework 4.7. There were minor bugs fixed here again, to help cleanup this environment.

That’s it for now! Enjoy 3ds Max 2019!

Updated .NET API Samples for 3ds Max 2018

Well, it's been a while since last posting, but trying to do more. Recently someone asked about the .NET API for recent versions of 3ds Max. There has really been no big changes for a few releases except moving from ParamBlock1 to ParamBlock2 for some of the older geometry objects and modifiers. .NET API, plus WPF, etc. still work OK, even though the main 3ds Max UI is moving to Qt. To demonstrate, I updated the samples I provided back in 2014 release to work with 2018. These are the things I changed to get everything working well again:

• Update the csproj variables to use the 3ds Max values (Currently: $(ADSK_3DSMAX_x64_2018)). Note the original project used: $(ADSK_MAXDES_x64_2014), but 3ds Max Design as not been available for several releases now, and is combined with 3ds Max as a workspace. That makes it easier to handle 3ds Max plugin projects! The variable changes are for the assembly references, and also for the Post-Build event command line, that provides the copy operation.
• The .NET Target framework should move to at least 4.6 to match the version 3ds Max itself is using.
• In the code, there was one place where we fixed a defect in Autodesk.Max.dll. Line #119 of HelixControl.xaml.cs was using the (IntPtr) cast for the IINodeTab value. We fixed that API to properly use an integer index, so the cast is no longer required.
• Updated a screen bitmap for the CreateTeapotUserControl
• Fixed the teapot creation in CreateTeapotUserControl... turns out it was updated with the move to ParamBlock2. Added a comment to show this.
• Added a tiny error check for the "05 - Create Face Objects" routine to ensure the user picks something before continuing.

Overall, pretty minor changes...I have attached the updated sample here: AdnCuiSamples_BlogV2018.

Enjoy!

 

3ds Max 2018 SDK Changes

Another year has passed, and we have a new release of 3ds Max! 3ds Max 2018 was released today, and should be available soon in your Autodesk Account access. The online help is also already rolled out.For new features, see What's New in 3ds Max 2018.

For the 3ds Max SDK changes, see  What's New: 3ds Max 2018 SDK. As in the past, the SDK is included in the install folder structure. Typically, it is here: .\x64\Tools\MAXSDK\SDK_3dsMax2018.msi

Some SDK highlights:

The first thing to note from the C++ programming perspective, is that the compiler has been bumped to Visual Studio 2015 update 3. You are probably already there with Visual Studio 2015, but be sure to check and update to ensure compatibility. Even though 3ds Max 2017 was using Visual Studio 2015 (RTM), you will have to rebuild any plugins. The 3ds Max 2018 release is not binary compatible with 2017.

Qt is also majorly bumped in 3ds Max 2018 and is now using Qt 5.6.2.

You will also notice that all the samples in the SDK have been updated to use the Parameter Block 2 standard. There's a new Parameter Block Porting Guide in the docs. Part of this is to encourage everyone with Parameter Block 1 definitions, to move to Parameter Block 2. In the future the old Parameter block 1 will be deprecated.

Two new features that came recently are the Data Channel Modifier, and the Bezier Trajectories. Both have some new SDK access in the 3ds Max 2018 SDK. Additionally, there were some minor UI API changes, and also around the Rendering APIs. See the help for details.

Other programming environments:

For 3ds Max 2018 MAXScript changes, check-out What's New in MAXScript in 3ds Max 2018.

For 3ds Max 2018 Python changes, check-out What's New in the 3ds Max 2018 Python API.

There were also a few minor changes to the 3ds Max 2018 .NET API assemblies. Mainly cleaning up signatures, and other miscellaneous fixes.

 

Happy coding with 3ds Max 2018!

 

How to properly check if a material is used in a scene?

Sometimes you may need to know if a given material is used within the scene or not. In Compact Material Editor it is usually marked with the UI giving you certain clues. For example, in the screen capture below, the gray corners indicate the material is used in the scene. Corners that are filled in white, indicate the material is used, and also is being used by a selected scene object. The white rectangle indicates it is the currently selected material.

The same indicators are found in the Slate Material editor. They will display on the preview of the material.

 

 

The obvious question now is how to retrieve this information using the C++ SDK? Let's take a look at how to do it.

The very first step is to have a look at the MtlBase class where you will notice the int TestMtlFlag(int mask) that "Tests the specified flags. Returns nonzero if the flags are set; otherwise zero” . Among the available Materials flags we can notice the MTL_IN_SCENE flag, that seems to be exactly what we need.

Thus, to test if a material is used or not we can easily do:

if(my_material->TestMtlFlag(MTL_IN_SCENE))
{
    \\ It is used
} else
{
    \\it is not
}

Hurrah! Job is done, let's go home.

Not so fast.

The MTL_IN_SCENE flag is useful only if somebody sets this flag (calling MtlBase::SetMtlFlag), but it turns out that nobody sets this specific flag, like ever. Thus, it will always return 0, no matter what, and even if you have assigned this material to dozens of objects in the scene, it is never accurate, unless someone sets it (maybe you set it in your plugin, but is seems none of the default materials are doing this.)

Other (Materials) flags seems to be working fine, thus being useful, but not this one. So, let's get back to work.

This question is not new, and there are lot of (mostly MAXScript) recipes on how to check whenever a given material is used somewhere in the scene, and the common algorithm is to get the scene materials and check if the material in question is found among them.

That should be piece of cake, as the Interface Class offers us the GetSceneMtls method, and the returned MtlBaseLib has the handy FindMaterial method for finding a material by name:

bool materialIsUsed(MtlBase* this_material)
{
   MtlBaseLib* scene_materials = GetCOREInterface()->GetSceneMtls();

   return (scene_materials->FindMtl(this_material) != -1) ? true : false;
}

Easy say, easy do - can we go home now?
Not yet ... not yet ...

It turns out that this approach is not very reliable (noticed by many developers), and the reason is that there is no dynamic tracking of the materials in the scene, thus the material library returned by the Interface::GetSceneMtls might not contain the latest information.

There is a way to manually reset and rebuilding the scene lib, but unfortunately it is available only in MAXScript as ‘UpdateSceneMaterialLib()’method, and there is not yet a C++ SDK equivalent.

"So, what it is the big deal? We can execute MAXScript from C++, we can live with that."

Well ... there is yet another problem.

If the material in question is a part of a sub-material, then you can check in the scene materials lib whenever you want, it will not show up, because (in a manner of speaking) it contains only the “first level” materials and will not contain the materials that are part/contained in other materials (g.e. multi-material).

“Then, what could be the solution?”

The solution is given us by the Reference System, because if we look at MtlBase inheritance diagram:

we notice the obvious aspect, that any material (like many other classes in 3ds Max SDK) is also a Reference Target.

This is obvious, because logically, a material has to have dependents, that are notified upon change (i.e. change the diffuse color).

Thus, what is left is to iterate through these dependents, using the dedicated DependentIterator Class and recursively check the dependents.

Easy say, but not so obviously done:

static bool  isNodeInScene(INode* node)
{
       for (INode* par = node->GetParentNode();
              par != nullptr;
              node = par, par = node->GetParentNode()) {
       }
       return node == GetCOREInterface()->GetRootNode();
}

 static bool isUsedInScene(ReferenceTarget *mt)
{
       DependentIterator di(mt);
       RefMakerHandle rm;

       if (mt->SuperClassID() == BASENODE_CLASS_ID) {
              return isNodeInScene(static_castINode*>(mt));
       }

       while ((rm = di.Next()) != NULL) {
              if (rm != mt && rm->IsRefTarget()
                     && isUsedInScene(static_castReferenceTarget*>(rm)))
                     return true;
       }
       return false;
}

Thus, to check if a given material is used in the scene or not, it suffice to call:

if(isUsedInScene(my_material))
{
    \\ It is used
}else
{
    \\it is not
}

and the cool thing with this approach is that (I guess you already noticed) it can be used with anything that is “referable” (i.e. is a ReferenceTarget), and that could be more interesting than just for materials.