API Change List in R21

Table of Contents

• API Changes in R21.022
  • New MAXON API Frameworks
  • DataType
  • cinema.framework
  • core.framework
  • command.framework
  • crypt.framework
  • geom.framework
  • image.framework
  • math.framework
  • mesh_misc.framework
  • misc.framework
  • network.framework
  • volume.framework
• API Changes in R21.026
  • crypt.framework
  • network.framework
• API Changes in R21.115
  • cinema.framework
  • core.framework
  • geom.framework
  • math.framework
  • misc.framework
• API Changes in R21.207
  • cinema.framework

API Changes in R21.022

New MAXON API Frameworks

These new frameworks were added

• animation.framework
• corenodes.framework
• render_filter.framework

For an overview see MAXON API Frameworks.

DataType

Many function were changed to return a maxon::DataType& instead of a maxon::DataType*.

cinema.framework

The lib_sn.h header file was removed.

c4d_basebitmap.h

class BaseBitmap
{
  Bool GetImageRef(SAVEBIT saveBit, Bool alpha, maxon::ImageRef& imageRef) const { return C4DOS.Bm->GetImageRef(this, saveBit, alpha, imageRef);
};

c4d_basechannel.h

class BaseShader
{
  Bool BakeShaderIntoBaseBitmap(BaseBitmap& outBmp, BaseDocument& doc, BaseThread* parentThread, Bool doAlpha, Int32 colorSpace, Bool linearworkflow, Bool useHDR, Int xmin, Int xmax, Int ymin, Int ymax);
};

c4d_basedraw.h

The following functions have been marked as deprecated:

• BaseDraw::InitDrawXORPolyLine()
• BaseDraw::FreeDrawXORPolyLine()
• BaseDraw::DrawXORPolyLine()
• BaseDraw::BeginDrawXORPolyLine()
• BaseDraw::EndDrawXORPolyLine()

class BaseDraw
{
  Bool IsMarkedAsCPURenderer();
  Bool IsCPURenderer();
};

c4d_baseeffectordata.h

define BC_ID_CLONE_DATA
 
struct Dpoint
{
  inline Vector GetSize(void);
  // Changed to
  inline Vector GetSize(void) const;
}

c4d_baselist.h

struct FieldGuiGetSubListInfo;
 
#define MSG_FIELDGUI_GETSUBLISTINFO
#define MSG_FIELDGUI_DISABLEMASK
 
class AssetEntry
{
  String      _nodePath;
  // Changed to
  maxon::CString  _nodePath;
 
  maxon::Id        _nodeSpace;
  BaseOverride*    _override;
}
 
struct AssetData
{
  BaseDocument* doc;
  // Changed to
  BaseDocument* _doc
 
  RootTextureString* rs;
  // Changed to
  RootTextureString*  _rs = nullptr;  
 
  ASSETDATA_FLAG flags;
  // Changed to
  ASSETDATA_FLAG      _flags
 
  BaseOverride* _override;
  Int32 _channelId = NOTOK;
 
  Bool Add(const Filename& fn, BaseList2D* bl, Int32 parameterId = NOTOK, Bool netRequestOnDemand = false, Int32 channelIndex = NOTOK, const maxon::String& nodePath = maxon::String());
  // Changed to
  Bool Add(const Filename& fn, BaseList2D* bl, Int32 parameterId = NOTOK, Bool netRequestOnDemand = false, Int32 channelIndex = NOTOK, const maxon::CString& nodePath = maxon::GetZeroRef<maxon::CString>(), const maxon::Id& nodeSpace = maxon::GetZeroRef<maxon::Id>());
}
 
struct CustomIconSettings;
 
class AtomArray
{
  Bool Append(AtomArray* src);
  // Changed to
  Bool Append(const AtomArray* src);
 
  Bool Compare(AtomArray* cmp);
  // Changed to
  Bool Compare(const AtomArray* cmp) const;
}
 
class GeListHeadCB;

c4d_bitmapfilter.h

// Removed
Bool IsHostWindow(void* win);

c4d_commanddata.h

struct RestoreLayoutSecret
{
  GeDialog* dlg;
};
 
class CommandData
{
  virtual Bool Execute(BaseDocument* doc);
  // Changed to
  virtual Bool Execute(BaseDocument* doc, GeDialog* parentManager);
 
  virtual Bool ExecuteSubID(BaseDocument* doc, Int32 subid);
  // Changed to
  virtual Bool ExecuteSubID(BaseDocument* doc, Int32 subid, GeDialog* parentManager);
 
  virtual Bool ExecuteOptionID(BaseDocument* doc, Int32 plugid, Int32 subid);
  // Changed to
  virtual Bool ExecuteOptionID(BaseDocument* doc, Int32 plugid, Int32 subid, GeDialog* parentManager);
 
  virtual Int32 GetState(BaseDocument* doc);
  // Changed to
  virtual Int32 GetState(BaseDocument* doc, GeDialog* parentManager);
 
  virtual Bool GetSubContainer(BaseDocument* doc, BaseContainer& submenu);
  // Changed to
  virtual Bool GetSubContainer(BaseDocument* doc, BaseContainer& submenu, GeDialog* parentManager);
};

c4d_descriptiondialog.h

class DescriptionToolData
{
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom* res_at);
  // Changed to
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom*& res_at);
}

c4d_fielddata.h

static const Int32 FLchannelmix;
 
struct FieldOutput
{
  maxon::BaseArray<Vector> _pivot;
}
 
struct FieldOutputBlock
{
  maxon::Block<Vector>  _pivot;
}
 
class FieldCallerStack
{
  static maxon::Result<FieldCallerStack> Create(BaseList2D* caller);
  // Changed to
  static maxon::Result<FieldCallerStack> Create(const BaseList2D* caller);
 
  static maxon::Result<FieldCallerStack> Create(const std::initializer_list<BaseList2D*>& callers);
  // Changed to
  static maxon::Result<FieldCallerStack> Create(const std::initializer_list<const BaseList2D*>& callers);
 
  BaseList2D* operator[](Int index) const;
  // Changed to
  const BaseList2D* operator[](Int index) const;
 
  void UpdateValue(BaseList2D* caller);
  // Changed to
  void UpdateValue(const BaseList2D* caller);
 
  maxon::Result<void> Add(BaseList2D* caller);
  // Changed to
  maxon::Result<void> Add(const BaseList2D* caller);
 
  static FieldCallerStack Add(const FieldCallerStack& src, BaseList2D* newCaller);
  // Changed to
  static FieldCallerStack Add(const FieldCallerStack& src, const BaseList2D* newCaller);
 
  maxon::BaseArray<BaseList2D*> _callers;
  // Changed to
  maxon::BaseArray<const BaseList2D*> _callers;
}
 
class FieldLayer
{
  GeListHead* GetMaskHead() const;
  maxon::Result<void> AddMask();
  void RemoveMask(Bool deleteLayers = true);
}
 
static const Int32 MSG_PRESAMPLE_FIELD_SINGLE;
static const Int32 MSG_POSTSAMPLE_FIELD_SINGLE;
 
struct PresampleFieldSingleData;

c4d_general.h

maxon::Result<void> GetGeneralLicensingInformation(maxon::String& productId, maxon::String& systemId, maxon::String& userId);
maxon::Result<maxon::String> ExportLicenses();
maxon::Result<void> AddLicenseItem(const maxon::InternedId& licenseItemId, Float versionNumber, maxon::CustomLicenseItemDelegate&& licenseUpdateCallback);
 
maxon::Bool CheckLicenseFeature(const maxon::InternedId& featureId);
Bool HasFullFeatureSet();
 
// Removed
GeGetSerialInfo();
// Removed
GeGetSystemInfo();
 
GeGetUserName();
 
maxon::Result<maxon::BaseArray<maxon::Url>> GetRecentDocumentsList(Bool isBodyPaint);
 
Vector GetViewColor(Int32 colid);
// Changed to
Vector GetViewColor(Int32 colid, Vector* defaultColor = nullptr);
 
enum class MACHINEFEATURESTYPE
{
  // Removed
  SOFTWARE_OGL;
}

c4d_gui.h

// Removed
#define DRAWBEZIER_BX
#define DRAWBEZIER_BY
#define DRAWBEZIER_CX
#define DRAWBEZIER_CY
#define DRAWBEZIER_DX
#define DRAWBEZIER_DY
 
class GeUserArea
{
  Int32 GetId();
  // Changed to
  Int32 GetId() const;
 
  Int32 GetWidth();
  // Changed to
  Int32 GetWidth() const;
 
  Int32 GetHeight();
  // Changed to
  Int32 GetHeight() const;
 
  Bool IsEnabled();
  // Changed to
  Bool IsEnabled() const;
 
