API Change List in S26

Table of Contents

• API Changes in S26.107
  • asset.framework
  • cinema.framework
  • core.framework
  • corenodes.framework
  • graph.framework
  • misc.framework
  • neutron.framework
  • nodes.framework
  • volume.framework
• API Changes in S26.013
  • asset.framework
  • cinema.framework
  • cinema_hybrid.framework
  • command.framework
  • core.framework
  • corenodes.framework
  • exchange.framework
  • geom.framework
  • graph.framework
  • image.framework
  • math.framework
  • mesh_misc.framework
  • misc.framework
  • network.framework
  • neutron.framework
  • nodes.framework
  • nodespace.framework
  • python.framework

API Changes in S26.107

asset.framework

asset_utilities.h

class AssetUtilitiesInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  static MAXON_METHOD Result<EnumDataType> GetEnumTypeForVersions(const AssetRepositoryRef& repo, const AssetType& type, const Id& assetId);
}

cinema.framework

c4d_customgui/customgui_itemtree.h

#define ITEMTREE_CALLBACK_GETHEADERCOLUMNWIDTH 29

c4d_libs/lib_description.h

enum DESC
{
  DESC_FORBID_COLOR_CONVERSION  = 42, 
  DESC_COLOR_CONVERTED  = 43,     
}

c4d_baselist.h

#define MSG_DOCUMENT_CONVERT_COLORS   1059361 
 
struct MessageDocumentConvertColors;

c4d_shader.h

extern Vector TransformColor(const Vector& input, COLORSPACETRANSFORMATION colortransformation);
// Changed to
extern Vector TransformColor(const Vector& input, COLORSPACETRANSFORMATION colortransformation, Bool force = false);
 
extern maxon::Color TransformColor(const maxon::Color& input, COLORSPACETRANSFORMATION colortransformation, Bool force = false);
// Changed to
extern maxon::Color TransformColor(const maxon::Color& input, COLORSPACETRANSFORMATION colortransformation, Bool force = false);

ge_prepass.h

enum class BOOLESETTINGS
{
  SMOOTHRADIUS = 2    
}
 
#define WPREF_CONSOLE_WIDTH   1059398 
 
#define WPREF_MATVP_DEFAULT_SIZE              1096      
// Changed to
#define WPREF_OPENGL_PREVIEWSIZE              1096      
 
#define WPREF_MATMANAGER_ALWAYS_OPEN_NODE_EDITOR  1097      
#define WPREF_OPENGL_SKY_PREVIEWSIZE          1098      
 
// Removed
#define WPREF_NODE_EDITOR_WIRE_STYLE  1055260 
 
// Removed
#define WPREF_NODE_EDITOR_WIRE_STYLE_BEZIER   0 
 
// Removed
#define WPREF_NODE_EDITOR_WIRE_STYLE_STRAIGHT 1 
 
#define WPREF_NODE_EDITOR_IDS         1055264 ///< ::Bool Shows node ids in info area. @since S26.1

operatingsystem.h

#define API_VERSION 26000
// Changed to
#define API_VERSION 26100

core.framework

application.h

enum class APPLICATIONFEATURE
{
  LIBRARY =     (1 << 1), 
  UI =      (1 << 2), 
}

applicationid.h

namespace APPLICATIONID
{
  static const LiteralId CINEWARE{"net.maxon.application.cineware"};
  // Changed to
    static const LiteralId CINEWARE_APP{"net.maxon.application.cineware_app"};
 
    static const LiteralId CINEWARE_STATIC{"net.maxon.application.cineware_static"};
}

array.h

class ArrayFactory
{
  static MAXON_METHOD Result<Array<Generic>> ConvertToSingleBlock(const Array<Generic>& source);
  template <typename T> static Result<Array<T>> ConvertToSingleBlock(const Array<T>& source);
}

datadescription_data.h

namespace maxon
{
    namespace DESCRIPTION
    {
        namespace DATA
        {
            namespace BASE
            {
                MAXON_ATTRIBUTE(void, GUIANDLIMITPRESET, "net.maxon.description.data.base.guiandlimitpreset");
            }
 
            namespace INFO
            {
 
                // Removed
                RESOURCE_DEFINE(ENUM_TEMPLATE, Id("template"))
 
        RESOURCE_DEFINE(ENUM_ATTRIBUTE_TEMPLATES, Id("attribute_templates"))
        RESOURCE_DEFINE(ENUM_DATATYPE_TEMPLATE, Id("datatype_template")));
            }
        }
    }
}

datadescription_ui.h

namespace maxon
{
    namespace DESCRIPTION
    {
        namespace DATA
        {
            namespace BASE
            {
          MAXON_ATTRIBUTE(Id, PRESETDATABASEDYNAMICID, "net.maxon.description.ui.base.presetdatabasedynamicid");
            }
        }
    }
}

datadescriptiondatabase.h

#define VARIABLEID_PREFIX         "var#"
#define DATADESCRIPTION_ID_COMMAND      "#command#"_cs
#define DATADESCRIPTION_ID_ENUM       "#enum#"_cs
#define DATADESCRIPTION_ID_PRESET     "#preset#"_cs
 
class DataDescriptionDatabaseInterface
{
  static MAXON_METHOD Result<BaseArray<Tuple<Id, Data, String>>> GetEffectiveEnumList(const DataDictionary& dataEntry,
  static MAXON_METHOD Result<Id> ResolveVariableIdentifier(const Id& identifier, const AssetRepositoryRef& repository, const GetDataCallbackType& getDataCallback, Opt<const DataDictionary&> dataEntry, Opt<const DataDictionary&> guiEntry = Opt<const DataDictionary&>{});
  static MAXON_METHOD Result<Id> GetAndResolvePresetIdentifier(const AssetRepositoryRef& repository, const GetDataCallbackType& getDataCallback, const DataDictionary& guiEntry, Opt<const DataDictionary&> dataEntry = Opt<const DataDictionary&>{}, Bool& outResolveFailed = DefaultLValue<Bool>{});
}
 
using EnumVariableResolveDelegate = Delegate<Result<CString>(const CString& variable, const CString& fullString, const AssetRepositoryRef& repository, const GetDataCallbackType& getDataCallback, Opt<const DataDictionary&> dataEntry, Opt<const DataDictionary&> guiEntry)>;
MAXON_DATATYPE(EnumVariableResolveDelegate, "net.maxon.datatype.delegate.enumvariableresolve");
MAXON_REGISTRY(EnumVariableResolveDelegate, EnumVariableResolveDelegates, "net.maxon.datadescription.registry.enumvariableresolve");

datadescriptiondefinitiondatabase.h

class DataDescriptionDefinitionDatabaseInterface
{
  static MAXON_METHOD Result<void> WriteUserChangedDataBases();
  static MAXON_METHOD Bool QueryNeedsWriteDataBasesForUserChanges();
}

datadescriptiondefinitiondatabaseimpl.h

class DataDescriptionDefinitionDatabaseImplInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_METHOD Int GetChangeCount() const;
  // Changed to
    MAXON_METHOD Int GetChangeCounts() const;
 
  MAXON_METHOD Int GetUserChangeCount() const;
 
  MAXON_METHOD Result<void> WriteUserChangedDataBases();
}

corenodes.framework

corenodes_lib.h

