API Change List in S26

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);
}
#define MAXON_METHOD
Definition: interfacebase.h:942
#define MAXON_INTERFACE_BASES(...)
Definition: objectbase.h:1054

cinema.framework

c4d_customgui/customgui_itemtree.h

#define ITEMTREE_CALLBACK_GETHEADERCOLUMNWIDTH 29

c4d_libs/lib_description.h

enum DESC
{
}
DESC
Definition: lib_description.h:90
@ DESC_COLOR_CONVERTED
Bool Set when the Color Converter Tool converted this color property
Definition: lib_description.h:148
@ DESC_FORBID_COLOR_CONVERSION
Bool Prevents the automated converter from transforming values for this Color field.
Definition: lib_description.h:147

c4d_baselist.h

#define MSG_DOCUMENT_CONVERT_COLORS 1059361
Message struct for the MSG_DOCUMENT_CONVERT_COLORS message.
Definition: c4d_baselist.h:1170

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);
Vector TransformColor(const Vector &input, COLORSPACETRANSFORMATION colortransformation, Bool force=false)
maxon::Bool Bool
Definition: ge_sys_math.h:55
COLORSPACETRANSFORMATION
Definition: ge_prepass.h:490

ge_prepass.h

enum class BOOLESETTINGS
{
}
#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
BOOLESETTINGS
Definition: ge_prepass.h:1843
@ SMOOTHRADIUS
Float The radius for the boolean.

operatingsystem.h

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

core.framework

application.h

{
LIBRARY = (1 << 1),
UI = (1 << 2),
}
UI
UI is enabled (if this is LIBRARY or COMMANDLINE)
Definition: application.h:3
APPLICATIONFEATURE
Definition: application.h:132

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"};
}
@ CINEWARE
Cineware - The renderer used in AfterEffects, Vectorworks, Archicad and Allplan. Runs without UI and ...
static const LiteralId CINEWARE_STATIC
Definition: applicationid.h:26
static const LiteralId CINEWARE_APP
Definition: applicationid.h:23

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")));
}
}
}
}
#define RESOURCE_DEFINE(ID, VAL)
Definition: fid.h:98
@ DESCRIPTION
Description changed.
@ DATA
Data in the arrays changed, must be manually set.
MAXON_ATTRIBUTE(Id, DATATYPE, "net.maxon.description.data.base.datatype", RESOURCE_DEFINE(ENUM_REGISTRY_MAXON_DB_DATADESCRIPTIONS, Id("registry#maxon.db.datadescriptions")))
The maxon namespace contains all declarations of the MAXON API.
Definition: c4d_basedocument.h:16

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");
MAXON_DATATYPE(GeData, "net.maxon.data.gedata")
#define MAXON_REGISTRY(T, Name, id)
Definition: registrybase.h:384
Delegate< Result< CString >(const CString &variable, const CString &fullString, const AssetRepositoryRef &repository, const GetDataCallbackType &getDataCallback, Opt< const DataDictionary & > dataEntry, Opt< const DataDictionary & > guiEntry)> EnumVariableResolveDelegate
Definition: datadescriptiondatabase.h:171
Delegate< Result< Data >(const InternedId &id, const DataDictionary &dataEntry, GETDATAFLAGS flags)> GetDataCallbackType
Definition: datadescriptiondefinition.h:26

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();
}
maxon::Int Int
Definition: ge_sys_math.h:64

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,
}
}
SKIP_REROUTER
Hop over rerouter nodes.
Definition: graph.h:8

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;
}
Definition: c4d_string.h:39
REGPARSEMODE
Definition: lib_regexpr.h:31

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;
maxon::Int32 Int32
Definition: ge_sys_math.h:60
static constexpr Int32 IDM_CAPSULE_ASSET_TO_GROUP
Definition: neutron_ids.h:90
static constexpr Int32 CAPSULE_BASE_ID
Definition: neutron_ids.h:86
static constexpr Int32 MSG_ENABLE_ASSET_TO_GROUP
Definition: neutron_ids.h:57
static constexpr Int32 MSG_SET_ASSET_WITH_VERSION
Definition: neutron_ids.h:80

nodes.framework

nodes_import.h