  Bool IsR2L();
  // Changed to
  Bool IsR2L() const;
 
  Bool HasFocus();
  // Changed to
  Bool HasFocus() const;
 
  Bool GetInputState(Int32 askdevice, Int32 askchannel, BaseContainer& res);
  // Changed to
  Bool GetInputState(Int32 askdevice, Int32 askchannel, BaseContainer& res) const;
 
  Bool GetInputEvent(Int32 askdevice, BaseContainer& res);
  // Changed to
  Bool GetInputEvent(Int32 askdevice, BaseContainer& res) const;
 
  HOTKEYFLAGS IsHotkeyDown(Int32 id);
  // Changed to
  HOTKEYFLAGS IsHotkeyDown(Int32 id) const;
 
 
  void DrawSetOpacity(Float opacity);
 
  Bool GetColorRGB(Int32 colorid, Int32& r, Int32& g, Int32& b);
  // Changed to
  Bool GetColorRGB(Int32 colorid, Int32& r, Int32& g, Int32& b) const;
 
  void DrawLine(Int32 x1, Int32 y1, Int32 x2, Int32 y2);
  // Changed to
  void DrawLine(Int32 x1, Int32 y1, Int32 x2, Int32 y2, Float lineWidth = 1.0, LINESTYLE lineStyle = LINESTYLE::NORMAL);
 
  void DrawFrame(Int32 x1, Int32 y1, Int32 x2, Int32 y2, Float lineWidth = 1.0, LINESTYLE lineStyle = LINESTYLE::NORMAL);
 
  // Removed
  void DrawBezier(Float sx, Float sy, Float* p, Int32 len, Bool closed, Bool filled);
 
  void DrawBezierLine(const Vector2d& startPoint, const maxon::Block<const BezierPoint>& bezierPoints, Bool closed, Float lineWidth = 1.0, LINESTYLE lineStyle = LINESTYLE::NORMAL);
  void DrawBezierFill(const Vector2d& startPoint, const maxon::Block<const BezierPoint>& bezierPoints, Bool closed);
 
  void DrawPolyLine(const maxon::Block<const Vector2d>& p, Bool closed, Float lineWidth = 1.0, LINESTYLE lineStyle = LINESTYLE::NORMAL);
  void DrawPolyFill(const maxon::Block<const Vector2d>& p, Bool closed);
 
  void DrawEllipseLine(const Vector2d& centerPoint, const Vector2d& radius, Float lineWidth = 1.0, LINESTYLE lineStyle = LINESTYLE::NORMAL);
  void DrawEllipseFill(const Vector2d& centerPoint, const Vector2d& radius);
 
  void DrawCustomButton(Int32 x, Int32 y, Int32 w, Int32 h, const Int32* ids, Bool nofill, Bool focus);
 
  Int32 DrawGetTextWidth(const maxon::String& text);
  // Changed to
  Int32 DrawGetTextWidth(const maxon::String& text) const;
 
  Int32 DrawGetTextWidth_ListNodeName(BaseList2D* node, Int32 fontid = FONT_STANDARD);
  // Changed to
  Int32 DrawGetTextWidth_ListNodeName(BaseList2D* node, Int32 fontid = FONT_STANDARD) const;
 
  Int32 DrawGetFontHeight();
  // Changed to
  Int32 DrawGetFontHeight() const;
 
  Int32 DrawGetFontBaseLine();
  // Changed to
  Int32 DrawGetFontBaseLine() const;
 
  Bool Local2Global(Int32* x, Int32* y);
  // Changed to
  Bool Local2Global(Int32* x, Int32* y) const;
 
  Bool Global2Local(Int32* x, Int32* y);
  // Changed to
  Bool Global2Local(Int32* x, Int32* y) const;
 
  Bool Local2Screen(Int32* x, Int32* y);
  // Changed to
  Bool Local2Screen(Int32* x, Int32* y) const;
 
  Bool Screen2Local(Int32* x, Int32* y);
  // Changed to
  Bool Screen2Local(Int32* x, Int32* y) const;
 
  Bool Local2Global(Float& x, Float& y) const;
  Bool Global2Local(Float& x, Float& y) const;
  Bool Local2Screen(Float& x, Float& y) const;
  Bool Screen2Local(Float& x, Float& y) const;
 
  Bool GetDragPosition(const BaseContainer& msg, Int32* x, Int32* y);
  // Changed to
  Bool GetDragPosition(const BaseContainer& msg, Int32* x, Int32* y) const;
 
  Bool GetDragObject(const BaseContainer& msg, Int32* type, void** object);
  // Changed to
  Bool GetDragObject(const BaseContainer& msg, Int32* type, void** object) const;
 
  void GetBorderSize(Int32 type, Int32* l, Int32* t, Int32* r, Int32* b);
  // Changed to
  void GetBorderSize(Int32 type, Int32* l, Int32* t, Int32* r, Int32* b) const;
 
  Bool CheckDropArea(const BaseContainer& msg, Bool horiz, Bool vert);
  // Changed to
  Bool CheckDropArea(const BaseContainer& msg, Bool horiz, Bool vert) const;
};
 
// Removed
GeClipMap* GetInterfaceScheme(Int32 type);

c4d_materialdata.h

#define PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU

c4d_painter.h

#define UV_SET_FROM_PROJECTION_CMD_ID
 
class PaintLayerMask 
{
  Bool GetEditMaskMode();
};

c4d_shader.h

struct Multipass
{
  Vector* vp_reflectance_albedo;
  Vector** aov_channel;
  Int32*   aov_channel_id;
  Int32 aov_channel_cnt;
}

c4d_tooldata.h

class ToolData
{
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom* res_at);
  // Changed to
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom*& res_at);
};

c4d_videopostdata.h

#define VPBUFFER_AOV
#define VPBUFFER_REFLECTANCE_ALBEDO
 
#define VPDenoiser

ge_autoptr.h

template <class TYPE> class AutoAlloc
{
  operator const TYPE*() const;
  operator const TYPE&() const;
  const TYPE* operator -> () const;
  const TYPE* const* operator & () const;
};

ge_prepass.h

struct BezierPoint;
enum class LINESTYLE;
 
enum class ASSETDATA_FLAG
{
  NODOCUMENT;
};
 
enum class SCENEFILTER
{
  SKIPOLDERTHANV13,
  PREVIEWONLY,
  DOCUMENTPREFSONLY
};
 
#define Ofieldforce
 
#define Ovolumegroup
// Changed to
#define Ovolumeset
 
#define ID_LISTHEADCB
 
#define Tuserdata
 
 
#define MDATA_JOIN_RESPECT_VISIBILITY
#define MDATA_GROWSELECTION_USEEDGE  
 
enum class MESHTOVOLUMESETTINGS
{
  UNSIGNED_DISTANCE_FIELD
};
 
enum class SPLINETOVOLUMESETTINGS
{
  SCALESEGMENT
};
 
enum class FILTERSETTINGS
{
  INVERTPOINT
};
 
// Remove
#define WPREF_HW_OPENGL
#define WPREF_OPENGL_TEMP
 
 
#define WPREF_MATMANAGER_DEFAULT_MATERIAL
#define WPREF_OPENGL_UVEDITOR_ANTIALIAS
 
#define WPREF_RENDERQUEUE_AUTORENAME
 
#define WPREF_FILE_ASSETS_LINK
 
 
#define WPREF_FILE_ASSETS_LINK_RELATIVE
#define WPREF_FILE_ASSETS_LINK_ABSOLUTE
#define WPREF_FILE_ASSETS_LINK_ASK
 
#define WPREF_COMMUNICATION_QUICKSTART_DIALOG
 
WPREF_COMMUNICATION_METRICS_ENABLE
// Changed to
WPREF_COMMUNICATION_METRICS_DISABLE
 
// Removed
WPREF_COMMUNICATION_METRICS_ENABLE_COMMANDS
WPREF_COMMUNICATION_METRICS_ENABLE_PREFERENCES
WPREF_COMMUNICATION_METRICS_ENABLE_SYSTEM_INFO
 
#define VIEWCOLOR_UVGIZMO_NORMAL
#define VIEWCOLOR_UVGIZMO_CANDIDATE
#define VIEWCOLOR_UVGIZMO_IN_MOTION
#define VIEWCOLOR_UVGIZMO_ANCHOR_SNAPPED
#define VIEWCOLOR_UV_AXIS_U
#define VIEWCOLOR_UV_AXIS_V
#define VIEWCOLOR_JOINT
#define VIEWCOLOR_HANDLES
 
enum class GETBRANCHINFO
{
  ONLYWITHANIMATION
};
 
enum class BRANCHINFOFLAGS
{
  HASFIELDS
};
 
// Removed
#define FORMAT_LWSIMPORT
#define FORMAT_LWOIMPORT
 