class CoreNodesLib
{
  static MAXON_METHOD Result<Bool> ConvertArgument(TrivialDataPtr& arg, const DataType& expectedType, PointerArray<Data>& resultReferences);
  // Changed to
    static MAXON_METHOD Result<Bool> PrivateConvertArgument(TrivialDataPtr& arg, const DataType& expectedType, PointerArray<Data>& resultReferences);
}

graph.framework

graph.h

class GraphModelInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  enum class GET_CONNECTIONS_MODE
    {
        // Deprecated. Use Wires::All(WIRE_MODE::ALL_INCLUDING_IMPLICIT).")
        WITH_IMPLICIT_FLAG = 32
 
        SKIP_REROUTER = 256,        
    }
}

misc.framework

stringregularexpression.h

class RegularExpressionInterface
{
  using FindRecvType = Tuple<Int, String>;
  MAXON_METHOD Result<Bool> FindAll(const String& text, REGPARSEMODE mode, const ValueReceiver<const FindRecvType&>& recv, Bool onlyFirst = false) const;
}

neutron.framework

neutron_ids.h

static constexpr Int32 MSG_ENABLE_ASSET_TO_GROUP = 180420123;
static constexpr Int32 MSG_SET_ASSET_WITH_VERSION = 180420304; // expects a pointer to an IdAndVersion of a node asset which can be found in the scope of the current document's repository
static constexpr Int32 CAPSULE_BASE_ID = 180420800;
static constexpr Int32 IDM_CAPSULE_ASSET_TO_GROUP = 180429000;

nodes.framework

nodes_import.h

class SerializationNodeData
{
  MAXON_METHOD ASSET_UPDATE_POLICY& GetUpdatePolicy();
  MAXON_METHOD CHILD_MODE GetChildMode() const;
}

nodesystem.h

class NodeSystemInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
    MAXON_METHOD AssetRepositoryRef GetTemplateLookupRepository() const;
    // Changed to
    MAXON_METHOD AssetRepositoryRef GetTemplateLookupRepository();
 
    Result<MutableRoot> BeginModification(Bool keepCurrent);
    // Changed to
    Result<MutableRoot> BeginModification(const AssetRepositoryRef& repo, Bool keepCurrent = false);
 
    Result<MutableRoot> BeginInstantiationModification(const NodeTemplate& templ);
    // Changed to
    Result<MutableRoot> BeginInstantiationModification(const AssetRepositoryRef& repo, const NodeTemplate& templ);
 
    Result<MutableRoot> BeginSubstitutionModification(const AssetRepositoryRef& lookup, const NodeTemplate& original, const TemplateArguments& args);
    // Changed to
    Result<MutableRoot> BeginSubstitutionModification(const AssetRepositoryRef& repo, const NodeTemplate& original, const TemplateArguments& args);
 
    Result<MutableRoot> BeginSubstitutionModification(const NodeSystem& original);
    // Changed to
    Result<MutableRoot> BeginSubstitutionModification(const AssetRepositoryRef& repo, const NodeSystem& original);
 
    // Deprecated
    MAXON_METHOD Result<MutableRoot> CreateInstance() const;
 
    MAXON_METHOD Result<MutableRoot> CreateInstance(const AssetRepositoryRef& repo) const;
 
    // Deprecated
    MAXON_METHOD Result<NodeSystem> CreateCopyOfSelection(const NodePath& basePath, const Block<const InternedId>& selection) const;
 
  MAXON_METHOD Result<NodeSystem> CreateCopyOfSelection(const AssetRepositoryRef& repo, const NodePath& basePath, const Block<const InternedId>& selection) const;
 
    // Deprecated
    MAXON_METHOD Result<void> BeginModificationImpl();
 
    MAXON_METHOD Result<void> BeginModificationImpl(const AssetRepositoryRef& lookup);
}
 
class NodeSystem : public NodeSystemInterface::Reference
{
private:
  // Moved to private section. For modification of a node system you have to call BeginModification.
  using Reference::MakeWritable;
}
 
template <typename BASE> class GNodeFunctions : public BASE
{
  template <typename T> Result<const T&> GetConstantValue(const T& def = maxon::NullValue<const T&>()) const;
}
 
class MutableRoot : private MutableNode
{
  AssetRepositoryRef GetLookupRepository() const;
 
    Result<MutableNode> AddChild(const Id& childId, const Result<NodeTemplate>& templ, const Result<TemplateArguments>& args = GetZeroRef<Result<TemplateArguments>>(), const AssetRepositoryRef& lookup = maxon::NullValue<const AssetRepositoryRef&>(), Opt<ChangeList&> list = {}) const;
    // Changed to
    Result<MutableNode> AddChild(const Id& childId, const Result<NodeTemplate>& templ, const Result<TemplateArguments>& args = GetZeroRef<Result<TemplateArguments>>(), Opt<ChangeList&> list = {}) const;
}

nodesystem_class.h

class NodeSystemClassInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
    // Deprecated.
  MAXON_METHOD Result<MutableRoot> CreateNodeSystem() const;
 
    MAXON_METHOD Result<MutableRoot> CreateNodeSystem(const AssetRepositoryRef& repo) const;
}

nodesystem_derivation.h

class NodeSystemDerivationHandlerInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
    // Deprecated
  MAXON_METHOD Result<Tuple<VALUEMODE, Data>> ComputeConstantValue(const Port& port) const;
 
    MAXON_METHOD Result<Bool> UpdateDerivedValue(const Port& port, VALUEMODE& outMode, Data& outValue) const;
}

portattributes.h

enum class PORT_FLAGS
{
  USED_FOR_TEMPLATE_MASK = USED_FOR_TEMPLATE_ARGUMENT | USED_FOR_INPUTPORTTYPE_TEMPLATE_ARGUMENT | USED_FOR_INPUTBUNDLE_TEMPLATE_ARGUMENT,
}

volume.framework

volumetools.h

class VolumeToolsInterface
{
  static MAXON_METHOD Result<Volume> SmoothBoolVolumes(const Volume& volumeOne, const Volume& volumeTwo, BOOLTYPE type, Float radius);
}

API Changes in S26.013

asset.framework

asset_strings.h

namespace maxon
{
namespace ASSET
{
  namespace GLOBALSTRINGS
    {
    MAXON_ATTRIBUTE(String, LOADINGASSETDBS, "net.maxon.asset.globalstrings.loadingassetdbs");
 
    MAXON_ATTRIBUTE(String, SCANNINGWATCHFOLDER, "net.maxon.asset.globalstrings.scanningwatchfolder");
  }
}
}

asset_watchfolder.h added.

assets.h

namespace maxon
{
namespace ASSETMETADATA
{
  MAXON_ATTRIBUTE(UInt64, ASSET_SIZE, "net.maxon.asset.size");
}
}
 
class AssetMetaDataInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  enum class KIND
  {
        MASK = 0xffff,          
        IGNORE_READ_ONLY = (1 << 16)  
  }
 
    template <typename T> MAXON_FUNCTION Result<typename T::ValueType> Get(const T& attr, const typename T::ValueType& defaultValue = NullValue<const typename T::ValueType&>()) const
    // Changed to
    template <typename T> MAXON_FUNCTION Result<Opt<T>> Get(const InternedId& metaId) const
 
    template <typename ATTR> MAXON_FUNCTION Result<Opt<typename ATTR::ValueType>> Get(const ATTR& attr) const
 
    template <typename ATTR> MAXON_FUNCTION Result<typename ATTR::ValueType> Get(const ATTR& attr, const typename ATTR::ValueType& defaultValue) const
}
 