class SerializationNodeData
{
MAXON_METHOD ASSET_UPDATE_POLICY& GetUpdatePolicy();
MAXON_METHOD CHILD_MODE GetChildMode() const;
}
ASSET_UPDATE_POLICY
Definition: idandversion.h:21

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;
}
const T & GetZeroRef()
Definition: apibase.h:574

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;
}
VALUEMODE
This enum defines what kind of value a port has.
Definition: nodesystem.h:314

portattributes.h

enum class PORT_FLAGS
{
}
PORT_FLAGS
Type of the PortFlags attribute.
Definition: portattributes.h:343
USED_FOR_TEMPLATE_MASK
Definition: portattributes.h:15
USED_FOR_TEMPLATE_ARGUMENT
The port is used for an argument for a TemplateParameter of a node template.
Definition: portattributes.h:2
USED_FOR_INPUTPORTTYPE_TEMPLATE_ARGUMENT
The port is used for an argument for a TypeTemplateParameter of an input port of a node template.
Definition: portattributes.h:3
USED_FOR_INPUTBUNDLE_TEMPLATE_ARGUMENT
The port is used for an argument for an BundleTemplateParameter of an input port of a node template.
Definition: portattributes.h:10

volume.framework

volumetools.h

class VolumeToolsInterface
{
static MAXON_METHOD Result<Volume> SmoothBoolVolumes(const Volume& volumeOne, const Volume& volumeTwo, BOOLTYPE type, Float radius);
}
maxon::Float Float
Definition: ge_sys_math.h:66
BOOLTYPE
Definition: ge_prepass.h:1855

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");
}
}
}
MAXON_ATTRIBUTE(String, PRESETDELETEERROR, "net.maxon.asset.globalstrings.presetdeleteerror")

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,
}
}
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();
}
CHECK_CANCELLATION
Set this flag when you want to check if the job is cancelled. if cancelled a ThreadCancelledError is ...
Definition: assets.h:7
IGNORE_READ_ONLY
This flag is only used as argument for AssetRepositoryInterface::StoreMetaData to ignore the READ_ONL...
Definition: assets.h:7
PRIVATE_QUERY_REPOSITORY_VISIBILITY
Private: if this flag is given then the delegate is called at the beginning of each findasset if the ...
Definition: assets.h:8
maxon::UInt64 UInt64
Definition: ge_sys_math.h:63
@ MASK
New pixels overwrite the old ones at the bits where the mask specified by the parameter equals 1.
#define MAXON_FUNCTION
Definition: interfacebase.h:963
MAXON_ATTRIBUTE(Array< Id >, Keywords, "net.maxon.asset.keywords")
Array with ids of keywords assets, attached to the asset.
const Class< R > & Get(const Id &cls)
Definition: objectbase.h:2060
KIND
An enum to represent the different node space kinds (such as materials or scene nodes).
Definition: node_spaces.h:48
ASSET_FIND_MODE
The flags of ASSET_FIND_MODE control the behavior of AssetRepositoryInterface::FindAssets.
Definition: assets.h:579

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");
const T & src
Definition: apibase.h:2613
#define MAXON_DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: classhelpers.h:317
#define MAXON_OPERATOR_MOVE_ASSIGNMENT(TypeName)
Definition: classhelpers.h:346

category_asset.h

MAXON_ATTRIBUTE(void, AssetCategoryWatchFolders, "category@5846c0689c0248cfa54bffed866571ce");
#define MAXON_ATTRIBUTE(TYPE, NAME, RID,...)
Definition: fid.h:151

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.
@ FONTCHOOSER_ENABLE_FILTER
Bool true Whether font filter field should be displayed.
Definition: customgui_fontchooser.h:32

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

{
String* _suffix = nullptr;
}
c4d_basebitmap.h
@code
{
{
}
}
Definition: c4d_basebitmap.h:150
COLORPROFILEINFO
Definition: c4d_basebitmap.h:164
@ COLORPROFILEINFO_NAME
Name of the color profile.
Definition: c4d_basebitmap.h:169
Base class for custom data types.
Definition: c4d_customdatatype.h:51
Message struct for some message types.
Definition: lib_description.h:845
Definition: lib_description.h:984
String * _suffix
The suffix which needs to be verified. Can be nullptr.
Definition: lib_description.h:985
Bool _addToRecentList
This can be set to false to prevent the exported filename to be added to the recent document list.
Definition: lib_description.h:986

c4d_basedocument.h