enum class REGISTRYTYPE
{
  // Removed
  SNHOOK
}
 
// Removed
enum class SERIALINFO;
 
enum class VERSIONTYPE
{
  // Removed
  PRIME,
  BODYPAINT,
  STUDIO,
  VISUALIZE,
  BROADCAST,
  INSTALLER,
  NET_CLIENT,
  NET_SERVER_3,
  NET_SERVER_UNLIMITED,
  UNKNOWN,
  LICENSESERVER,
 
  UNKNOWN,
  LITE,
  TEAMRENDER_CLIENT,
  TEAMRENDER_SERVER,
  CINEMA4D,
  COMMANDLINE,
  CINEWARE,
  CPYTHON,
  CPYTHON3
};
 
// Removed
enum class SYSTEMINFO;
 
enum class FIELDLAYER_FLAG
{
  // Removed
  SKIPWITHDEFAULTOUTPUTS
};
 
enum
{
  LV_GETBUBBLEHELP
};
 
enum class CINEMAINFO
{
  FORBID_HWOGL,
  // Changed to
  MINIMAL_VIEWPORT
};
 
enum class FIELDSAMPLE_FLAG
{
  NONLINEARCOLOR;
}

gui.h

enum
{
  BMP_EMBOSSED
  // Changed to
  BMP_GRAYEDOUT,
 
  BMP_TRANSPARENTALPHA,
  BMP_SCALE_NEARESTPIXEL
};
 
enum
{
  BORDER_THIN_INb,
  BORDER_TEXT_DOTTED
};
 
enum
{
  SCROLLGROUP_BORDERINb
}

customgui_descproperty.h

#define DESCRIPTIONPROPERTY_CONNECTIONSTATE
// Changed to
#define DESCRIPTIONPROPERTY_PORTSTATE  

customgui_description.h

define DESCRIPTION_HIDE_LAYOUT_SWITCH
 
class DescriptionCustomGui
{
  void SetObjectList(const AtomArray &list);
  // Changed to
  void SetObjectList(const AtomArray &list, Bool limitExceeded = false);
};

customgui_field.h

static const Int32 ID_FIELDSUBLIST_ICON;
static const Int32 ID_FIELDMASK_ICON;

customgui_gradient.h

enum
{
    GRADIENT_INTERPOLATION_CUBICBIAS
};

customgui_htmlviewer.h

typedef void HtmlViewerCustomGuiURLCallback(void *user_data, const maxon::String &url, Int32 encoding, void *reserved);
// Changed to
typedef void HtmlViewerCustomGuiURLCallback(void *user_data, const maxon::String &url, Bool hasError, Int32 encoding, void *reserved);

customgui_itemtree.h

#define ITEMTREE_FLAG_GREYED_OUT

customgui_listview.h

#define LV_CHECKBOX_GREYEDOUT
 
class TreeViewFunctions
{
  virtual String GetBubbleHelp(void* root, void* userdata, void* obj, Int32 col, CellInfo* info);
 
  virtual void SetFloatValue(void *root, void *userdata, void *obj, Int32 lColumn, Float value);
  // Changed to
  virtual void SetFloatValue(void *root, void *userdata, void *obj, Int32 lColumn, Float value, Bool finalValue);
 
  virtual void SetFloatValueEx(void *root, void *userdata, void *obj, Int32 lColumn, Float value);
};

customgui_splinecontrol.h

class SplineData
{
  Float GetTension() const;
  void SetTension(Float tension);
};

c4d_graphview_def.h

#define ID_GV_VALUE_TYPE_COLORA
#define ID_GV_DATA_TYPE_COLORA

c4d_particles.h

#define ID_TP_OP_FORCEOBJECT

lib_ca.h

class CAWeightTag
{
  Bool TransferWeightMap(BaseDocument *doc, CAWeightTag *dst, Int32 sindex, Int32 dindex, Int32 offset, Int32 cnt, AliasTrans *trans);
  // Changed to
  Bool TransferWeightMap(BaseDocument *doc, CAWeightTag *dst, Int32 sindex, Int32 dindex, Int32 offset, Int32 cnt, AliasTrans *trans, Bool mergeTags = false);
};
 
class CAWeightMgr
{
  static maxon::Result<Int> GetAutoWeightAlgoIndex(BaseDocument* doc, const maxon::Id& id);
  static maxon::Result<maxon::Id> GetAutoWeightAlgoId(BaseDocument* doc, Int index);
  static maxon::Result<void> GetAutoWeightRef(BaseDocument *doc, const maxon::Id& autoweightId, maxon::AutoWeightRef& autoWeightRef);
  static maxon::Result<maxon::DataDictionary>GetAutoWeightDictionary(BaseDocument *doc, const maxon::Id& autoweightId);
  static maxon::Result<void> SetAutoWeightDictionary(BaseDocument *doc, maxon::DataDictionary dataDictionary, maxon::Id autoweightId);
 
  static Bool AutoWeight(BaseDocument* doc, Bool allowNull);
  // Changed to
  static Bool AutoWeight(BaseDocument* doc);
}:

lib_clipmap.h

class GeClipMap
{
  IMAGERESULT Init(GeUserArea* userArea, Int32 x, Int32 y, Int32 w, Int32 h);
  const BaseBitmap* GetBitmap() const;
  Bool SupportsDrawBezierSegment() const;
  void DrawBezierSegment(const maxon::Vector2d* p);
}

lib_customdatatag.h

class CustomDataTag
{
  maxon::Result<const maxon::DataType*> GetDataType() const;
  // Changed to
  maxon::Result<maxon::DataType> GetDataType() const;
};

lib_description.h

struct DescriptionCommand
{
  BaseContainer _data;
}

lib_instanceobject.h

class InstanceObject
{
  maxon::Result<void> SetInstanceMatrix(UInt index, const Matrix& globalMatrix);
  UInt32 GetMatrixDirtyID(UInt index) const;
  maxon::Result<void>  SetInstanceUniqueIPs(const maxon::BaseArray<Int32> &uniqueIPs);
  const maxon::BaseArray<Int32>*  GetInstanceUniqueIPs() const;
  Int32  GetInstanceUniqueIP(UInt index) const;
};
 
struct MultiInstanceData
{
 maxon::BaseArray<Int32> instanceUniqueIPs; 
};

lib_sculptbrush.h

class SculptBrushToolData
{
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom* res_at);
  // Changed to
  virtual Bool TranslateDescID(BaseDocument* doc, BaseContainer& data, const DescID& id, DescID& res_id, C4DAtom*& res_at);
};

lib_splinehelp.h

class SplineHelp
{
  Bool CopyTo(SplineHelp *dest);
  // Changed to
  Bool CopyTo(SplineHelp *dest) const;
};

lib_token.h

Bool RegisterPythonToken(const String& key, const String& help, const String& example, void* callback);
Bool RegisterPythonHiddenToken(const String& key, const String& help, const String& example, void* callback);

lib_volumebuilder.h

enum class MIXVECTORTYPE;
 
class VolumeBuilder
{
  void SetMixVectorMode(Int32 index, MIXVECTORTYPE mode);
  MIXVECTORTYPE GetMixVectorMode(Int32 index) const;
};

lib_volumeobject.h

class VolumeObject
{
  maxon::VolumeInterface* GetVolume() const;
  // Changed to
  const maxon::VolumeInterface* GetVolume() const;
 
  void SetVolume(maxon::VolumeInterface* volumeObj);
  // Changed to
  void SetVolume(const maxon::VolumeInterface* volumeObj);
};

lib_volumeset.h

class VolumeSet;

lib_volumetag.h

class VolumeTag;

core.framework

The ask_password.h and jobbarrier.h header files have been removed.

apibase.h

// moved to intfloat.h
struct IntFloat32;
struct IntFloat64;
 
class EntityBase
{
  enum class TYPE
  {
    GLOBAL
  };
};
 
enum class VALUEKIND
{
  // Removed
  INDEXABLE,
  ABSTRACT_VIEW,
  ARRAY_VIEW,
  XFORM_VIEW,
  CONCAT_VIEW  ,
  VIEW_REF,
  ARRAY_CONTAINER,
  SET_CONTAINER,
  INDIVIDUAL_MEMBERS,
  TIMESTAMPED,
  GENERIC_MEMBERS,
  ARRAY_VIEW_COW_REFS
  ARRAY_CONTAINER_REF,
  SET_CONTAINER_REF,
  OWNS_TYPE_ARGUMENTS,
  ARRAY_CONTAINER_BASE_TEST,
  ARRAY_CONTAINER_REF_BASE_TEST,
  INDEXABLE_MASK,
  CONTAINER_MASK,
  CONTAINER_REF_MASK
 
 
  VALUE,
  ELEMENT_TYPE_AS_ARG,
  NEVER_NULLPTR,
  SIGNED,
  CONTAINER,
  STATIC_ARRAY_CONTAINER,
  ARRAY_CONTAINER,
  CONTAINER_REF,
  GENERIC_CONTAINER,
  ARRAY_CONTAINER_MASK,
  DERIVED_CONTAINER_MASK,
  CONTAINER_MASK,
  CONTAINER_OR_REF,
};