enum class ASSET_FIND_MODE
{
    enum class ASSET_FIND_MODE
    {
      CHECK_CANCELLATION = 1 << 6,                  
        PRIVATE_QUERY_REPOSITORY_VISIBILITY = 1 << 7, 
    }
}
 
class AssetRepositoryInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface, DataDictionaryObjectInterface)
{
  MAXON_METHOD void RequestUnloadRepository();
}
 
class CompactableAssetRepositoryInterface : MAXON_INTERFACE_BASES(AssetRepositoryInterface)
{
  MAXON_METHOD Result<void> CompactInBackground(const BackgroundProgressRef & backgroundJob);
 
    MAXON_METHOD Bool HasIndex();
}

base_preset_asset.h

class ResolveAssetDependenciesStruct
{
  MAXON_DISALLOW_COPY_AND_ASSIGN(ResolveAssetDependenciesStruct)
    MAXON_OPERATOR_MOVE_ASSIGNMENT(ResolveAssetDependenciesStruct);
 
    maxon::Result<void> CopyFrom(const ResolveAssetDependenciesStruct& src);
}
 
MAXON_DATATYPE(ResolveAssetDependenciesStruct, "net.maxon.datatype.resolveassetdependenciesstruct");
 
 
class AddAssetDepencendyStruct : public StoreAssetStruct
{
  MAXON_DISALLOW_COPY_AND_ASSIGN(AddAssetDepencendyStruct)
  MAXON_OPERATOR_MOVE_ASSIGNMENT(AddAssetDepencendyStruct);
 
    maxon::Result<void> CopyFrom(const AddAssetDepencendyStruct& src);
}
 
MAXON_DATATYPE(AddAssetDepencendyStruct, "net.maxon.datatype.addassetdepencendystruct");

category_asset.h

MAXON_ATTRIBUTE(void, AssetCategoryWatchFolders, "category@5846c0689c0248cfa54bffed866571ce");

derived_metadata.h

namespace maxon
{
namespace ASSETMETADATA
{
  MAXON_ATTRIBUTE(CString, DerivedMetaDataStamp, "net.maxon.asset.derivedmetadatastamp");
}
}

cinema.framework

c4d_customgui/customgui_bitmapbutton.h

#define BITMAPBUTTON_FORCE_TOOLTIP  'ftti'  
#define BITMAPBUTTON_NO_COLOR_INFO  'ncoi'  ///< ::Bool Hides the per-pixel color info that pops-up when holding CTRL key on mouse hover when @ref BITMAPBUTTON_BUTTON is @formatConstant{false}. @since S26

c4d_customgui/customgui_fontchooser.h

FONTCHOOSER_ENABLE_FILTER = 'filt', ///< ::Bool @formatConstant{true} Whether font filter field should be displayed.

c4d_customgui/customgui_inexclude.h

#define IN_EXCLUDE_DATA_BACKGROUND  11  
#define IN_EXCLUDE_DATA_ROWFLAGS  12  
#define IN_EXCLUDE_FLAG_DISABLE_CONTEXTMENU 2071  ///< ::Bool @formatConstant{true} if right click context menu should be deactivated. @since S26

c4d_libs/lib_description.h

struct DescriptionImExportVerifySuffix : public DescriptionBaseMessage
{
  String* _suffix = nullptr;       
  Bool    _addToRecentList = true; 
}
 
c4d_basebitmap.h
 
@code
class ColorProfile : public CustomDataType
{
  enum COLORPROFILEINFO
  {
        COLORPROFILEINFO_NAME           = 4 
  }
}

c4d_basedocument.h

Bool LoadFile(const Filename& name);
// Changed to
Bool LoadFile(const Filename& name, Bool allowAsync);
 
using ProgressDelegate = maxon::Delegate<Bool(Float percent)>;
 
BaseDocument* LoadDocument(const Filename& name, SCENEFILTER loadflags, BaseThread* thread, maxon::String* errorString = nullptr);
// Changed to
BaseDocument* LoadDocument(const Filename& name, SCENEFILTER loadflags, BaseThread* thread, maxon::String* errorString = nullptr, const ProgressDelegate& progressDelegate = ProgressDelegate());
 
Bool MergeDocument(BaseDocument* doc, const Filename& name, SCENEFILTER loadflags, BaseThread* thread, maxon::String* errorString = nullptr);
// Changed to
Bool MergeDocument(BaseDocument* doc, const Filename& name, SCENEFILTER loadflags, BaseThread* thread, maxon::String* errorString = nullptr, const ProgressDelegate& progressDelegate = ProgressDelegate());

c4d_basedraw.h

class BaseView : public BaseList2D
{
  Int32 GetColorSpace() const;
}
 
class BaseDraw : public BaseView
{
  static Int32 GetColorSpaceFromDocumentIndex();
}

c4d_baselist.h

#define MSG_DESCRIPTION_IMPEXPORT_VERIFY_SUFFIX     1058891     ///< Sent after the export options dialog was closed and before the save dialog will be shown. @correspondingData{DescriptionImExportVerifySuffix}

c4d_colors.h

COLOR_MENU_TEXT_SEPARATOR,
COLOR_TEXT_SEPARATOR,
COLOR_WARNING,
COLOR_ERROR,
COLOR_NETSTATE_DISABLED,
COLOR_NETSTATE_IDLE,
COLOR_NETSTATE_BUSY,
COLOR_NETSTATE_BUSY2,
COLOR_NETSTATE_CRITICAL,

c4d_file.h

class Filename
{
  static maxon::Result<Bool> FileSelectMultiple(FILESELECT flags, const maxon::String& title, const maxon::Url& startUrl, const maxon::Id& settingsIdentifier, const maxon::Block<maxon::Tuple<maxon::String, maxon::String>>& filterStrings, const maxon::ValueReceiver<const maxon::Url&>& selectedUrls);
}

c4d_filterdata.h

#define PLUGINFLAG_SCENELOADER_SUPPORT_ASYNC (1 << 25)
#define PLUGINFLAG_SCENELOADER_SUPPORT_MERGED_OPTIONS (1 << 22)

c4d_general.h

void  SetActiveScriptObject(Int32 type);
BaseList2D* CreateNewPythonScript(String& name, const String& body);
BaseList2D* LoadPythonScript(const Filename& fn);
Int32 GetFormatDepth(Int32 format, Int32 depth);

c4d_gui.h

class GeDialog
{
  Bool MenuAddSeparator(void);
  // Changed to
    Bool MenuAddSeparator(const maxon::String& title = maxon::String());
 
    Int32 IsDockedOrTabbed();
}
 
c4d_objectdata.h
 
@code
Bool RegisterObjectPlugin(Int32 id, const maxon::String& str, Int32 info, DataAllocator* g, const maxon::String& description, BaseBitmap* icon, Int32 disklevel, OBJECTCATEGORY category);

c4d_shader.h

struct InitRenderStruct
{
  explicit InitRenderStruct(BaseDocument* t_doc);
  // Changed to
    explicit InitRenderStruct(BaseDocument* t_doc, Int32 overrideViewTransform = -1);
 
    void Init(BaseDocument* t_doc);
    // Changed to
    void Init(BaseDocument* t_doc, Int32 overrideViewTransform = -1);
}

ge_prepass.h