Bool LoadFile(const Filename& name);
// Changed to
Bool LoadFile(const Filename& name, Bool allowAsync);
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());
BaseDocument * LoadDocument(const Filename &name, SCENEFILTER loadflags, BaseThread *thread, maxon::String *errorString=nullptr, const ProgressDelegate &progressDelegate=ProgressDelegate())
maxon::Delegate< Bool(Float percent)> ProgressDelegate
Definition: c4d_basedocument.h:1665
Bool LoadFile(const Filename &name, Bool allowAsync)
Bool MergeDocument(BaseDocument *doc, const Filename &name, SCENEFILTER loadflags, BaseThread *thread, maxon::String *errorString=nullptr, const ProgressDelegate &progressDelegate=ProgressDelegate())
Definition: c4d_basedocument.h:498
Definition: c4d_thread.h:28
Manages file and path names.
Definition: c4d_file.h:94
Definition: delegate.h:235
Definition: string.h:1226
SCENEFILTER
Definition: ge_prepass.h:291

c4d_basedraw.h

class BaseView : public BaseList2D
{
}
class BaseDraw : public BaseView
{
}
Definition: c4d_basedraw.h:754
static Int32 GetColorSpaceFromDocumentIndex()
Definition: c4d_basedraw.h:1873
Definition: c4d_baselist.h:2188
Definition: c4d_basedraw.h:266
Int32 GetColorSpace() const
Definition: c4d_basedraw.h:727

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_WARNING
Definition: c4d_colors.h:438
@ COLOR_NETSTATE_BUSY
Definition: c4d_colors.h:442
@ COLOR_MENU_TEXT_SEPARATOR
Definition: c4d_colors.h:435
@ COLOR_NETSTATE_BUSY2
Definition: c4d_colors.h:443
@ COLOR_NETSTATE_CRITICAL
Definition: c4d_colors.h:444
@ COLOR_ERROR
Definition: c4d_colors.h:439
@ COLOR_TEXT_SEPARATOR
Definition: c4d_colors.h:436
@ COLOR_NETSTATE_IDLE
Definition: c4d_colors.h:441
@ COLOR_NETSTATE_DISABLED
Definition: c4d_colors.h:440

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);
}
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)
Definition: block.h:423
Definition: apibaseid.h:251
Definition: url.h:876
FILESELECT
Definition: ge_prepass.h:3873

c4d_filterdata.h

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

c4d_general.h

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

c4d_gui.h

class GeDialog
{
// Changed to
}
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);
Bool RegisterObjectPlugin(Int32 id, const maxon::String &str, Int32 info, DataAllocator *g, const maxon::String &description, BaseBitmap *icon, Int32 disklevel)
Definition: c4d_basebitmap.h:415
Definition: c4d_gui.h:1113
Int32 IsDockedOrTabbed()
Bool MenuAddSeparator(const maxon::String &title=maxon::String())
OBJECTCATEGORY
Definition: ge_prepass.h:4274
NodeData * DataAllocator(void)
Definition: c4d_graphview_def.h:58

c4d_shader.h

{
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);
}
Definition: c4d_shader.h:216
InitRenderStruct()
Default constructor.
Definition: c4d_shader.h:221
void Init(BaseDocument *t_doc, Int32 overrideViewTransform=-1)

ge_prepass.h

enum class SCENEFILTER
{
SUPPRESSOPTIONSDIALOG = (1 << 31),
}
{
UNDEFINED = 0,
LINEAR = 1,
SRGB = 2,
#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
{
#define DIALOG_ISDOCKED (1 << 0)
#define DIALOG_ISTABBED (1 << 1)
}
#define MAXON_ENUM_LIST(E,...)
Definition: enumflags.h:137
VIEW_WINDOW_COLOR_SPACE
Definition: ge_prepass.h:515
@ DIALOG_ISDOCKETORTABBED
Returns DIALOG_ISDOCKED | DIALOG_ISTABBED, 0 if individual window.
Definition: ge_prepass.h:5182
@ UNDEFINED
Undefined.
@ LINEAR
Linear handle constraint.
@ SUPPRESSOPTIONSDIALOG
Suppress the options dialog (if DIALOGSALLOWED was specified), so that errors would show up.

gui.h

enum
{
}
enum
{
}
CMD_VALUE_MASK = 0x0FFFFFFF,
CMD_HIDDEN = 0x20000000, ///< Hidden.
@ CMD_HIDDEN
Hidden.
Definition: gui.h:394
@ CMD_VALUE_MASK
Valid mask for value.
Definition: gui.h:393
@ FONT_SMALL_BOLD
1 point smaller bold font.
Definition: gui.h:30
@ FONT_BIGGER
1 point bigger font.
Definition: gui.h:31
@ DR_MULTILINE_LINECOUNT
Default multiline line count.
Definition: gui.h:338

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

{
}
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);
}
AUTODETECT_RENDERENGINE
detect render engine from document
Definition: asset_creation.h:5
Definition: c4d_basematerial.h:28
Definition: c4d_baseobject.h:225
GENERATESCENEPREVIEWIMAGEFLAGS
Definition: asset_creation.h:51

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");
#define MAXON_OBSERVABLE(RETTYPE, NAME,...)
Defined Observables for the source processor.
Definition: observable.h:736

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) { }
}
ENUM_DONT_INITIALIZE
Definition: apibase.h:605

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);
}
maxon::Char Char
Definition: ge_sys_math.h:56
static auto Create(ARGS &&... args)
Definition: apibase.h:2730