application.h

enum class APPLICATION_URLTYPE
{
  CURRENT_MODULE_DIR,
  CURRENT_MODULE_RESOURCE_DIR
};
 
// Removed
enum class APPLICATIONTYPE;
 
enum class APPLICATIONFEATURE;
 
class Application
{
  // Removed
  static MAXON_METHOD APPLICATIONTYPE GetApplicationType();
 
  static MAXON_METHOD Bool GetFeature(APPLICATIONFEATURE feature);
  static MAXON_METHOD void SetFeature(APPLICATIONFEATURE feature, Bool value);
};

atomictypes.h

template <typename T> class AtomicFloatType;
 
class StrongReferenceCounter
{
  static StrongReferenceCounter& Get(const void* object);
};

basebitset.h

template <typename ALLOCATOR = DefaultAllocator> class BaseBitSet
{
  void ClearUnchecked(UInt index);
  Result<void> SetRange(UInt first, UInt last);
  Result<void> MergeOr(const BaseBitSet<ALLOCATOR>& src);
  Result<void> MergeAnd(const BaseBitSet<ALLOCATOR>& src);
  Result<void> MergeXOr(const BaseBitSet<ALLOCATOR>& src);
  Int GetCapacity() const;
};

block.h

template <typename T, Bool STRIDED , Bool MOVE > class Block : public ArrayBase<Block<T, STRIDED, MOVE>, T, BlockBase<T, STRIDED>, DefaultCompare>
{
  Bool StartsWith(const Block& prefix) const
};

blockarray.h

template <typename T, Int BLOCK_SIZE_EXPONENT = BLOCKARRAY_DEFAULT_SIZE_EXPONENT, BLOCKARRAYFLAGS MEMFLAGS = BLOCKARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator> class BlockArray : public ArrayBase<BlockArray<T, BLOCK_SIZE_EXPONENT, MEMFLAGS, ALLOCATOR>, T, ALLOCATOR, DefaultCompare>
{
  BaseArray<ArrayBlock, BASEARRAY_DEFAULT_CHUNK_SIZE, BASEARRAYFLAGS::NONE, ForwardAllocator> Disconnect();
  Super Disconnect();
}

collection.h

template <Bool CONSTITERATOR, Bool STRIDED> class BlockIterator : public ForEachIterator<BlockIterator<CONSTITERATOR, STRIDED>>
// Changed to
template <typename COLLECTION, typename VALUETYPE, Bool CONSTITERATOR, Bool STRIDED> class BlockIterator : public ForEachIterator<BlockIterator<COLLECTION, VALUETYPE, CONSTITERATOR, STRIDED>>;

crc32c.h

class Crc32C
{
  MAXON_ATTRIBUTE_FORCE_INLINE void UpdateInt16(Int16 i);
  MAXON_ATTRIBUTE_FORCE_INLINE void UpdateChar(Char i);
};

datadescriptionobject.h

class DataDescriptionObjectInterface
{
  static MAXON_METHOD Result<String> GetObjectName(const Id& classId, const LanguageRef& language);
};

datadictionary.h

Result<void> MergeDataDictionariesPreferBase(DataDictionary& base, const DataDictionary& other, Bool mergeSubContainers);

datadictionaryobject.h

class DataDictionaryObjectInterface
{
  template <typename KEY> MAXON_FUNCTION Bool Existing(KEY&& key) const;
}

datatypebase.h

enum class CONVERSION_FLAGS
{
  INCONVERTIBLE
}

datatypelib.h

class InternedId;
struct TypeArguments;
 
class DataTypeLib
{
  static MAXON_METHOD const DataType& GetEllipsisType();
 
  // Removed
  static MAXON_METHOD Result<const TupleDataType*> GetTupleType(const Block<const DataType* const>& types);
  static MAXON_METHOD Result<const TupleDataType*> GetTupleType(const Block<const Result<const DataType*>>& types);
  static MAXON_METHOD Result<const TupleDataType*> GetTupleType(const Block<const Member>& members);
  static MAXON_METHOD Result<const TupleDataType*> GetTupleTypeWithIndividualMembers(const TupleDataType* type);
 
  static MAXON_METHOD Result<DataType> GetReferenceType(const DataType& type, EntityBase::FLAGS refFlags);
 
  static MAXON_METHOD Result<const MemberMap*> GetMemberMap(Block<const Int> block);
 
  static MAXON_METHOD Result<const MemberMap*> GetIdentityMemberMap(Int length);
 
  static MAXON_METHOD Result<const MemberMap*> ConcatMemberMap(const MemberMap* first, const MemberMap* second);
 
  static MAXON_METHOD Result<const MemberMap*> PrivateGetMemberMap(const DataTypeImpl* containerType, const DataTypeImpl* runtimeType);
 
  static MAXON_METHOD Result<StrongRef<TypeArguments>> CreateTypeArguments(const Block<const Member>& args);
};
 
class TupleDataType 
{
  // Removed
  Result<const TupleDataType*> GetWithIndividualMembers() const;
};

datetime.h

class UniversalDateTime
{
  UniversalDateTime& operator += (const TimeValue& t);
  UniversalDateTime& operator -= (const TimeValue& t);
  UniversalDateTime operator +(const TimeValue& t) const;
  UniversalDateTime operator -(const TimeValue& t) const;
 
  static UniversalDateTime FromJulianDay(Float64 j);
  // Changed to
  static UniversalDateTime FromJulianDay(JULIANDATE variant, Float64 j);
};

decorator.h

class WeakDecoratorInterface;

descriptionprocessor.h

class DescriptionProcessorInterface;

errorbase.h

class DisabledErrorInterface;

fixedsizebitset.h

template <Int EXPONENT> class FixedSizeBitSet
{
  void Remove(UInt index);
  Bool IsPopulated() const;
  Bool IsEmpty() const;
  void Reset();
}

genericdata.h

class GenericData;

genericfunction.h

namespace ParametricTypes
{
  class FunctionType;
};

hashmap.h

enum class HASHMAP_ENTRY_LAYOUT
{
  KEY_HASH_VALUE
};
 
struct HashMapKeyHashValuePair;
 
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE>;
 
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE>;
 
template <typename VALUEHASH> class Hash
{
  const Char* GetSignature(void*) const;
  const Char* GetSignature(Char*) const;
};
 
template <typename K_TO, typename V_TO, typename K_FROM, typename V_FROM, Bool SAFE> struct GenericCastMemberTrait<HashMap<K_TO, V_TO>, HashMap<K_FROM, V_FROM>, SAFE>;
 
template <typename T, typename HASH = DefaultCompare, typename ALLOCATOR = DefaultAllocator, Bool SYNCHRONIZED = false> class HashSet
// Changed to
template <typename T, typename HASH = DefaultCompare, typename ENTRY_HANDLER = HashMapKeyValuePair, typename ALLOCATOR = DefaultAllocator, Bool SYNCHRONIZED = false> class HashSet
 
template <typename TO, typename FROM, Bool SAFE> struct GenericCastMemberTrait<HashSet<TO>, HashSet<FROM>, SAFE> : public GenericCastMemberTrait<TO, FROM, SAFE>;

hierarchyobject.h

template <typename REF> struct DefaultHierarchy;
template <> struct DefaultHierarchy<void>;
 
class HierarchyObjectInterface
{
  // HierarchyObjectRef& arugments and return values have been replaced with typename HIERARCHY::template Child<Interface>::type
};

interfacetemplate.h

template <typename TO, typename FROM> struct SpecialOut;
template <typename TO, typename FROM> struct SpecialOut<GenericRef<TO>, FROM>;
class NumberBaseInterface;
template <typename T, Int X> class NumberInterface;
template <typename T> class Number2Interface;

intfloat.h

struct IntFloat32;
struct IntFloat64;

job.h

template <typename BASE> struct ObservableCancelledBase
{
  Result<void> RemoveObserver(JobInterface* observer);
  static Result<void> RemoveCancelledObserver(JobInterface* job, JobInterface* observer);
};

lazyinit.h

// moved to lazyinitthreaded.h
class LazyInitThreaded:

lazyinitthreaded.h

class LazyInitThreaded;

lexer.h

enum class LEXERSYMBOL : UChar
{
  OPERATOR
};
 
enum class LEXERSYMBOLFLAGS
{
  MINUS_OPERATOR
};
 