enum class SCENEFILTER
{
  SUPPRESSOPTIONSDIALOG = (1 << 31),  
}
 
enum class VIEW_WINDOW_COLOR_SPACE : Int32
{
  UNDEFINED = 0,  
  LINEAR    = 1,  
  SRGB    = 2,  
} MAXON_ENUM_LIST(VIEW_WINDOW_COLOR_SPACE);
 
 
#define OBJECT_HASDEFORMMODE  (1 << 18) 
 
#define Orscamera   1057516     
#define Tcineware 465000402   
 
#define MCOMMAND_AUTOMATICUV    1053624 
#define MCOMMAND_PACKUVRASTERIZED 1053659 
#define MDATA_AUTOMATICUV_ALLOWSTRETCH    2247    
#define MDATA_AUTOMATICUV_MERGEMULTIOBJECT  2248    
 
#define WPREF_SAVEDLOGGER   1058544 
 
#define WPREF_MATVP_DEFAULT_SIZE    1096    
 
#define COLORSYSTEM_RANGE_1     3 
 
#define PYTHONSCRIPT_SCRIPTPATH 3 
 
enum
{
  DIALOG_ISDOCKETORTABBED,            
    #define DIALOG_ISDOCKED (1 << 0)    
    #define DIALOG_ISTABBED (1 << 1)    
}

gui.h

enum
{
  FONT_SMALL_BOLD = 7,    
  FONT_BIGGER   = 8     
}
 
enum
{
  DR_MULTILINE_LINECOUNT  = 1048576,  
}
 
CMD_VALUE_MASK      = 0x0FFFFFFF,   
CMD_HIDDEN      = 0x20000000,   ///< Hidden.

modelingids.h

#define ID_MODELING_FITCIRCLE_TOOL    1058461   
#define ID_MODELING_EDGESMOOTH_TOOL   1058499   
#define ID_MODELING_SETEDGEFLOW_TOOL  1058529   
#define ID_MODELING_SETEDGESLINEAR_TOOL 1058543     
#define ID_MODELING_EVENSPACING_TOOL    1058592     
#define ID_MODELING_FLATTEN_TOOL        1058447     ///< Flatten Tool. See toolflatten.h

operatingsystem.h

#define API_VERSION 25108
// Changed to
#define API_VERSION 26000
 
struct C4D_Object
{
  Bool    (*RegisterObjectTypeToCategory)(Int32 type, OBJECTCATEGORY category);
  Bool  (*ObjectTypeToCategory)(Int32 type, OBJECTCATEGORY& category);
}

struct C4D_General { void (*LayoutOrderChanged)(Int sourceLayoutIndex, Int destinationLayoutIndex); void (*UpdateUIAfterRenderEngineChange)(); }

cinema_hybrid.framework

asset_creation.h

enum class GENERATESCENEPREVIEWIMAGEFLAGS
{
  AUTODETECT_RENDERENGINE = (1 << 4), 
}
 
class AssetCreationInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  static MAXON_METHOD Result<AssetDescription> SaveDocumentAsset(BaseDocument* assetDoc, InternedId subType, Id newAssetId, const StoreAssetStruct& storeAssetStruct, const String& assetName, const String& versionString, const Delegate<Result<BaseBitmap*>()>& createPreviewBitmapDelegate, const AssetMetaData& copyMetaData, Bool addAssetsIfNotInThisRepository, ResolveAssetDependenciesStruct& resolveAssets);
 
    static MAXON_METHOD Result<AssetDescription> CreateObjectAsset(BaseObject* op, BaseDocument* activeDoc, const StoreAssetStruct& storeAssetStruct,
        const Id& assetId, const String& assetName, const String& assetVersion, const AssetMetaData& copyMetaData, Bool addAssetsIfNotInThisRepository, ResolveAssetDependenciesStruct& resolveAssets);
 
  static MAXON_METHOD Result<AssetDescription> CreateMaterialAsset(BaseDocument* activeDoc, BaseMaterial* mat, const StoreAssetStruct& storeAssetStruct,
    const Id& assetId, const String& assetName, const String& assetVersion, const AssetMetaData& copyMetaData, Bool addAssetsIfNotInThisRepository, ResolveAssetDependenciesStruct& resolveAssets);
}

assetmanagerinterface.h

class AssetManagerInterface
{
  static MAXON_METHOD Result<Bool> LoadAssets(const AssetRepositoryRef& searchRepository, const HashMap<Id, String>& selectionAndFilterString, const GraphModelPresenterRef& presenter, const nodes::NodesGraphModelRef& graphModelRef);
  // Changed to
    static MAXON_METHOD Result<Bool> LoadAssets(const AssetRepositoryRef& searchRepository, const HashMap<Id, String>& selectionAndFilterString, const GraphModelPresenterRef& presenter = GetZeroRef<GraphModelPresenterRef>(), const nodes::NodesGraphModelRef& graphModelRef = GetZeroRef<nodes::NodesGraphModelRef>());
}

commandgetstatedelegate.h added. createdefaultmaterialdelegate.h added. numtostring.h added. py_element.h added. py_element_detector.h added. py_element_manager.h added.

command.framework

commandobservable.h

struct InvocationState
 
class CommandObserverInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  MAXON_OBSERVABLE(Result<void>, ObservableCommandPrepareInfo, (const Id& commandId, const CommandDataRef& data), ObservableCombinerRunAllComponent);
    MAXON_OBSERVABLE(Result<void>, ObservableCommandInvokedInfo, (const Id& commandId, const Result<COMMANDRESULT>& result, const CommandDataRef& data, const InvocationState& interactionState), ObservableCombinerRunAllComponent);
}
 
MAXON_DATATYPE(InvocationState, "net.maxon.datatype.command.invokationstate");

core.framework

math/vec.h

template <typename T> struct Vec3<T, 1>
{
    template <typename T2, Int S2> explicit constexpr Vec3(const Vec2<T2, S2>& v, T vz = T()) : x((T)v.x), y((T)v.y), z(vz) { }
    // Changed to
  template <typename T2, Int S2, typename SPACE2> explicit constexpr Vec3(const Vec2<T2, S2, SPACE2>& v, T vz = T()) : x((T)v.x), y((T)v.y), z(vz) { }
 
    explicit constexpr Vec3(ENUM_DONT_INITIALIZE v) { }
    // Changed to
    explicit constexpr Vec3(ENUM_DONT_INITIALIZE v) { }
 
}

math/vec2.h

template <typename T> struct Vec2<T, 1>
// Changed to
template <typename T, typename SPACE> struct Vec2<T, 1, SPACE>
{
  template <typename T2, Int S2> explicit constexpr Vec2(const Vec2<T2, S2>& v) : x((T)v.x), y((T)v.y) { }
    // Changed to
    template <typename T2, Int S2> explicit constexpr Vec2(const Vec2<T2, S2, SPACE>& v) : x((T)v.x), y((T)v.y) { }
 
  template <Int S2> constexpr Vec2(const Vec2<T, S2>& v) : x(v.x), y(v.y) { }
    // Changed to
  template <Int S2> constexpr Vec2(const Vec2<T, S2, SPACE>& v) : x(v.x), y(v.y) { }
 
    constexpr explicit Vec2(ENUM_DONT_INITIALIZE v) { }
    // Changed to
    explicit constexpr Vec2(ENUM_DONT_INITIALIZE v) { }
}