utilities/apibasemath.h

// Changed to
// Changed to
maxon::UInt32 UInt32
Definition: ge_sys_math.h:61
#define MAXON_ATTRIBUTE_FORCE_INLINE
Definition: apibase.h:111
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo(UInt32 x)
Definition: apibasemath.h:571

utilities/closurejob.h

namespace details
{
template <typename FN> static ResultPtr<JobInterface> CreateCancelledObserver(FN&& src);
}
Definition: enumflags.h:147

utilities/debugdiagnostics.h

enum class OUTPUT
{
NONE = 0,
PRETTYPRINT = (1 << 28),
}
#define OutputWithFlags(flags, formatString, ...)
PRETTYPRINT
If set, it is tried to break and indent long output according to parentheses and commas.
Definition: debugdiagnostics.h:5
OUTPUT
Output flags for OutputWithFlags and DebugOutput.
Definition: debugdiagnostics.h:53

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>;
INDEXABLE
The container implements GenericIndexableContainerInterface.
Definition: containerbase.h:11
auto SetDifference(const ITERABLE1 &firstSet, const ITERABLE2 &secondSet) -> Result< ITERABLE1 >
Definition: algorithms.h:2794
static auto CountIfMatch(INDEXABLE &&indexable, MATCHER matcher) -> Match< Int >
Definition: algorithms.h:2044
auto UnorderedSetDifference(const ITERABLE &firstSet, const FINDABLE &secondSet) -> Result< ITERABLE >
Definition: algorithms.h:2868
auto ExcludeSetFromSet(ERASABLE &firstSet, const ITERABLE &secondSet) -> Result< void >
Definition: algorithms.h:2914

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;
void CombineUnordered(const HashValue& other);
}
enum class VALUEKIND : UInt64
{
SINGLETON_CONTAINER = 3LL << 54,
// Changed to
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)
BUNDLE
The data type is a bundle type.
Definition: apibase.h:83
VIRTUAL_TUPLE_CONTAINER
The data type is a ContainerDataType.
Definition: apibase.h:73
Bool operator<(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:261
void Destruct(const T *object)
Definition: apibase.h:2670
static constexpr Int ZERO_MEMORY_SIZE
The number of zero bytes available at g_zeroMemory.
Definition: apibase.h:568
#define MAXON_OPERATOR_INEQUALITY(TypeName)
Definition: classhelpers.h:406
VALUEKIND
Definition: apibase.h:2296

applicationid.h

namespace APPLICATIONID
{
static const LiteralId FORGER{"net.maxon.application.forger"};
}
static const LiteralId FORGER
Definition: applicationid.h:29

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);
}
const T & GetPtrSizedZeroRef()
Definition: apibase.h:590
MAXON_ATTRIBUTE_FORCE_INLINE auto end(COLLECTION &&c) -> decltype(c.End())
Definition: foreach.h:361
COLLECTION_RESIZE_FLAGS
Flags for Resize(). Depending on the type of collection the flags might be ignored (except for ON_GRO...
Definition: collection.h:126
#define MAXON_GENERIC_BASE(...)
Definition: interfacebase.h:1797
DEFAULT
Default.
Definition: lib_ca.h:4

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);
}
@ NODE
Private - node parameter.

blockarray.h