enum class LEXERINITFLAGS
{
  ALLOW_DOLLAR_IDENT,
  ALLOW_AT_IDENT,
  NON_ASCII_IS_IDENT,
  HASH_COMMENTS,
  ESCAPE_IN_SINGLE_QUOTED,
  C_ESCAPE_SEQUENCES,
  SPACESCOMPATIBILITY
}
 
class LexerInterface
{
  MAXON_METHOD Result<void> AddOperator(const String& chars);
  MAXON_METHOD Result<Int64> GetSymbolPosition() const;
}

machineinfo.h

MAXON_ATTRIBUTE(maxon::String, UNIQUEOSIDENTIFIER, "net.maxon.machineinfo.uniqueosidentifier");
MAXON_ATTRIBUTE(maxon::String, DISPLAYDEVICE, "net.maxon.machineinfo.displaydevice");

module.h

// moved
class InternedId
 
#define MAXON_LOCAL_INTERNED_ID
// Changed to
#define MAXON_INTERNED_ID_LOCAL
 
class Binary
{
  const Url& GetUrl() const;
};
 
template <typename T, typename C> class Declaration
{
  static Id GetId();
  // Changed to
  static constexpr LiteralId GetId();
 
  const T& GetWithoutDependency() const;
}

objectbase.h

class InterfaceReference
{
  EntityBase::FLAGS GetFlags() const;
};
 
class ComponentDescriptor
{
  Int GetSize() const;
};
 
class ClassInterface
{
  // Removed
  MAXON_METHOD Result<ObjectRef> CreateRef() const;
 
 
  template <typename REFCLASS> MAXON_FUNCTION Result<typename maxon::details::ClassCreateType<REFCLASS>::type> Create() const;
  // Changed to
  MAXON_METHOD Result<typename maxon::details::ClassGetNonConst<REF>::type> Create() const;
 
 
  MAXON_METHOD Bool IsSubclassOf(const Class<>& other) const;
};
 
template <typename R, typename SRC> inline typename SFINAEHelper<Result<R>, typename R::ReferencedType, typename SRC::ReferencedType>::type AssertCast(Result<SRC>&& src)
 
// Removed
template <typename REFCLASS> inline Result<typename maxon::details::ClassCreateType<REFCLASS>::type> ClassInterface::Create() const;
template <typename R> class Class : public ReferenceBase<ClassInterface::ReferenceFunctions<RefBaseFunctions<DirectRef<const ClassInterface, StrongRefHandler, maxon::Class<R>>>>>;

observerobject.h

template <typename T> class StaticObservableStorage;

optional.h

class Opt
{
  T GetValueOrNull() const;
  T MoveValueOrNull();
}
 
class Opt<const T&>
{
  const T& GetValueOrNull() const;
}

parametric_type.h

class ParametricTypeInterface
{
  MAXON_FUNCTION Result<DataType> Instantiate(const Block<const DataType>& types, const Block<const Int64>& iargs = GetZeroRef<Block<const Int64>>()) const;
  MAXON_FUNCTION Result<DataType> Instantiate(Result<DataType>&& type, const Block<const Int64>& iargs = GetZeroRef<Block<const Int64>>()) const;
  MAXON_FUNCTION Result<DataType> PrivateInstantiate(Block<Result<DataType>>&& types) const;
  MAXON_METHOD void ResetInstantiated(DataTypeImpl* type) const;
 
  MAXON_METHOD DataTypeImpl*& GetLeakingLink(DataTypeImpl* type) const;
 
  // Removed
  MAXON_METHOD Result<const DataType*> Substitute(const DataType* orig, const Delegate<Result<const DataType*>(const DataType*)>& replace) const;
};
 
namespace ParametricTypes
{
  class ParametricTupleType 
}

parser_json.h

enum class NETWORKPROTOCOLJSONFLAGS
// Changed to
enum class JSONPARSERFLAGS
 
// Removed
class NetworkProtocolJSONInterface;
 
class JsonParserInterface;

parser_jwt.h

enum class JWTPARSERFLAGS;
class JwtParserInterface;

rangemap.h

template <typename K> struct RangeSetPair
{
  static Result<void> DescribeIO(const DataSerializeInterface& stream);
}
 
template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class RangeMap
{
  static Result<void> DescribeIO(const DataSerializeInterface& stream);
}

reflectionbase.h

class Member
{
  enum class KIND
  {
    CONTAINER_TEST
  };
};
 
class Container 
{
  static const Container* Find(const Id& memberId);
}
 
class Class
{
  MAXON_METHOD const NonvirtualInterfaceReference* GetInterface() const;
  // Changed to
  MAXON_METHOD const InterfaceReference* GetInterface() const;
 
  MAXON_METHOD const InterfaceReference* GetVirtualInterface() const;
  // Changed to
  MAXON_METHOD const NonvirtualInterfaceReference* GetNonvirtualInterface() const;
 
  MAXON_METHOD const Class* GetStaticInterface() const;
}
 
class Function
{
  MAXON_METHOD const Block<const Parameter>& GetParameters() const;
  MAXON_METHOD Bool IsPure() const;
  MAXON_METHOD void* GetAddress() const;
 
  static MAXON_METHOD Result<void> FindAll(const Id& memberId, const ValueReceiver<const Function*>& result);
}

registrybase.h

class RegistryInterface
{
  MAXON_METHOD Result<GenericData> AddObserver(Delegate<void(const Id& eid, const ConstDataPtr& value, Bool inserted)>&& observer, Bool notifyDuringRegistration) const;
  static MAXON_METHOD Result<GenericData> Register(const RegistryInterface* registry, const Id& eid, ForwardingDataPtr&& value);
};
 
template <typename T, typename R> class Registry
{
  static Result<GenericData> Register(const Id& eid, const T& object);
  static Result<GenericData> Register(const Id& eid, T&& object);
}

secure_random.h

class SecureRandom
{
static MAXON_METHOD Bool GetRandomNumber(SecureRandomProvider provider, const Block<UChar>& buffer);
// Changed to
static MAXON_METHOD Bool GetRandomNumber(SecureRandomProvider provider, const Block<Byte>& buffer);
}

sse_matrix_4f32.h

class Matrix4f32;

sse_vector.h

MAXON_ATTRIBUTE_FORCE_INLINE void SSECross(Vector8f32* r, const Vector8f32* a, const Vector8f32* b);
template<Bool useRsqrt = false> MAXON_ATTRIBUTE_FORCE_INLINE void SSENormalize(Vector8f32 *n);
MAXON_ATTRIBUTE_FORCE_INLINE Vector8f32 ConvertToVector8f32(const Vector4f32& a, const Vector4f32& b);
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertToVectors4f32(const Vector8f32& a, Vector4f32& result1, Vector4f32& result2);
MAXON_ATTRIBUTE_FORCE_INLINE Vector8i32 CastToVector8i32(const Vector8f32& a);
MAXON_ATTRIBUTE_FORCE_INLINE Vector8f32 CastToVector8f32(const Vector8i32& a);

sse_vector_4f32.h

MAXON_ATTRIBUTE_FORCE_INLINE void LoadUnaligned(const Float64* p);
MAXON_ATTRIBUTE_FORCE_INLINE void LoadAligned(const Float64* p);

sse_vector_8i32.h

class Vector8i32;

streamconversion.h

namespace StreamConversions
{
  MAXON_DECLARATION(StreamConversionFactory, Base64UrlEncoder, "net.maxon.streamconversion.base64url.encoder");
  MAXON_DECLARATION(StreamConversionFactory, Base64UrlDecoder, "net.maxon.streamconversion.base64url.decoder");
};

string.h

template <typename INTERFACETYPE, typename REFTYPE, typename CHARTYPE> class StringTemplate
{
  MAXON_METHOD INTERFACETYPE* Append(const INTERFACETYPE* str);
  // Changed to
  MAXON_METHOD Result<void> Append(const INTERFACETYPE* str);
 
  MAXON_METHOD INTERFACETYPE* Append(const CHARTYPE* str, Int len);
   Changed to
  MAXON_METHOD Result<void> Append(const CHARTYPE* str, Int len);
 
  MAXON_FUNCTION INTERFACETYPE* AppendChar(CHARTYPE v);
  // Changed to
  MAXON_FUNCTION Result<void> AppendChar(CHARTYPE v);
 
  MAXON_METHOD Result<void> Split(const REFTYPE& splitSymbol, Bool trim, BaseArray<REFTYPE>& parts) const;
  // Changed to
  MAXON_METHOD Result<void> Split(const REFTYPE& splitSymbol, Bool trim, const ValueReceiver<const REFTYPE&>& parts) const;
}

system.h