math/vec2.h

template <typename T> struct Vec4<T, 1>
{
  constexpr explicit Vec4(ENUM_DONT_INITIALIZE v) { }
  // Changed to
    explicit constexpr Vec4(ENUM_DONT_INITIALIZE v) { }
 
    Vec3<T, STRIDE>& GetVector3() { return *(Vec3<T, STRIDE>*) this; }
}

utilities/apibaseid.h

class LiteralId
{
  Bool IsEmpty() const
  // Changed to
    constexpr Bool IsEmpty() const
 
  Bool IsPopulated() const
    // Changed to
    constexpr Bool IsPopulated() const
 
  const Char* GetCString() const
    // Changed to
    constexpr const Char* GetCString() const
 
    Int GetCStringLength() const
    // Changed to
    constexpr Int GetCStringLength() const
}
 
class Id : public LiteralId
{
  template <typename... INPUTTYPE>
  static Result<Id> Create(INPUTTYPE&&... inputId);
}

utilities/apibasemath.h

MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo(UInt32 x)
// Changed to
MAXON_ATTRIBUTE_FORCE_INLINE constexpr Bool IsPowerOfTwo(UInt32 x)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo(UInt64 x)
// Changed to
MAXON_ATTRIBUTE_FORCE_INLINE constexpr Bool IsPowerOfTwo(UInt64 x)

utilities/closurejob.h

namespace details
{
template <typename FN> static ResultPtr<JobInterface> CreateCancelledObserver(FN&& src);
}

utilities/debugdiagnostics.h

enum class OUTPUT
{
  NONE          = 0,
  PRETTYPRINT   = (1 << 28), 
}
 
#define OutputWithFlags(flags, formatString, ...)

algorithms.h

template <typename INDEXABLE, typename MATCHER> static
auto CountIfMatch(INDEXABLE&& indexable, MATCHER matcher) -> Match<Int>;
 
template<typename ITERABLE1, typename ITERABLE2>
inline auto SetDifference(const ITERABLE1& firstSet, const ITERABLE2& secondSet) -> Result<ITERABLE1>;
 
template<typename ITERABLE1, typename ITERABLE2, typename APPENDABLE>
inline auto SetDifference(const ITERABLE1& firstSet, const ITERABLE2& secondSet, APPENDABLE& outContainer) -> Result<void>;
 
template<typename ITERABLE, typename FINDABLE>
inline auto UnorderedSetDifference(const ITERABLE& firstSet, const FINDABLE& secondSet) -> Result<ITERABLE>;
 
template<typename ITERABLE, typename FINDABLE, typename APPENDABLE>
inline auto UnorderedSetDifference(const ITERABLE& firstSet, const FINDABLE& secondSet, APPENDABLE& outputContainer) -> Result<void>;
 
template<typename ERASABLE, typename ITERABLE>
inline auto ExcludeSetFromSet(ERASABLE& firstSet, const ITERABLE& secondSet) -> Result<void>;

apibase.h

#define MAXON_CORE_FRAMEWORK_VERSION 25000
// Changed to
#define MAXON_CORE_FRAMEWORK_VERSION 26000
 
#define MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE
 
static constexpr Int ZERO_MEMORY_SIZE = 1024;
 
struct HashValue
{
  Bool operator <(const HashValue& other) const;
  MAXON_OPERATOR_INEQUALITY(HashValue);
  void CombineUnordered(const HashValue& other);
}
 
enum class VALUEKIND : UInt64
{
  SINGLETON_CONTAINER   = 3LL << 54,  
    // Changed to
    VIRTUAL_TUPLE_CONTAINER = 3LL << 54,  
 
    BUNDLE          = 1LL << 62,  
}
 
template <typename... INPUTTYPE> inline Result<Id> Id::Create(INPUTTYPE&&... inputId);
 
template <typename T> inline void Destruct(T* object)
// Changed to
template <typename T> inline void Destruct(const T* object)
 
template <typename T, typename... ARGS> static auto Create(ARGS&&... args)

applicationid.h

namespace APPLICATIONID
{
  static const LiteralId FORGER{"net.maxon.application.forger"};
}

array.h

template <typename TYPE> class StaticArrayInterface : public GenericContainerInterface MAXON_GENERIC_BASE(NamedTuple<TYPE>)
// Changed to
template <typename TYPE> class StaticArrayInterface : public GenericIndexableContainerInterface MAXON_GENERIC_BASE(NamedTuple<TYPE>)
{
  MAXON_METHOD Result<void> MakeAllElementsWritable(Bool copyElements = true);
  MAXON_METHOD Result<void> MakeElementsWritable(Int start, Int end, Bool copyElements = true);
 
}
 
class ArrayFactory
{
  static Result<ArrayInterface<Generic>*> NewBaseArray(const DataType& type, Int size = 0, COLLECTION_RESIZE_FLAGS flags = COLLECTION_RESIZE_FLAGS::DEFAULT);
  static MAXON_METHOD Result<Array<Generic>> NewPagedArray(const DataType& elementType, const Generic* defaultValue = nullptr, Bool useRefCountForDefault = false);
  static MAXON_METHOD Result<Array<Generic>> NewPagedArrayFromContainerType(const ContainerDataType<>& containerType, const Generic* defaultValue = nullptr, Bool useRefCountForDefault = false);
  template <typename T> static Result<Array<T>> NewPagedArray();
  static MAXON_METHOD Result<Array<Generic>> Slice(const Array<Generic>& base, Int start, Int end, Bool cycle, const Generic* defaultValue = nullptr, Bool useRefCountForDefault = false);
  template <typename T> static Result<Array<T>> Slice(const Array<T>& base, Int start, Int end);
  template <typename T> static Result<Array<T>> Slice(const Array<T>& base, Int start, Int end, Bool cycle, const T* defaultValue = nullptr, Bool useRefCountForDefault = false);
  static MAXON_METHOD Result<Array<Generic>> NewSingleValueArray(const ConstDataPtr& value, Int count, const ContainerDataType<>& containerType = GetPtrSizedZeroRef<ContainerDataType<>>());
  template <typename T> static Result<Array<T>> NewSingleValueArray(const T& value, Int count);
  static MAXON_METHOD Result<Array<Generic>> ExtractMember(const Array<Generic>& base, Int offset, const ContainerDataType<>& containerType);
  static MAXON_METHOD Result<Array<Generic>> Reinterpret(const Array<Generic>& base, const ContainerDataType<>& containerType);
  template <typename DST, typename SRC> static Result<Array<DST>> Reinterpret(const Array<SRC>& base);
}

atomictypes.h

class StrongReferenceCounter
{
  Bool HasMoreReferences(Int count) const;
}

backgroundentry.h added.

basearray.h

template <typename T, Bool MOVE_AND_COPY_MEMORY> class BaseArrayUtilities
{
  static void MoveFromKeepSrc(T* src, T* dst, Int moveCnt)
}

baselist.h

template <typename NODE> class BaseListLink : public BaseListLinkPOD
{
  static void MoveBefore(NODE* move, NODE* next);
}

blockarray.h

static const Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT = 10;
// Changed to
static constexpr Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT = 10;

blockarryallocator.h added.

containerbase.h

class GenericContainerInterface
{
  static GenericContainerInterface* Alloc(MAXON_SOURCE_LOCATION_DECLARATION);
 