// Changed to
static constexpr Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT = 10;
static constexpr Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT
Default value for the BLOCK_SIZE_EXPONENT template parameter of BlockArray. The value is 10 which mea...
Definition: blockarray.h:24

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,
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;
}
PAGED_ARRAY
The container is a paged array (see ArrayFactory::NewPagedArray). This is set in addition to ARRAY.
Definition: containerbase.h:10
MEMBER_ARRAY
The container is an array pointing to member data of a source array (see ArrayFactory::ExtractMember)...
Definition: containerbase.h:14
MULTI_DOMAIN_CONTAINER
The container implements MultiDomainContainerInterface.
Definition: containerbase.h:12
BASE_ARRAY
The container uses an underlying BaseArray (see ArrayFactory::NewBaseArray). This is set in addition ...
Definition: containerbase.h:9
SLICED_ARRAY
The container is a subset of an array (see ArrayFactory::Slice). This is set in addition to ARRAY.
Definition: containerbase.h:13
#define MAXON_SOURCE_LOCATION_DECLARATION
Definition: memoryallocationbase.h:77
BufferedBaseArray< Int64, 10 > PersistentIdBuffer
Definition: containerbase.h:26

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);
}
Tuple< Id, Id > IdAndVersion
IdAndVersion is used for assets to store the asset id (first) and version (second) in a single tuple.
Definition: idandversion.h:14

datadescriptiondefinition.h

enum class GETDATAFLAGS
{
}
INTENT_ENABLING_HASVALUE
Same as INTENT_ENABLING, but limited to value, will not return a type when no value is present.
Definition: datadescriptiondefinition.h:5
INTENT_GET_TRANSLATEDCHILDREN
Fetch TRANSLATEDCHILDREN attribute from a port's EffectivePortDescription.
Definition: datadescriptiondefinition.h:6
GETDATAFLAGS
Flags used in combination with GetDataCallbackType.
Definition: datadescriptiondefinition.h:16

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);
}
Tuple< Id, DescriptionMessageCheck, DescriptionMessageBuildSubMenu, DescriptionMessageCall > DescriptionMessageFunction
Definition: datadescriptiondefinitiondatabase.h:75

datadictionary.h

class DataDictionaryInterface
{
}
Int GetCount(const ITERABLE &iterable)
Definition: collection.h:37

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,
}
FULL
DEFAULT + compare with all data dictionaries.
Definition: ioenums.h:4
URLCOMPARE
Flag to pass to Compare.
Definition: ioenums.h:27

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;
}
CONVERTTOUINAMEFLAGS
See ConvertToUiName() and ConvertToUiNameWithRepository()
Definition: url.h:67

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())>
}
BaseRef< T, StrongRefHandler > StrongRef
Definition: baseref.h:936
static const JobQueueInterface::Current JOBQUEUE_CURRENT
Equivalent to calling GetDestinationQueue(), you just save a function call.
Definition: jobqueue.h:361

map.h

template <typename MAP> MAXON_IMPLEMENTATION_REGISTER_SIMPLE(MapImpl<MAP>);
// Changed to
template <typename MAP> MAXON_IMPLEMENTATION_SIMPLE_REGISTER(MapImpl<MAP>);
#define MAXON_IMPLEMENTATION_SIMPLE_REGISTER(C)
Definition: interfacebase.h:1792

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
}
PARALLELFORFLAGS
Definition: parallelfor.h:28

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);
}
void _ConsoleOutput(OUTPUT flags, const Char *str, Int line, const Char *file)

systemerror.h

class NSSystemErrorInterface : MAXON_INTERFACE_BASES(ErrorInterface)
{
MAXON_METHOD void SetCFError(CFErrorRef osError);
}
CFError * CFErrorRef
Definition: systemerror.h:17

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())
auto ExecuteOnMainThread(FN &&fn, WAITMODE waitMode=WAITMODE::DEFAULT, TimeValue wait=TIMEVALUE_INFINITE) -> decltype(fn())
Definition: thread.h:649
WAITMODE
Definition: threadservicespods.h:195

threadservices.h

// Removed
class ThreadCancelledErrorInterface : MAXON_INTERFACE_BASES(ErrorInterface)

threadservicespods.h