namespace APPLICATIONID
{
  static const Id UNKNOWN;
  static const Id LITE;
  static const Id CINEBENCH;
  static const Id UPDATER;
  static const Id TEAMRENDER_SERVER;
  static const Id TEAMRENDER_CLIENT;
  static const Id CINEMA4D;
  static const Id COMMANDLINE;
  static const Id CINEWARE;
  static const Id PYTHON;
  static const Id PYTHON3;
}

taggedbaseref.h

template <typename T, typename HANDLER, typename TAG, Int TAG_BITS, TAG DEFAULT_VALUE = TAG(0), Bool ENABLE_POINTER_CONVERSION = true> class TaggedBaseRef
{
  void Reset();
};

timer.h

class TimerInterface
{
  template <typename FN> static MAXON_FUNCTION ResultMemT<TimerRef> AddPeriodicTimer(TimeValue interval, FN&& job, JobQueueInterface* queue);
  // Changed to
  template <typename FN> static MAXON_FUNCTION Result<TimerRef> AddPeriodicTimer(TimeValue interval, FN&& job, JobQueueInterface* queue);
 
  template <typename FN> static MAXON_FUNCTION ResultMemT<TimerRef> AddOneShotTimer(TimeValue delay, FN&& job, JobQueueInterface* queue);
  // Changed to
  template <typename FN> static MAXON_FUNCTION Result<TimerRef> AddOneShotTimer(TimeValue delay, FN&& job, JobQueueInterface* queue);
};

treemap.h

template <typename K, typename V, typename MAP = HashMapSelector<>, Bool COW = false> class TreeMap : public TreeMapParent<TreeMap<K, V, MAP, COW>, COW>
{
  TreeMap* FindChild(const K& key)
};

tuple.h

template <UInt32 INDEX, UInt32 PRE_OFFSET, UInt32 PRE_MAX_ALIGN, UInt64 SZ_ALIGN, UInt64... REST> class TupleStorageLayout<INDEX, PRE_OFFSET, PRE_MAX_ALIGN, SZ_ALIGN, REST...> : public TupleStorageLayout<INDEX + 1, UInt32(Align(PRE_OFFSET, UInt32(SZ_ALIGN >> 33))) + UInt32(SZ_ALIGN), Max(PRE_MAX_ALIGN, UInt32(SZ_ALIGN >> 33)), REST...>
{
  static Int GetOffset(typename std::integral_constant<UInt32, INDEX>::type*)
};
 
template <typename... T> class TupleStorage : public TupleStorageBase<And<std::is_default_constructible<T>::value...>::value, And<std::is_trivially_destructible<T>::value...>::value, T...>
{
    static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*);
 
  }
 
  template <typename T1, typename T2> class TupleStorage<T1, T2>
{
    static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*);
}
 
template <typename T1, typename T2, typename T3> class TupleStorage<T1, T2, T3>
{
    static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*);
}
 
template <typename T1, typename T2, typename T3, typename T4> class TupleStorage<T1, T2, T3, T4>
{
    static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 3>::type*);
}
 
template <typename T1, typename T2, typename T3, typename T4, typename T5> class TupleStorage<T1, T2, T3, T4, T5>
{
  static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 3>::type*);
  static Int GetOffset(typename std::integral_constant<UInt32, 4>::type*);
}
 
template <typename T1> class TupleStorage<T1, UnitType>
{
  static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*) { return 0; }
  static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*) { return 0; }
}
 
template <> class Tuple<>
{
  // Removed
  Tuple() { }
  Tuple(const Tuple&) { }
  Tuple(Tuple&&) { }
};

url.h

namespace URLFLAGS
{
  MAXON_ATTRIBUTE(DataDictionary, HTTP_ADDITIONAL_REQUEST_HEADER, "net.maxon.url.http_additional_request_header");
  MAXON_ATTRIBUTE(DataDictionary*, HTTP_RESPONSE_HEADER, "net.maxon.url.http_response_header");
  MAXON_ATTRIBUTE(Bool, HTTP_FOLLOWMOVEDFILES, "net.maxon.url.http_followmovedfiles");
  MAXON_ATTRIBUTE(Bool, HTTP_POST, "net.maxon.url.http_post");
  MAXON_ATTRIBUTE(CString, HTTP_POSTDATA, "net.maxon.url.http_postdata");
  MAXON_ATTRIBUTE(Bool, HTTP_NO_PROXY_CACHING, "net.maxon.url.http_no_proxy_caching");
  MAXON_ATTRIBUTE(Bool, HTTP_DISALLOW_GZIP, "net.maxon.url.http_disallow_gzip");
};

vector4d.h

MAXON_ATTRIBUTE_FORCE_INLINE ColorA BlendColor(const ColorA& col1, const ColorA& col2, const Float blendValue);
MAXON_ATTRIBUTE_FORCE_INLINE Float GetPerceivedBrightness(const ColorA& color);
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsColorPerceivedAsDark(const ColorA& color);

viewiterator.h

struct ViewIteratorMember;
struct MemberMap;
class GenericContainerInterface;

weakref.h

struct WeakRefTargetBase
{
  const void* GetCurrent() const;
  void Swap(const void* oldTarget, const void* newTarget);

weakrefservices.h

enum class MEMORY_OBSERVER_FLAGS : Int;
enum class MEMORY_OBSERVER_STATE : Int;
 
template <typename REFERENCE> class FatWeakRef;

apibaseid.h

class LiteralId
{
  LiteralId(const LiteralId&) = default;
  MAXON_IMPLICIT LiteralId(const Id&) = delete;
 
  LiteralId& operator =(const LiteralId&) = default;
  LiteralId& operator =(const Id&) = delete
 
  operator const Id&() const
 
  template <UInt N> constexpr LiteralId(bool dummy, const Char (&str)[N]) : _value(str), _hash(GetHashCode<N>(str))
  constexpr LiteralId(bool dummy, const LiteralId& src) : _value(src._value), _hash(src._hash)
  template <typename T, typename = typename T::DeclarationHelper> constexpr LiteralId(bool dummy, const T& decl) : LiteralId(T::DeclarationHelper::GetId())
};
 
class Id
{
  // Removed
  template <typename T, typename = typename T::DeclarationHelper> explicit Id(const T& ref) : Id(ref.GetId())
 
  ResultMem Init(const Block<const Char>& str);
}

apibasemath.h

MAXON_ATTRIBUTE_FORCE_INLINE Float32 Exp2(Float32 val);
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Exp2(Float64 val);

classhelpers.h

#define MAXON_COPYFROM_MEMBERS(...)
#define MAXON_OPERATOR_COPYFROM(T, ...)
#define MAXON_STRUCT_TUPLE(T, ...)
#define MAXON_MEMBER_ACCESSORS(T, M, ...)

debugdiagnostics.h

#define DiagnosticVarOutput(...)

newobj.h

template <Bool IS_DELETABLE> class ForwardFree;
template <> class ForwardFree<true>;
 
template <typename T> class NewObjHelper
// Changed to
template <typename T> class NewDelete

resultbase.h

template <typename T> class ResultOk
{
  // Removed
  T& GetValue()
 
  const T& UncheckedGetValue() const &
 
  MAXON_MEMBER_ACCESSORS(T, GetValue);
 
  MAXON_MEMBER_ACCESSORS(T, UncheckedGetValue);
};
 
template <typename T> class ResultOk<T&>
{
  operator T&() const;
};
 
template <typename T> class MAXON_WARN_UNUSED_CLASS ResultMemT
{
  const T& GetValue() const;
  // Changed to
  const T& GetValue() const &;
 
  const T& UncheckedGetValue() const;
  // Changed to
  const T& UncheckedGetValue() const &;
 
  MAXON_MEMBER_ACCESSORS(T, GetValue);
 
  MAXON_MEMBER_ACCESSORS(T, UncheckedGetValue);
 
  // Removed
  T& GetValue();
};
 
template <typename T> class ResultBase
{
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValue() const;
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValue() const &;
 
  // Removed
  MAXON_ATTRIBUTE_FORCE_INLINE T& GetValue();
 
  MAXON_ATTRIBUTE_FORCE_INLINE const T& UncheckedGetValue() const
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValue() const &
 
  MAXON_MEMBER_ACCESSORS(T, GetValue);
 
  MAXON_MEMBER_ACCESSORS(T, UncheckedGetValue);
 
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValueAndError(ThreadReferencedError& error) const;
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValueAndError(ThreadReferencedError& error) const &;
 
  MAXON_ATTRIBUTE_FORCE_INLINE T&& MoveValueGetError(ThreadReferencedError& error);
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE T GetValueAndError(ThreadReferencedError& error) &&;
 
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValueAndError(Error& error) const;
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE const T& GetValueAndError(Error& error) const &;
 
  MAXON_ATTRIBUTE_FORCE_INLINE T&& MoveValueGetError(Error& error);
  // Changed to
  MAXON_ATTRIBUTE_FORCE_INLINE T GetValueAndError(Error& error) &&;
};
 
template <typename T, typename ENABLE> class ResultSuper;
// Changed to
template <typename RESULT_TYPE, typename ENABLE> class ResultSuper;
 
template <typename T> class ResultSuper<T&, typename SFINAEHelper<void, typename T::template ResultFunctions<ResultBase<T&>>>::type>
// Changed to
template <typename RESULT_TYPE> class ResultSuper<RESULT_TYPE&, typename SFINAEHelper<void, typename RESULT_TYPE::template ResultFunctions<ResultBase<RESULT_TYPE&>>>::type>
 
template <typename T> class MAXON_WARN_UNUSED_CLASS Result : public ResultSuper<T, void>::type
// Changed to
template <typename RESULT_TYPE> class MAXON_WARN_UNUSED_CLASS Result : public ResultSuper<RESULT_TYPE, void>::type

command.framework

commandbase.h

class CommandTuple;
 
class CommandDataInterface
{
  MAXON_FUNCTION Result<COMMANDRESULT> Invoke(const Id& command, Bool interactive, const SetParameters& setParameters);
  MAXON_FUNCTION Result<COMMANDRESULT> Invoke(const CommandClass& command, Bool interactive, const SetParameters& setParameters);
};
 
class LegacyCommandDataInterface
{
  MAXON_METHOD Result<Generic*> GetLegacyData();
  // Changed to
  MAXON_METHOD Result<Generic*> GetLegacyData(Int index);
 