  enum class INTERFACES
    {
    BASE_ARRAY = 256,               
    PAGED_ARRAY = 512,              
    INDEXABLE = 1024,               
    MULTI_DOMAIN_CONTAINER = 2048,  
    SLICED_ARRAY = 4096,            
    MEMBER_ARRAY = 8192             
    }
 
    ResultRef<typename std::remove_const<typename S::PrivateReferencedType>::type> MakeWritableDontCopyContent()
  [[deprecated]] MAXON_METHOD Result<GenericContainerInterface*> Clone(Bool copyContent = true) const;
  [[deprecated]] MAXON_METHOD Result<Int> InitIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const;
  MAXON_METHOD Result<Int> InitIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer, Bool constAccess) const;
}

datadescriptiondatabase.h

class DataDescriptionDatabaseInterface
{
  [[deprecated("only needed internally")]] static MAXON_METHOD Result<void> StoreDescription(const Id& category, const LanguageRef& language, const Id& dataType, DataDescription& description);
  [[deprecated("only needed internally")]] static MAXON_METHOD Result<void> StoreDescription(const Id& category, const LanguageRef& language, const IdAndVersion& dataType, DataDescription& description);
}

datadescriptiondefinition.h

enum class GETDATAFLAGS
{
  INTENT_ENABLING_HASVALUE = (1 << 3),    
  INTENT_GET_TRANSLATEDCHILDREN = (1 << 4),   
}

datadescriptiondefinitiondatabase.h

class DataDescriptionDefinitionDatabaseInterface
{
  [[deprecated("only needed internally")]] static MAXON_METHOD Result<DataDescription> UpdateDescriptionI(const Id& databaseId, const Id& category,
  static MAXON_METHOD Result<void> RegisterDatabaseWithUrl(const Id& databaseId, const Url& url, const CString& version);
  static MAXON_METHOD Result<void> RegisterValueChangedMessage(const Id& dataTypeId, const Id& attributeId, const DescriptionMessageFunction& func);
  static MAXON_METHOD Result<Bool> FindNodeValueChangedMessage(const Id& dataTypeId, const Id& attributeId, const ValueReceiver<DescriptionMessageFunction&>& receiver);
}

datadictionary.h

class DataDictionaryInterface
{
  MAXON_METHOD Int GetCount() const;
}

dataserialize.h

class DESCRIBEFLAGS
{
  static const ValueType CONDITION_NOWRITE    = (1 << 18);  
}

datatypelib.h

class InternedId
{
  Result<void> Init(const Char* str);
  // Changed to
    Result<void> Init(const Char* str, Bool copyString = true);
 
    CString ToCString() const;
}
 
class DataTypeLib
{
  static MAXON_METHOD const Block<const Int>& GetMemberOrder(const DataType& bundleOrContainerType);
  [[deprecated]] static MAXON_METHOD ConstDataPtr GetConstant(const DataType& type, Int value);
  static MAXON_METHOD const Generic* PrivateGetDefault(const DataTypeImpl* type);
}

errorbase.h

class ThreadCancelledErrorInterface : MAXON_INTERFACE_BASES(ErrorInterface)

file_utilities.h

class FileUtilities
{
  static MAXON_METHOD Result<OutputStreamRef> CreateCStringOutputStream(CString& str, Int maxLength);
}

flexible_array.h added.

ioenums.h

enum class URLCOMPARE
{
  FULL    = 5,    
}

iohandler.h

class IoHandlerInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  [[deprecated("use ConvertToUiNameWithRepository instead")]] MAXON_METHOD Result<String> ConvertToUiName(const UrlInterface& url, CONVERTTOUINAMEFLAGS flags) const;
  MAXON_METHOD Result<String> ConvertToUiNameWithRepository(const UrlInterface& url, CONVERTTOUINAMEFLAGS flags, const AssetRepositoryRef& lookupRepository) const;
}

job.h

class JobRef : public StrongRef<JobInterface>
{
  template <JOBCANCELLATION B = JOBCANCELLATION::AUTOMATIC, typename FN> static auto EnqueueAndWait(FN&& src, JobQueueInterface* queue = JOBQUEUE_CURRENT) -> Result<decltype(src())>
}

map.h

template <typename MAP> MAXON_IMPLEMENTATION_REGISTER_SIMPLE(MapImpl<MAP>);
// Changed to
template <typename MAP> MAXON_IMPLEMENTATION_SIMPLE_REGISTER(MapImpl<MAP>);

module.h

template <typename T, typename C> class Declaration
{
  static const Declaration& GetInstance()
  // Changed to
    static MAXON_ATTRIBUTE_FORCE_INLINE const Declaration& GetInstance()
}

objectbase.h

class ClassInterface
{
  MAXON_METHOD Int GetSize() const;
  MAXON_METHOD Result<ObjectInterface*> CreatePointer(Int size) const;
}
 
class ErrorInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_FUNCTION Bool IsCancellation() const;
}

optional.h

template <typename SUPER> class ResultOptFunctions : public SUPER
{
  template <typename U>
  T GetValueOr(U&& defaultValue) const
    // Changed too
    const T& GetValueOr(const T& defaultValue) const
 
    T GetValueOrNull() const
    // Changed to
    const T& GetValueOrNull() const
 
    template <typename U>
  T MoveValueOr(U&& defaultValue)
  // Changed to
    T MoveValueOr(T&& defaultValue)
}

parallelfor.h

enum class PARALLELFORFLAGS
{
    // Removed
  INITTHREADEDWITHSYNC_FINALIZESYNC = 5 
}
 
class ParallelFor
{
  class NoContextWithResult : public BreakContext
 
}

progress.h added.

range.h

template <typename T> class Range
{
  T _minValue; 
  // Changed to
  T minValue; 
 
  T _maxValue; 
  // Changed to
  T maxValue; 
}

sharedref.h removed.

sse_general.h

#define C4D_HAS_AVX_CAPABILITY
#define C4D_HAS_AVX_INTRINSICS
#define C4D_HAS_SSE4_INTRINSICS

string.h

class StringInterface : public StringTemplate<StringInterface, String, Utf32Char>
{
  MAXON_METHOD Result<String> Prettify(Int indent = 0, const String& indentStr = "\t"_s, Int breakUpThreshold = 100, Bool angularBrackets = false) const;
}

system.h

class System
{
  static MAXON_METHOD void _ConsoleOutput(const Char* s, const SourceLocation& loc, OUTPUT flags);
}

systemerror.h

class NSSystemErrorInterface : MAXON_INTERFACE_BASES(ErrorInterface)
{
  MAXON_METHOD void SetCFError(CFErrorRef osError);
}

thread.h

template <typename FN> inline auto ExecuteOnMainThread(FN&& fn, Bool wait) -> decltype(fn())
// Changed to
template <typename FN> inline auto ExecuteOnMainThread(FN&& fn, WAITMODE waitMode, TimeValue timeout) -> decltype(fn())

threadservices.h

// Removed
class ThreadCancelledErrorInterface : MAXON_INTERFACE_BASES(ErrorInterface)

threadservicespods.h

enum class WAITMODE
{
  DONT_WAIT   = 128   
}

treemap.h