enum class WAITMODE
{
DONT_WAIT = 128
}
DONT_WAIT
For ExecuteOnMainThread only: Do not wait.
Definition: threadservicespods.h:4

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)
}
DefaultLValue< Bool > BoolLValue
Definition: apibase.h:2786

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]);
}
maxon::UChar UChar
Definition: ge_sys_math.h:57

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
UniqueValueReceiver< T, ERROR_WHEN_AMBIGUOUS > SingleValueReceiver
SingleValueReceiver will get deprecated.
Definition: valuereceiver.h:181

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)
@ BlendColor
Color.
Definition: lib_layershader.h:87
Col4< Float, 1 > ColorA
Definition: vector4d.h:60

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,
}
}
NO_LIFETIME_PORT
Definition: corenodes_instances.h:32
NO_FACTOR_NODES
Definition: corenodes_instances.h:33

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);
static Result< void > SimpleAttributeInsert(MaterialMapperParameterInsertWrapper &wrappedParams, const SOURCE_MATERIAL_ATTRIBUTE fromMaterial, const TARGET_MATERIAL_ATTRIBUTE toMaterial, const T fallbackValue)
Definition: materialmapping.h:27

geom.framework

geometryutils.h

class GeometryUtilsInterface
{
static MAXON_METHOD Bool ArePointsCoLinearWithinTolerance(const Block<const Vector>& points, maxon::Float tol = maxon::GeomConstants::EPSILON5);
}
static constexpr Float EPSILON5
Definition: geomconstants.h:20
Float64 Float
Definition: apibase.h:199

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
{
}
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);
}
MODIFIED
Modified variant with epoch of 0h Nov 17, 1858.
Definition: datetime.h:2
ALL_MASK
A mask containing all possible MODIFIED bits.
Definition: graph.h:43
SPECIAL_NAME
This is set to indicate a change which affects names of nodes or ports.
Definition: graph.h:40
INTERNAL_CONNECTIONS
Only report connections which don't leave the node to which the port belongs (so they are internal to...
Definition: graph.h:7
PORT_DIR
Definition: graph_basics.h:34
Tuple< IoNodePath, IoNodePath > IoNodeConnection
Definition: graph.h:424
Tuple< NodePath, InternedId > IoNodePath
Definition: graph.h:418
Tuple< GraphNode, InternedId > IoGraphNode
Definition: graph.h:429
NODE_KIND
Definition: nodepath.h:25
INPUT
Definition: parametertype.h:1

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 = '/';
}
UInt HashInt
Definition: apibase.h:332
Block< const InternedId > PathBlock
A PathBlock is a Block of identifiers to be used as path into a graph, see NodePath.
Definition: nodepath.h:58

image.framework

gfx_image_colorprofile.h

enum class COLORPROFILEINFO
{
NAME = 4
}
{
}
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;
}
INVERSE_DIRECTION
Definition: gfx_image_colorprofile.h:9
@ NAME
String Get/Set. The layer name.
COLORCONVERSIONFLAGS
Definition: gfx_image_colorprofile.h:69
COLORPROFILEINFO
Return value of ColorProfile.GetInfo() function.
Definition: gfx_image_colorprofile.h:25

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;
}
Block< const BITS > ChannelOffsets
Definition: gfx_image_pixelformat.h:27

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;
static constexpr Int32 MSG_CREATE_IF_REQUIRED
Definition: neutron_ids.h:55
static constexpr Int32 SCENE_PORT_LINK
Definition: neutron_ids.h:88

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");
}
}
}
static constexpr LiteralId NODESPACE
Definition: neutron_ids.h:94
MAXON_ATTRIBUTE(Id, SPACEID, "net.maxon.nodes.nodespace.spaceid")
Defines the identifier for all space-related data, such as node graph storage within C4D files.

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);
}
#define STD_IS_REPLACEMENT(name,...)
Definition: compilerdetection.h:306
std::enable_if< STD_IS_REPLACEMENT(same, T, py::CPyTypeRef), T >::type CPyCast(const CPyRef &o)
Definition: cpython.h:2891

cpython_ref.h

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

cpython3_raw.h

struct NativePyHashMap : public NativePyObject;
NativePyObjectHead_Release NativePyObject
Definition: cpython3_raw.h:67

vm.h

namespace VmDebuggerConnections
{
MAXON_DECLARATION(VmDebuggerConnectionRef, Ptvs, "net.maxon.python.vmdebuggerconnection.ptvs");
// Changed to
MAXON_DECLARATION(VmDebuggerConnectionRef, DebugPy, "net.maxon.python.vmdebuggerconnection.debugpy");
}
#define MAXON_DECLARATION(T, Name, id,...)
Definition: module.h:812