  MAXON_METHOD Result<void> SetLegacyData(const Generic* data);
  // Changed to
  MAXON_METHOD Result<void> SetLegacyData(const Generic* data, Int index);
 
  MAXON_METHOD Int GetLegacyDataCount() const;
 
  template<typename LEGACYDATA> MAXON_FUNCTION Result<LEGACYDATA&> GetLegacyData();
  // Changed to
  template<typename LEGACYDATA> MAXON_FUNCTION Result<LEGACYDATA&> GetLegacyData(Int index)
 
  template<typename LEGACYDATA> MAXON_FUNCTION Result<void> SetLegacyData(const LEGACYDATA& data);
  // Changed to
  template<typename LEGACYDATA> MAXON_FUNCTION Result<void> SetLegacyData(const LEGACYDATA& data, Int index);
};
 
class CommandDescriptionClassInterface;
class CommandConversionClassInterface;

crypt.framework

cryptography_hash.h

Result<Tuple<String, String>> HashPasswordWithSalt(const String& password, const StreamConversionFactory& hashClass = StreamConversions::HashSHA256());

cryptography_ssl.h

class SSLInterface
{
  static MAXON_METHOD Result<Bool> VerifySignature(const Block<const Char>& publicKey, const Block<const Char>& messageHash, const Block<const Char>& message);
  static MAXON_METHOD Result<void> CreateSignature(const Block<const Char>& privateKey, BaseArray<Char>& messageHash, const Block<const Char>& message);
};

geom.framework

lib_geom.h has been renamed to geometryutils.h.

exactpredicates2d.h

class ExactPredicates2DInterface;

geomconstants.h

class GeomConstants;

geometryutils.h

class DegeneratedInputErrorInterface;
class GeometryUtilsInterface;

simplemesh.h

template <typename T> class Poly;
MAXON_DATATYPE(SimplePolygon, "net.maxon.geom.simplepolygon");
MAXON_DATATYPE(UVWPolygon, "net.maxon.geom.uvwpolygon");
class SimpleMeshObject;

image.framework

gfx_basictypes.h

// Removed
template <typename T> struct DrawPoint;
 
template <typename T> struct DrawDimension
{
  MAXON_IMPLICIT DrawDimension(const Vec2<T, 1>& src);
};
 
template <typename T> struct DrawRect
{
  DrawRect(Vec2<T,1> positionValue, DrawDimension<T> sizeValue);
  DrawRect(T x, T y, T w, T h);
  MAXON_IMPLICIT DrawRect(const Range<Vec2<T, 1>>& src);
};

gfx_image.h

struct ImageHierarchy;
 
class ImageBaseInterface : MAXON_INTERFACE_BASES(DataDictionaryObjectInterface, HierarchyObjectInterface)
// Changed to
class ImageBaseInterface : MAXON_INTERFACE_BASES(DataDictionaryObjectInterface, HierarchyObjectInterface<ImageHierarchy>)

mediasession_stream.h

class MediaStreamInterface : MAXON_INTERFACE_BASES(MediaBaseInterface, HierarchyObjectInterface)
// Changed to
class MediaStreamInterface : MAXON_INTERFACE_BASES(MediaBaseInterface, HierarchyObjectInterface<DefaultHierarchy<MediaStreamRef>>)

math.framework

apibasemath_extension.h

MATH_HELPER_INSTANTIATE(Exp2);

gradient.h

enum class GRADIENT_INTERPOLATION_TYPE
{
  CUBICBIAS
};

polynomsolver.h

template <typename T> class PolynomSolver;

splinemapper.h

enum class SPLINEMAPPER_KNOT_INTERPOLATION_TYPE;
enum class SPLINEMAPPER_KNOT_FLAGS;
struct SplineMapperKnot;
enum class SPLINEMAPPER_SPLINE_TYPE;
enum class SPLINEMAPPER_RANGE_STATE;
class SplineMapperInterface;

mesh_misc.framework

mesh_attribute_base.h

#define MAXON_CUSTOMDATATAG(pluginID, name, resurceID, displayID, level, floatValueCount)
// Changed to
#define MAXON_CUSTOMDATATAG(pluginID, name, resurceID, displayID, level, floatValueCount, flags)
 
class CustomDataTagClassInterface 
{
  MAXON_METHOD Int32 GetTagPluginFlags() const;
};

misc.framework

The container.h and listview.h header files were removed.

graph_basics.h

enum class PORT_DIR;

io.h

class IoDocument
{
  static MAXON_METHOD Result<void> ReadDocument(const InputStreamRef& stream, const Id& id, const DataPtr&, IOFORMAT format, const DataDictionary& dict);
  // Changed to
  static MAXON_METHOD Result<void> ReadDocument(UrlOrInputStream&& urlOrStream, const Id& id, const DataPtr&, IOFORMAT format, const DataDictionary& dict);
};

profiler.h

class Profiler
{
  MAXON_METHOD Bool GetDebugDumpEnabled();
  MAXON_METHOD void SetDebugDumpEnabled(Bool state);
 
  MAXON_METHOD void OutputString(String& string);
 
  MAXON_METHOD void OutputStringReport(const String& headerString, Bool outputToConsole, Bool outputDebugDump = false);
  // Changed to
  MAXON_METHOD void OutputStringReport(const String& headerString);
};
 
#define PROFILER_START(enable)
#define PROFILER_STOP_AND_REPORT(...)

profiler_disabled.h

#define PROFILER_DISABLED
 
#define PROFILER_START(...)
#define PROFILER_STOP_AND_REPORT(...)

ruleparser.h

class ParseHelper
{
  static MAXON_METHOD Result<void> ConvertTextToLines(const BaseArray<Utf32Char>& in, BaseArray<String>& out, Bool allowBackSlashToJoinNextLine);
};

timestamp.h

class ExecutionTime
{
  void operator ++();
  // Changed to
  ExecutionTime& operator ++();
};

network.framework

network_oauth.h

enum class OAUTHERRORCODE;
 
class UrlRedirectInterface;
 
class NetworkOAuthSessionInterface
{
  MAXON_METHOD Result<String> InitV2Session(const Url& authUrl, const Url& tokenUrl, const String& account, const CString& appKey, const CString& appSecret,
  Bool forceReapprovement,
  const Delegate<Result<void>(const NetworkOAuthSessionRef& session, const Url& url)>& askForApproval,
  const Delegate<Result<String>(const NetworkOAuthSessionRef& session)>& verifyAccountName);
  // Changed to
  MAXON_METHOD Result<String> InitV2Session(const Url& authUrl, const Url& tokenUrl, const Url& redirectUrl, const String& account,
  const CString& appKey, const CString& appSecret, const CString& scope, Bool forceReapprovement, Bool allowRedirectServer,
  const UrlRedirectRef& redirectRef, const Delegate<Result<void>(const NetworkOAuthSessionRef& session, const Url& url)>& askForApproval,
  const Delegate<Result<String>(const NetworkOAuthSessionRef& session, const DataDictionary& response)>& verifyAccountName);
 
 
  MAXON_METHOD Result<DataDictionary> ReadJson(const Url& url, OAUTHHTTPMETHOD httpMethod) const;
  // Changed to
  MAXON_METHOD Result<BaseArray<DataDictionary>> ReadJson(const Url& url, OAUTHHTTPMETHOD httpMethod, const StringDecodingRef& stringDecoding) const;
 