template <typename K, typename V, typename MAP = HashMapSelector<>, Bool COW = false> class TreeMap : public TreeMapParent<TreeMap<K, V, MAP, COW>, COW>
// Changed to
template <typename K, typename V, typename MAP = HashMapSelector<>, Bool COW = false, Bool OPT = true> class TreeMap : public TreeMapParent<TreeMap<K, V, MAP, COW, OPT>, COW>
{
  Result<Child&> InsertChild(const K& key, Child&& child)
 
  template <typename PATH> Result<V&> InsertKey(PATH&& key, Bool& created = BoolLValue())
  // Changed to
    template <typename PATH> Result<V&> InsertKey(PATH&& key, Bool& created)
 
    template <typename PATH> Result<V&> InsertKey(PATH&& key)
}

url.h

class UrlInterface
{
  [[deprecated("use ConvertToUiNameWithRepository instead")]] MAXON_METHOD Result<String> ConvertToUiName(CONVERTTOUINAMEFLAGS flags) const;
  [[deprecated("use ConvertFromUiNameWithRepository instead")]] static MAXON_METHOD Result<Url> ConvertFromUiName(const String& str);
  MAXON_METHOD Result<String> ConvertToUiNameWithRepository(CONVERTTOUINAMEFLAGS flags, const AssetRepositoryRef& lookupRepository) const;
  static MAXON_METHOD Result<Url> ConvertFromUiNameWithRepository(const String& str, const AssetRepositoryRef& lookupRepository);
}

uuid.h

class UuidInterface
{
  static MAXON_METHOD Result<void> CreateUuid(UChar (&uuid)[16]);
}

valuereceiver.h

template <typename T> class FirstValueReceiver;
 
template <typename T, Bool ERROR_WHEN_AMBIGUOUS = true> class SingleValueReceiver
// Changed to
template <typename T, Bool ERROR_WHEN_AMBIGUOUS = true> class UniqueValueReceiver

vector4d.h

MAXON_ATTRIBUTE_FORCE_INLINE ColorA BlendColor(const ColorA& col1, const ColorA& col2, const Float blendValue)
// Changed to
template <typename COLORTYPE> MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendColor(const COLORTYPE& col1, const COLORTYPE& col2, const typename COLORTYPE::ValueType blendValue)

corenodes.framework

corenodes.h

class CoreNodeInterface : public CoreNodeBaseInterface
{
  MAXON_METHOD Bool IsInvocable() const;
 
    MAXON_METHOD Result<void> ConvertAndInvoke(const Block<const Tuple<TrivialDataPtr, CORENODE_PORT_FLAGS>>& args) const;
}

corenodes_instances.h

class MicroNode
{
  enum class FLAGS
  {
    NO_LIFETIME_PORT = 1 << 30,
    NO_FACTOR_NODES = 1 << 31,
  }
}

corenodes_lib.h

class CoreNodesLib
{
  static MAXON_METHOD ConstDataPtr GetConstant(const DataType& type, Int value);
  static MAXON_METHOD Result<Bool> ConvertArgument(TrivialDataPtr& arg, const DataType& expectedType, PointerArray<Data>& resultReferences);
}

exchange.framework

material/datadescription_material_redshift.h added.

material/materialmapping.h

struct MaterialMapperParameterInsertWrapper;
 
static Result<void> SimpleAttributeInsert(MaterialMapperParameterInsertWrapper& wrappedParams, const SOURCE_MATERIAL_ATTRIBUTE fromMaterial, const TARGET_MATERIAL_ATTRIBUTE toMaterial, const T fallbackValue);

geom.framework

geometryutils.h

class GeometryUtilsInterface
{
  static MAXON_METHOD Bool ArePointsCoLinearWithinTolerance(const Block<const Vector>& points, maxon::Float tol = maxon::GeomConstants::EPSILON5);
}

graph.framework

graph.h

struct Wires
{
  Wires& operator |=(Wires other);
}
 
using IoNodePath = Tuple<NodePath, InternedId>;
using IoNodeConnection = Tuple<IoNodePath, IoNodePath>;
using IoGraphNode = Tuple<GraphNode, InternedId>;
 
class GraphModelInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  enum class GET_CONNECTIONS_MODE
  {
        INTERNAL_CONNECTIONS = 128, 
  }
 
    enum class MODIFIED
    {
        SPECIAL_NAME = 4096,
    }
 
    protected:
 
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> IsSelected(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<GraphNode> CreateOutputPort(const GraphNode& node, const CString& id, const String& name = String("Output"));
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<GraphNode> CreateInputPort(const GraphNode& node, const CString& id, const String& name = String("Input"));
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetDirectPredecessors(const GraphNode& node, const ValueReceiver<const GraphNode&>& callback, const NODE_KIND& filter);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetAllPredecessors(const GraphNode& node, const ValueReceiver<const GraphNode&>& callback, const NODE_KIND& filter);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetDirectSuccessors(const GraphNode& node, const ValueReceiver<const GraphNode&>& callback, const NODE_KIND& filter);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetAllSuccessors(const GraphNode& node, const ValueReceiver<const GraphNode&>& callback, const NODE_KIND& filter);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> IsConnectedTo(const GraphNode& node, const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> MuteConnectionWith(const GraphNode& node, const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> MuteAllConnections(const GraphNode& node, const PORT_DIR& direction);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> UnmuteConnectionWith(const GraphNode& node, const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> UnmuteAllConnections(const GraphNode& node, const PORT_DIR& direction);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> RemoveAllConnections(const GraphNode& node);
 
    public:
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> SelectWire(const NodePath& src, const NodePath& dst);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> DeselectWire(const GraphNode& src, const GraphNode& dst);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetSelectedWires(const ValueReceiver<const GraphNode&, const GraphNode&, const Wires&>& callback);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> DeselectTrueNode(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> DeselectPort(const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> SelectNode(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> DeselectNode(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> ListAllNodes(const ValueReceiver<const GraphNode&>& callback, const DataDictionary& matchingData);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> IsTrueNodeSelected(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> IsPortSelected(const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<Bool> IsWireSelected(const NodePath& src, const NodePath& dst);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> SelectWire(const GraphNode& src, const GraphNode& dst);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> SelectTrueNode(const GraphNode& node);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetSelectedTrueNodes(const ValueReceiver<const GraphNode&>& callback);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> SelectPort(const GraphNode& port);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetSelectedPorts(const ValueReceiver<const GraphNode&>& callback);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> GetSelectedNodes(const ValueReceiver<const GraphNode&>& callback, const NODE_KIND &kind);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> DeselectAll(const NODE_KIND &kind);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> RemoveAllConnections(const GraphNode &src, const GraphNode &dst);
        [[deprecated("Use GraphModelHelper static functions")]] MAXON_METHOD Result<void> FindAllGraphNodeByName(const String& nodeName, const ValueReceiver<const GraphNode&>& callback, const NODE_KIND &kind = NODE_KIND::ALL_MASK, const PORT_DIR direction = PORT_DIR::INPUT);
}

graph_helper.h added.

nodepath.h

class NodePathInterface
{
  MAXON_METHOD HashValue GetHashValue() const;
  MAXON_METHOD HashInt GetFastHashCode() const;
  MAXON_METHOD Result<InternedId> GetPortPartAsId() const;
  static MAXON_METHOD Result<InternedId> GetPortPartAsId(const PathBlock& path);
  static constexpr Char SEPARATOR = '/';  
}

image.framework

gfx_image_colorprofile.h

enum class COLORPROFILEINFO
{
  NAME          = 4   
}
 
enum class COLORCONVERSIONFLAGS
{
  INVERSE_DIRECTION       = 1 << 1
}
 
class ColorProfileConvertInterface
{
  static MAXON_METHOD Result<ColorProfileConvert> InitGPU(const ColorProfile& srcProfile, const ColorProfile& dstProfile, COLORCONVERSIONFLAGS_GPU flags, COLORCONVERSION_OPTIMIZATION_GPU_FLAGS optimization);
  MAXON_METHOD ForwardRef<ColorProfileGpuHandlerRef> GetGpuHandler() const;
}

gfx_image_gpu_legacy_processor.h added.

gfx_image_pixelformat.h

class PixelFormatInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_METHOD Result<CONVERTPIXELFUNC> GetConvertPixelFunc(const PixelFormat& srcFormatPtr, const ChannelOffsets& srcChannelOffset,
    const ChannelOffsets& dstChannelOffset, const ColorProfile& srcColorProfile, ColorProfile* dstColorProfile,
    Bool forceColorProfileConversion, COLORCONVERSIONFLAGS colorConversionFlags, Bool& disableCaching) const;
}

imageurlcache.h

class ImageUrlCacheInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  MAXON_METHOD Result<Opt<ImageBaseRef>> GetImage(UpdateCacheDelegate&& updateDelegate) const;
}

math.framework

blend_animation.h

class BlendAnimationInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  MAXON_METHOD void SetStartProgress(Float startProgress);
  MAXON_METHOD void SetDirection(Bool reverse);
}

matrix_prs.h added.

NURBSMath.h

class NURBSCurveInterface
{
  MAXON_METHOD Result<Pair<Block<Vector4d>, Int>> AddControlPoint(const Float t);
}

mesh_misc.framework

mesh_attribute_base.h

class MeshAttributeClassInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_METHOD const DataType& GetUnderlyingDataType() const;
}

misc.framework

profiler.h

#define PROFILER_SCOPE(...)

ramdisk.h

class RamDiskInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
  static MAXON_METHOD Result<RamDiskRef> Create(const String& ramdiskId);
}

network.framework

network_oauth.h

class NetworkOAuthSessionInterface
{
  MAXON_METHOD CString GetIdToken() const;
}

neutron.framework

neutron_ids.h

// Removed
static constexpr Int32 MSG_REINITIALIZE_SCENEREPOSITORY_ON_LOAD = 180420114;
 
static constexpr Int32 MSG_CREATE_IF_REQUIRED = 180420122;
 
static constexpr Int32 SCENE_PORT_LINK = 180420710;

nodes.framework

componentaccessattributes.h added.

node_or_template.h

class NodeOrTemplate
{
  Bool IsTemplate() const;
}

nodes_corenodes_base.h

MAXON_ATTRIBUTE(Bool, NoCleanupOnFinalize, "skipfinalizemodification");

nodesgraph.h

class NodeSystemManagerInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
 protected:
    MAXON_METHOD Result<NodesGraphModelRef> CreateGraphModel() const;
}
 
class NodesGraphModelInterface : MAXON_INTERFACE_BASES(GraphModelInterface)
{
  MAXON_METHOD Result<const MutableRoot&> GetMutableRoot();
  MAXON_METHOD Result<void> ReplaceChild(const GraphNode& childNode, const NodeSystem& base, const HashMap<NodePath, NodePath>& portMap);
  MAXON_METHOD Result<Bool> GetAllAssetIds(const GraphNode& node, const ValueReceiver<const IdAndVersion&>& receiver);
}

nodeslib.h

// Deprecated
using InstantiateDelegate = Delegate<Result<MutableRoot>(const InstantiationTrace& parent, const TemplateArguments& args)>;
 
using InstantiateDelegate = Delegate<Result<MutableRoot>(const InstantiationTrace& parent, const TemplateArguments& args, const NodeTemplate& self)>;
 
[[deprecated]] static MAXON_METHOD Result<void> PrivateInitFromPath(GNode& node, const NodeSystem& system, const NodePath& path, NODE_KIND check);
[[deprecated]] static MAXON_METHOD Result<void> PrivateInitFromPath(MutableGNode& node, NodeSystemInterface* system, const NodePath& path, NODE_KIND check);

nodesystem.h

class NodeSystemInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_METHOD Int GetTopologicalOrder(const NodePath& port) const;
  // Changed to
    MAXON_METHOD Int GetTopologicalLayer(const NodePath& port) const;
}

nodesystem_class.h

class NodeSystemClassInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
  MAXON_METHOD Bool NeedsAttribute(const DerivedAttribute& attr) const;
  // Changed to
    MAXON_METHOD Result<Bool> GetDerivedAttributes(const ValueReceiver<const InternedId&>& receiver) const;
}

portattributes.h

// Removed
MAXON_ATTRIBUTE(Id, ComponentAccessBundle, "componentaccessbundleport");
 
// Removed
MAXON_ATTRIBUTE(Bool, ComponentAccessChild, "componentaccesschild");
 
MAXON_ATTRIBUTE(Bool, InternalDescriptionDerivation, "internaldescriptionderivation");
 
MAXON_ATTRIBUTE(Bool, UseAttributeResources, "useattributeresources");
 
MAXON_ATTRIBUTE(Bool, IgnoreBase, "ignorebase");
 
MAXON_ATTRIBUTE(Bool, AllowMultipleConnections, "allowmultipleconnections");
 
class DerivedAttributeInterface : MAXON_INTERFACE_BASES(GraphAttributeInterface)
{
    [[deprecated]] MAXON_METHOD Bool IsNeededFor(const NodeSystemClass& cls) const;
}

nodespace.framework

node_spaces.h

namespace maxon
{
namespace nodes
{
namespace NODESPACE
{
  MAXON_ATTRIBUTE(Bool, DISABLE_PREVIEWS, "net.maxon.nodes.nodespace.disablepreviews");
}
}
}

python.framework

code_exchange.h added.

cpython.h

class CPythonLibraryInterface : MAXON_INTERFACE_BASES(LibraryInterface)
{
  MAXON_METHOD Bool CPyList_Clear(const CPyRef& list);
 
    MAXON_METHOD MPyHashMapRef MPyHashMap_New(const HashMap<Data, Data>& map);
  MAXON_METHOD MPyHashMapRef MPyHashMap_New(HashMap<Data, Data>&& map);
 
  template<typename KEY, typename VALUE>
  MAXON_FUNCTION MPyHashMapRef MPyHashMap_New(HashMap<KEY, VALUE>& map);
 
    MAXON_METHOD Class<MPyHashMapRef> GetMPyHashMapRefClass() const;
 
    template <typename T>
    typename std::enable_if<STD_IS_REPLACEMENT(same, T, py::MPyHashMapRef), T>::type CPyCast(const CPyRef& o);
}

cpython_ref.h

class MPyHashMapInterface : MAXON_INTERFACE_BASES(CPyInterface)
{
  MAXON_METHOD HashMap<Data, Data>* GetHashMap();
}

cpython3_raw.h

struct NativePyHashMap : public NativePyObject;

vm.h

namespace VmDebuggerConnections
{
    MAXON_DECLARATION(VmDebuggerConnectionRef, Ptvs, "net.maxon.python.vmdebuggerconnection.ptvs");
    // Changed to
  MAXON_DECLARATION(VmDebuggerConnectionRef, DebugPy, "net.maxon.python.vmdebuggerconnection.debugpy");
}