  MAXON_METHOD Result<BaseArray<DataDictionary>> ReadJWT(const Url& url, OAUTHHTTPMETHOD httpMethod, const StringDecodingRef& stringDecoding, const Block<const Char>& publicKey, BaseArray<Char>* originalToken) const;
 
  MAXON_METHOD CString GetAccessToken() const;
  MAXON_METHOD CString GetRefreshToken() const;
  MAXON_METHOD Result<Url> GetOAuthTokenUrl(const String& account) const;
};

network_strings.h

namespace NETWORK
{
  namespace GLOBALSTRINGS
}

network_url.h

enum class HTTPMETHOD;
namespace URLFLAGS;

network_webserver.h

class NetworkWebServerInterface
{
  MAXON_METHOD Result<void> Init(const NetworkIpAddrPort& serverIpAndPort, const String& serverName);
  // Changed to
  MAXON_METHOD Result<void> Init(Bool useSSL, const NetworkIpAddrPort& serverIpAndPort, const String& serverName);
 
  MAXON_METHOD Bool IsUsingSSL() const;
 
  MAXON_METHOD Result<void> RegisterRequest(const String& file, HandleRequestDelegate&& requestDelegate);
 
  MAXON_METHOD Result<CString> CreateRequestHeader(Bool isPost, const UrlScheme& proxyScheme, Bool allowGzip, const String& hostName, const String& fileName, const String& queryParameter, const Range<Int64>& range, const DataDictionary& optionalTags = DataDictionary(), const Block<const Char>& postData = Block<const Char>()) const;
  // Changed to
  MAXON_METHOD Result<CString> CreateRequestHeader(HTTPMETHOD method, const UrlScheme& proxyScheme, Bool allowGzip, const String& hostName,
  const String& fileName, const String& queryParameter, const Range<Int64>& range, const DataDictionary& optionalTags = DataDictionary(),
  const Block<const Char>& postData = Block<const Char>()) const;
};

network_ip.h

class NetworkTimeoutErrorInterface;

volume.framework

volume.h

class VolumeInterface
{
  MAXON_INTERFACE(VolumeInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.volume");
  // Changed to 
  MAXON_INTERFACE(VolumeInterface, MAXON_REFERENCE_COPY_ON_WRITE, "net.maxon.volume.interface.volume");
 
  MAXON_INTERFACE_SINGLE_IMPLEMENTATION
 
  static MAXON_METHOD Result<Volume> CreateFromFile(const Url& url, Float scale, Int gridIndex);
 
  MAXON_METHOD Result<void> WriteToFile(const Url& url, Float scale, const DataDictionary& metaData = DataDictionary());
  // Changed to
  MAXON_METHOD Result<void> WriteToFile(const Url& url, Float scale, const DataDictionary& metaData = DataDictionary()) const;
 
  MAXON_METHOD void SetGridTransform(Matrix newTransform) const;
  // Changed to
  MAXON_METHOD void SetGridTransform(Matrix newTransform);
 
  MAXON_METHOD Range<Float> GetMinMaxValues(Bool includeBackground = false) const;
};

volumeaccessors.h

class GridAccessorInterface
{
  MAXON_METHOD Result<void> InitWithWriteAccess(Volume& volumeObject, VOLUMESAMPLER sampler = VOLUMESAMPLER::NEAREST);
};

volumecommands.h

struct VolumeCommandData
{
  SplineData* splineData;
};

volumeiterators.h

enum class TREEVOXELLEVEL;
 
class GridIteratorInterface
{
  MAXON_METHOD TREEVOXELLEVEL GetVoxelLevel() const;
};

volumetools.h

enum class POLYGONCONVERSIONFLAGS;
enum class VECTORFILTERTYPE;
 
struct FilterSettings
{
  Float invertPoint
};
 
class VolumeToolsInterface
{
  static MAXON_METHOD Result<VolumeRef> MeshToVolume(const Block<Vector>& vertices, const Block<VolumeConversionPolygon>& polygons, Matrix polygonObjectMatrix, Float gridSize, Int32 bandWidthInterior, Int32 bandWidthExterior, const ThreadRef& thread, const Matrix* creationTransform = nullptr);
  // Changed to
  static MAXON_METHOD Result<Volume> MeshToVolume(const Block<Vector>& vertices, const Block<VolumeConversionPolygon>& polygons, Matrix polygonObjectMatrix, Float gridSize, Int32 bandWidthInterior, Int32 bandWidthExterior, const ThreadRef& thread, POLYGONCONVERSIONFLAGS conversionSettings = POLYGONCONVERSIONFLAGS::NONE, const Matrix* creationTransform = nullptr);
 
  static MAXON_METHOD Result<Volume> MixVectorVolumes(const Volume& volumeOne, const Volume& volumeTwo, MIXVECTORTYPE type);
  static MAXON_METHOD Result<Volume> ConvertFieldsToVectorVolume(FieldSampleData& fieldData, Float gridSize, const Range<Vector>& sampleBox, const ThreadRef& thread, const Volume* volumeReference = nullptr, const Matrix* creationTransform = nullptr);
  static MAXON_METHOD Result<Volume> NormalizeVectorVolume(const Volume& volume, const ThreadRef& thread);
  static MAXON_METHOD Result<Volume> CreateCurlVolume(const Volume& volume, const ThreadRef& thread);
  static MAXON_METHOD Result<Volume> CreateMeanCurvatureVolume(const Volume& volume, const ThreadRef& thread);
  static MAXON_METHOD Result<Volume> RotateVectorVolume(const Volume& volume, const Vector& rotationAxis, const Float angle, const ThreadRef& thread, FieldSampleData* maskField = nullptr);
  static MAXON_METHOD Result<Volume> ConvertVectorToFog(const Volume& volume, const ThreadRef& thread);
  static MAXON_METHOD Result<Volume> BlendVolumes(const Volume& volumeA, const Volume& volumeB, const Float blendValue, const ThreadRef& thread);
};

API Changes in R21.026

crypt.framework

cryptography_ssl.h

class SSLInterface
{
  static MAXON_METHOD int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
};

network.framework

network_ip_ssl.h

namespace URLFLAGS
{
  MAXON_ATTRIBUTE(Url, USECUSTOMCLIENTCERTIFICATE, "net.maxon.url.usecustomclientcertificate");
}

API Changes in R21.115

cinema.framework

c4d_file.h

class HyperFile
{
  SCENEFILTER GetFilterFlags() const;
};

ge_prepass.h

enum class RENDERFLAGS
{
  RENDERQUEUEERRORS
};

customgui_inexclude.h

#define IN_EXCLUDE_FLAG_NO_RESIZABLE

lib_ca.h

class CAWeightTag
{
  Bool ResetBindPose(BaseDocument *doc, Bool doUndo);
  Bool SetBindPose(BaseDocument *doc, Bool doUndo);
};

core.framework

matrix.h

template <typename V> struct Mat3
{
  friend Mat3 Min(const Mat3& a, const Mat3& other);
  friend Mat3 Max(const Mat3& a, const Mat3& other);
}

streamconversion.h

namespace BASE64_OPTIONS
{
  MAXON_ATTRIBUTE(Bool, DISABLE_PADDING, "net.maxon.streamconversion.base64.disable_padding");
}

stringencoding.h

MAXON_DECLARATION_STRINGENCODING("urlqueryparam", UrlQueryParameter)

geom.framework

geomconstants.h

class GeomConstants
{
  static constexpr Float EPSILON6;
  static constexpr Float EPSILON16;
};

geometryutils.h

class GeometryUtilsInterface
{
  static MAXON_METHOD Float CalculateSignedTriangleArea(const Vector& a, const Vector& b, const Vector& c, const Vector& normal);
  static MAXON_METHOD Result<void> CalculateMeanValueCoordinatesWeights(const Vector& point, const Block<const Vector>& outline, const Vector& normal, WritableArrayInterface<Float>& weights);
};

math.framework

apibasemath_extension.h

template <> class LIMIT<Matrix32>;
template <> class LIMIT<Matrix64>;

gradientmath.h

struct IndexedGradientKnot;
class SortedGradientKnots;
class IndexedGradientSample;

misc.framework

formulaparser.h

class FormulaParserInterface
{
  MAXON_METHOD Result<void> AddDataVariable(const String& name, Data* val, Bool caseSensitive);
};

API Changes in R21.207

cinema.framework

c4d_gui.h

class ProgressThread : public C4DThread
{
  Bool Start(ProgressDialog* pdlg);  // internal
  void End();                        // internal
};