API Change List in R23

API Changes in R23.110

cinema.framework

c4d_customgui/customgui_bitmapbutton.h

{
void *data;
// changed to
void* data = nullptr;
void (*ShowPopup)(void *data);
// Changed to
void (*ShowPopup)(void* data) = nullptr;
}

c4d_customgui/customgui_listview.h

{
// Changed to
}
{
virtual String GetNameForEdit(void* root, void* userdata, void* obj);
}
{
String GetNameForEdit(TreeViewFunctions* pFuncs, void* root, void* userdata, void* obj);
}
struct InternalFunctionTable
{
/*57*/ String (TreeViewF::*GetNameForEdit)(TreeViewFunctions* pFuncs, void* root, void* userdata, void* obj);
}

c4d_libs/lib_paint.h

class PaintView
{
}
struct PaintLibrary : public C4DLibrary
{
Bool(iPaintView::* GetShowMeshWireframe)(Bool& showMesh);
Bool(iPaintView::* SetShowMeshWireframe)(Bool showMesh);
}

description/arprefs.h removed.

description/deltamushbase.h removed.

description/dmline.h removed.

description/dpathlist.h removed.

description/fdecay.h removed.

description/fdelay.h removed.

description/fobjexport.h removed.

description/fobjimport.h removed.

description/fribexport.h removed.

description/Fstepexport.h removed.

description/ftime.h removed.

description/mrenderman.h removed.

description/odirectdeltamushdeformer.h removed.

description/ofracture.h removed.

description/omotioncapture.h removed.

description/osplinetovolume.h removed.

description/prefscineman.h removed.

description/prefsgpurenderer.h removed.

description/prefsmetricspreferences.h removed.

description/prefsphprefs.h removed.

description/Sclient.h removed.

description/Sgroup.h removed.

description/shrenderman.h removed.

description/Smodul.h removed.

description/Sserial.h removed.

description/tfloat.h removed.

description/toolmeshtovolume.h removed.

description/toolsculptbrushmulti.h removed.

description/toolsculptbrushpolish.h removed.

description/toolsculptbrushproject.h removed.

description/toolvolumeremesher.h removed.

description/tspooldummy.h removed.

description/tvolume.h removed.

description/vpbloom.h removed.

description/vprenderman.h removed

description/falembicexport.h

// Removed
ABCEXPORT_FORMAT = 1024,
ABCEXPORT_FORMAT_HDF5_LEGACY = 0,
ABCEXPORT_FORMAT_OGAWA = 1,

c4d_basedocument.h

class BaseSceneHook : public BaseList2D
{
// Changed to
void Draw(BaseDocument* doc, BaseDraw* bd, BaseDrawHelp* bh, BaseThread* bt, SCENEHOOKDRAW flags);
}
struct LayerData
{
{
solo = false;
}
}

c4d_basedraw.h

class DrawportContextRef;
class BaseDraw : public BaseView
{
void GetDrawportContext(maxon::DrawportContextRef& context) const
}

c4d_painter.h

// Deprecated use GetUVSeams2
const EdgeBaseSelect* GetUVSeams2(const BaseObject* obj, Bool checkUVSettings = false);

ge_prepass.h

{
IMPORTER = (1 << 0)
}
{
NO_DEPTH_CORRECTION = (1 << 7),
}

operatingsystem.h

class DrawportContextRef;
Bool (BaseSceneHook::*InitDisplayControlEx)(BaseSceneHook *node, BaseDocument* doc, BaseDraw* bd, const AtomArray* active);
void (BaseSceneHook::*Draw)(BaseDocument* doc, BaseDraw* bd, BaseDrawHelp* bh, BaseThread* bt, SCENEHOOKDRAW flags);
void (*GetDrawportContext)(const BaseDraw* bd, maxon::DrawportContextRef& context);
const EdgeBaseSelect* (*GetUVSeams2)(const BaseObject* obj, Bool checkUVSettings);

core.framework

math/col.h

template <typename T, Int STRIDE = 1> struct Col3
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

math/col4.h

template <typename T, Int STRIDE = 1> struct Col4
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

math/vec.h

template <typename T, Int STRIDE = 1> struct Vec3
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

math/vec2.h

template <typename T, Int STRIDE = 1> struct Vec2
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

math/vec4.h

template <typename T, Int STRIDE = 1> struct Vec4
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

utilities/apibaseid.h

class LiteralId
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

utilities/defaultdoc.h

class DefaultDoc
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

utilities/sseconversion.h added.

enum class VALUEKIND : UInt64
{
}

array.h

template <typename ARRAY> class ArrayImpl
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

basebitset.h

template <typename ALLOCATOR = DefaultAllocator> class BaseBitSet
{
static Result<void> DescribeIO(const DataSerializeInterface& stream)
}

bytesvalue.h

class BytesValue
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

collection.h

template <typename COLLECTION, typename SUPER> class BaseCollection : public SUPER
{
inline String ToString(const FormatStatement* formatStatement) const;
// Changed to
inline String ToString(const FormatStatement* formatStatement = nullptr) const;
}

containerbase.h

class GenericContainerInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

contiguousrangemap.h

template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class ContiguousRangeMap
{
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt) const
// Changed to
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt = nullptr) const
}

crc32c.h

class Crc32C
{
static const UInt32 UNSET_VALUE = 0;
}

datadescription.h

class DataDescriptionInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

datadescription_data.h

MAXON_ATTRIBUTE(Id, CLASSIFICATION, "net.maxon.description.data.info.classification",
RESOURCE_DEFINE(ENUM_TYPE, Id("type")));

datadescriptiondatabase.h

class DataDescriptionDatabaseInterface
{
// Deprecated
static MAXON_METHOD Result<BaseArray<Tuple<Id, Data, String>>> GetEffectiveEnumList(const DataDictionary& dataEntry,
const DataDictionary& guiEntry, const DataDescription& stringDescription, Bool resolveExtensionPointsAndGui,
const AssetRepositoryRef& repository, const Data* filterData);
static MAXON_METHOD Result<BaseArray<Tuple<Id, Data, String>>> GetEffectiveEnumList(const DataDictionary& dataEntry,
const DataDictionary& guiEntry, const DataDescription& stringDescription, Bool resolveExtensionPointsAndGui,
Bool withStrings, const LanguageRef& language, const AssetRepositoryRef& repository, const Data* filterData);
}

datadictionary.h

class DataDictionaryInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

dataserialize.h

struct IDENT_VOID
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

datatype_builder.h

struct DataTypeComponent
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

datatypebase.h

class DataTypeImpl
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class DataTypeImpl::Instantiated : public DataTypeImpl
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class Data
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class class ConstDataPtr
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

datatypebase.h

class InternedId
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
struct Member
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

datetime.h

class LocalDateTime
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class UniversalDateTime
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

foreach.h

template <typename ITERATOR, typename SUPER = EmptyClass> class ForEachIterator : public SUPER
{
inline String ToString(const FormatStatement* formatStatement) const;
// Changed to
inline String ToString(const FormatStatement* formatStatement = nullptr) const;
}

hashmap.h

class Entry : public HashMapEntryBase<K, V, Entry, ENTRY_HANDLER>
{
typename SFINAEHelper<String, V>::type ToString(const FormatStatement* format) const
// Changed to
typename SFINAEHelper<String, V>::type ToString(const FormatStatement* format = nullptr) const
}
template <typename VALUEHASH> class Hash
{
typename SFINAEHelper<String, V>::type ToString(const FormatStatement* formatStatement) const
// Changed to
typename SFINAEHelper<String, V>::type ToString(const FormatStatement* formatStatement = nullptr) const
}

job.h

class JobInterface : protected JobInterfaceBase
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class JobStatusRef : public StrongRef<JobStatusInterface>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class JobRef : public StrongRef<JobInterface>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

jobgroup.h

class JobGroupInterface
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class JobGroupRef : public StrongRef<JobGroupInterface>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
template <typename T> class StaticJobGroupInterface : public JobGroupInterface
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
template <typename T> class StaticJobGroupRef : public StrongRef<StaticJobGroupInterface<T>>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

machine.h

class MachineInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

map.h

template <typename K, typename V> class MapInterface : public MapBase0<MapInterface<K, V>, K, V, EmptyClass, DefaultCompare>
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}
template <typename MAP> class MapImpl
: public std::conditional<STD_IS_REPLACEMENT(const, typename std::remove_reference<MAP>::type) || !STD_IS_REPLACEMENT(reference, MAP),
MapInterface<typename std::remove_reference<MAP>::type::KeyType, typename ConstIf<typename std::remove_reference<MAP>::type::ValueType, STD_IS_REPLACEMENT(const, typename std::remove_reference<MAP>::type)>::type>,
NonConstMap<typename std::remove_reference<MAP>::type::KeyType, typename std::remove_reference<MAP>::type::ValueType>>::type
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

matrix.h

template <typename V> struct SqrMat3
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
template <typename V> struct Mat3
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

matrix2d.h

template <typename V> struct SqrMat2
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
template <typename V> struct Mat2
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

matrix4d.h

template <typename V> struct SqrMat4
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

multiindex.h

template <typename INT_TYPE> class MultiIndex
{
String ToString(const FormatStatement* fmt) const;
// Changed to
String ToString(const FormatStatement* fmt = nullptr) const;
}

objectbase.h

class InterfaceReference
{
String ToString(const FormatStatement* fs) const
// Changed to
String ToString(const FormatStatement* fs = nullptr) const
}
class ComponentDescriptor
{
String ToString(const FormatStatement* fs) const
// Changed to
String ToString(const FormatStatement* fs = nullptr) const
}
class ClassInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class ObjectInterface : protected ObjectSuper
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

optional.h

template <typename T>
class Opt
{
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format) const
// Changed to
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format = nullptr) const
}

parametertype.h

class ParameterType
{
String ToString(const FormatStatement* fmt) const;
// Changed to
String ToString(const FormatStatement* fmt = nullptr) const;
}

range.h

template <typename T> class Range
{
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format) const
// Changed to
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format = nullptr) const
}

rangemap.h

template <typename K> struct RangeSetPair
{
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt) const
// Changed to
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt = nullptr) const
}
template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class RangeMap
{
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt) const
// Changed to
typename SFINAEHelper<String, K>::type ToString(const FormatStatement* fmt = nullptr) const
}

refcount_hashmap.h

template <typename K, typename V, typename HASH = DefaultCompare, typename HANDLER = RefCountHashMapDefaultHandler> class RefCountHashMap
{
String ToString(const FormatStatement* fmt) const
// Changed to
String ToString(const FormatStatement* fmt = nullptr) const
}
class EntryRef
{
String ToString(const FormatStatement* fs) const
// Changed to
String ToString(const FormatStatement* fs = nullptr) const
}

reflectionbase.h

class Member
{
MAXON_METHOD String ToString(const FormatStatement* fs) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* fs = nullptr) const;
}

set.h

template <typename TYPE> class SetInterface : public SetBase0<SetInterface<TYPE>, TYPE, EmptyClass, DefaultCompare>
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}
template <typename SET> class SetImpl
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

streamconversion.h

struct ConversionTestSet
{
String ToString(const FormatStatement* format) const
// Changed to
String ToString(const FormatStatement* format = nullptr) const
}

string.h

class StringInterface : public StringTemplate<StringInterface, String, Utf32Char>
{
inline String ToString(const FormatStatement* formatStatement) const;
// Changed to
inline String ToString(const FormatStatement* formatStatement = nullptr) const;
}
class CStringInterface : public StringTemplate<CStringInterface, CString, Char>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

stringresource.h

class LanguageInterface
{
// Changed to
MAXON_METHOD String ToString(const maxon::FormatStatement* fs = nullptr) const;
}

taggedbaseref.h

template <typename T, typename HANDLER, typename TAG, Int TAG_BITS, TAG DEFAULT_VALUE = TAG(0), Bool ENABLE_POINTER_CONVERSION = true> class TaggedBaseRef
{
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format) const
// Changed to
typename SFINAEHelper<String, T>::type ToString(const FormatStatement* format = nullptr) const
}

thread.h

class ThreadInterface : public JobInterface
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}
template <typename INTERFACE> class ThreadRefTemplate : public StrongRef<INTERFACE>
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

timevalue.h

class TimeValue
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

treemap.h

template <typename K, typename V, typename MAP = HashMapSelector<>, Bool COW = false> class TreeMap : public TreeMapParent<TreeMap<K, V, MAP, COW>, COW>
{
String ToString(const FormatStatement* fs) const
// Changed to
String ToString(const FormatStatement* fs = nullptr) const
}

tuple.h

template <typename... T> class Tuple : public maxon::details::TupleStorage<T...>
{
typename SFINAEHelper<String, T...>::type ToString(const FormatStatement* format) const
// Changed to
typename SFINAEHelper<String, T...>::type ToString(const FormatStatement* format = nullptr) const
}
template <> class Tuple<>
{
const String& ToString(const FormatStatement*) const
// Changed to
const String& ToString(const FormatStatement* fmt = nullptr) const
}

units.h

class DimensionInterface
{
MAXON_METHOD String ToString(const FormatStatement* fs) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* fs = nullptr) const;
}
class UnitInterface
{
MAXON_METHOD String ToString(const FormatStatement* fs) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* fs = nullptr) const;
}

url.h

class UrlInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

uuid.h

class Uuid;
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

corenodes.framework

corenodes.h

struct PortInfo
{
String ToString(const FormatStatement* format) const
// Changed to
String ToString(const FormatStatement* format = nullptr) const
}
class CoreNodeBaseInterface
{
MAXON_FUNCTION String ToString(const FormatStatement* fmt) const { return GetId().ToString(fmt); }
// Changed to
MAXON_FUNCTION String ToString(const FormatStatement* fmt = nullptr) const { return GetId().ToString(fmt); }
}

corenodes_conversion.h

class ConversionSequence
{
String ToString(const FormatStatement* fs) const;
// Changed to
String ToString(const FormatStatement* fs = nullptr) const;
}

corenodes_helpers.h

class PortId
{
String ToString(const FormatStatement* fs) const;
// Changed to
String ToString(const FormatStatement* fs = nullptr) const;
}

corenodes_helpers.h

class IdBuilder
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

corenodes_instances.h

class CoreNodeInstanceBaseInterface
{
MAXON_FUNCTION String ToString(const FormatStatement* fmt) const
// Changed to
MAXON_FUNCTION String ToString(const FormatStatement* fmt = nullptr) const
}

crypt.framework

cryptography_key.h

class CryptoKeyInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

cryptography_ssl.h

class SSLInterface
{
//Deprecated
static MAXON_METHOD void ADD_thread_state();
//Deprecated
static MAXON_METHOD void SSL_load_error_strings();
//Deprecated
SSL_library_init
static MAXON_METHOD int OPENSSL_init_ssl();
//Deprecated
static MAXON_METHOD const SSL_METHOD* TLSv1_method(); /* TLSv1.0 */
//Deprecated
static MAXON_METHOD const SSL_METHOD* TLSv1_1_method(); /* TLSv1.1 */
//Deprecated
static MAXON_METHOD const SSL_METHOD* TLSv1_2_method(); /* TLSv1.2 */
//Deprecated
static MAXON_METHOD const SSL_METHOD* SSLv3_method(); /* SSLv3 */
//Deprecated
static MAXON_METHOD const SSL_METHOD* SSLv2_method(); /* SSLv2 */
//Deprecated
static MAXON_METHOD const SSL_METHOD* SSLv23_method(); /* SSLv3 but can rollback to v2 */
static MAXON_METHOD const SSL_METHOD* TLS_method();
}

geom.framework

celldata.h

struct CellEdge
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

geomconstants.h

class GeomConstants
{
static constexpr Float EPSILON_FLOAT = sizeof(Float) == sizeof(double) ? 2.2204460492503131e-016 : 1.192092896e-07F;
// Changed to
template <typename FLOATTYPE> static constexpr FLOATTYPE EPSILON_FLOAT = sizeof(FLOATTYPE) == sizeof(double) ? 2.2204460492503131e-016 : 1.192092896e-07F;
}

simplemesh.h

template <typename T> class Poly
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

image.framework

gfx_basictypes.h

template <typename T> struct DrawDimension
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
template <typename T> struct DrawRect
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

gfx_basictypes_3d.h

template <typename T> struct DrawPoint3d
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
template <typename T> struct DrawDimension3d
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
template <typename T> struct DrawVolume
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

gfx_image_bits.h

class BITS
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

gfx_image_colorprofile.h

{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

half.h

template <typename FLOAT32TYPE> class HalfFloat
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

math.framework

big_integer.h

class BigIntegerInterface
{
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Changed to
MAXON_METHOD String ToString(const FormatStatement* formatStatement = nullptr) const;
}

complex.h

template <typename T> class Complex
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

matrix_nxm.h

template <typename TYPE> class MatrixNxM
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

quaternion.h

template <typename ValueType> class Quaternion
{
String ToString(const FormatStatement* formatStatement) const;
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const;
}

splinemapper.h

struct SplineMapperKnot
{
static Result<void> DescribeIO(const DataSerializeInterface& stream)
}
MAXON_DATATYPE(SplineMapperKnot, "net.maxon.datatype.splinemapperknot");
class SplineMapperInterface
{
static MAXON_METHOD Result<void> DescribeIO(const DataSerializeInterface& stream);
}

mesh_misc.framework

mesh_attribute_utilities.h

template <typename T> class PolyData
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

misc.framework

timestamp.h

class TimeStamp
{
String ToString(const FormatStatement* fs) const
// Changed to
String ToString(const FormatStatement* fs = nullptr) const
}

network.framework

network_ip_addr.h

class NetworkIpAddrInterface
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
class NetworkIpAddrPortInterface : public NetworkIpAddrInterface
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
class NetworkIpAddr : public NetworkIpAddrInterface::Reference
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}
class NetworkIpAddrPort : public NetworkIpAddrPortInterface::Reference
{
String ToString(const FormatStatement* formatStatement) const
// Changed to
String ToString(const FormatStatement* formatStatement = nullptr) const
}

network_ip_ssl.h

{
// Removed
SSL3,
// Removed
SSL2,
// Removed
SSL23,
TLS
}

python.framework

vm.h

namespace VirtualMachines
{
// Removed
MAXON_DECLARATION(Class<VirtualMachineRef>, PyPy, "net.maxon.python.virtualmachine.pypy");
}

API Changes in R23.008

cinema.framework

c4d_customgui/customgui_bitmapbutton.h

#define BITMAPBUTTON_FORCE_SIZE_Y 'sizy' ///< ::Int32 Additionally forces the y size of the bitmap button. FORCE_SIZE is used for y size when not specified.

c4d_customgui/customgui_description.h

enum class AMFILTERFLAGS
{
SHOWKEYFRAMESEL = 1 << 4,
SHOWANIMATED = 1 << 5,
SHOWOVERRIDEN = 1 << 7,
}

c4d_customgui/customgui_filename_breadcrumb.h

#define BREADCRUMB_SLASH_CODE 10007 ///< ::Bool The string "_&s&_" is replaced with character "/"

c4d_customgui/customgui_linkbox.h

LINKBOX_NO_PICKER = 10003 ///< ::Bool No picker mode.

c4d_customgui/customgui_listview.h

#define TREEVIEW_CUSTOM_BG_COLOR 'cubg'
{
virtual Bool IsSelectable(void *root, void *userdata, void *obj);
void SetShowLines(Bool show);
Bool GetShowLines() const;
}

c4d_libs/lib_activeobjectmanager.h

enum class ACTIVEOBJECTMODE
{
}

c4d_libs/lib_browser.h

{
Int32 GetPluginID(String *plugin_name = 0) const;
// Changed to
Int32 GetPluginID(String *plugin_name = nullptr) const;
}
{
virtual Int32 GetPluginID(String *plugin_name = 0)
// Changed to
virtual Int32 GetPluginID(String *plugin_name = nullptr)
}
{
virtual UInt32 GetNodeFlags(Int64 *out_size = 0)
// Changed to
virtual UInt32 GetNodeFlags(Int64 *out_size = nullptr)
virtual Int32 NewFolder(Int32 mode, const String &name, SDKBrowserContentNodeRef *folder = 0)
// Changed to
virtual Int32 NewFolder(Int32 mode, const String &name, SDKBrowserContentNodeRef *folder = nullptr)
}
{
SDKBrowserURL GetNodeURL(UInt32 flags = 0, Int32 *idx = 0) const;
// Changed to
SDKBrowserURL GetNodeURL(UInt32 flags = 0, Int32 *idx = nullptr) const;
UInt32 GetNodeFlags(Int64 *out_size = 0) const;
// Changed to
UInt32 GetNodeFlags(Int64 *out_size = nullptr) const;
Int32 NewFolder(Int32 mode, const String &name, SDKBrowserContentNodeRef *folder = 0);
// Changed to
Int32 NewFolder(Int32 mode, const String &name, SDKBrowserContentNodeRef *folder = nullptr);
}
{
static SDKBrowserIcon *GetIcon(const SDKBrowserURL &url, SDKBrowserPluginRef plugin = 0, Int32 flags = 0, LocalFileTime *preview_time = 0);
// Changed to
static SDKBrowserIcon *GetIcon(const SDKBrowserURL &url, SDKBrowserPluginRef plugin = nullptr, Int32 flags = 0, LocalFileTime *preview_time = nullptr);
static Int32 PreviewDialogMisc(SubDialog *dlg, void *&private_data, Int32 cmd, Int32 value0 = 0, Int32 value1 = 0, void *value2 = 0, void *value3 = 0);
// Changed to
static Int32 PreviewDialogMisc(SubDialog *dlg, void *&private_data, Int32 cmd, Int32 value0 = 0, Int32 value1 = 0, void *value2 = nullptr, void *value3 = nullptr);
}

c4d_libs/lib_description.h

class DescID
{
// Removed
Int32 temp1;
Int32 *temp2;
std::aligned_storage<sizeof(maxon::BaseArray<DescLevel>), alignof(maxon::BaseArray<DescLevel>)>::type _private;
UInt GetHashCode() const;
// Changed to
}
struct DescriptionLib
{
UInt (*DescID_GetHashCode)(const DescID *d);
// Changed to
maxon::HashInt (*DescID_GetHashCode)(const DescID *d);
}

c4d_libs/lib_instanceobject.h

{
}
struct InstanceObjectLibrary
{
maxon::Block<const maxon::HashValue> (iInstanceObject::*GetInstancePersistentHashes)() const;
}

c4d_libs/lib_net.h

namespace maxon
{
class ThreadInterface;
}

c4d_libs/lib_prefs.h

#define PREFS_NODE_EDITOR 1055257
#define PREFS_PRI_NODE_EDITOR 10000095 ///< Node Editor.

c4d_libs/lib_tlmarker.h

// Changed to
BaseList2D* AddMarker(BaseDocument* doc, BaseList2D* pPred, BaseTime time, String name, maxon::Color color = maxon::Color(), BaseTime length = BaseTime(), LayerObject* obj = nullptr);
BaseList2D* (*AddMarker)(BaseDocument* doc, BaseList2D* pPred, BaseTime time, String name);
// Changed to
BaseList2D* (*AddMarker)(BaseDocument* doc, BaseList2D* pPred, BaseTime time, String name, maxon::Color color, BaseTime length, LayerObject* obj);

c4d_libs/lib_viewport.h

//Removed
class AtomArray;
//Removed
//Removed
class GeClipMap;

c4d_misc/utilities/apibasemath.h

// Changed to
static constexpr Float32 MINVALUE_FLOAT32
// Changed to
static constexpr Float32 MAXVALUE_FLOAT32
// Changed to
static constexpr Float64 MINVALUE_FLOAT64
// Changed to
static constexpr Float64 MAXVALUE_FLOAT64
// Changed to
// Changed to
// Changed to
// Changed to
// Changed to
static constexpr Float32 MINRANGE_FLOAT32
// Changed to
static constexpr Float32 MAXRANGE_FLOAT32
// Changed to
static constexpr Float64 MINRANGE_FLOAT64
// Changed to
static constexpr Float64 MAXRANGE_FLOAT64
static const Float MINVALUE_FLOAT
// Changed to
static constexpr Float MINVALUE_FLOAT
static const Float MAXVALUE_FLOAT
// Changed to
static constexpr Float MAXVALUE_FLOAT
static const Float MINRANGE_FLOAT
// Changed to
static constexpr Float MINRANGE_FLOAT
static const Float MAXRANGE_FLOAT
// Changed to
static constexpr Float MAXRANGE_FLOAT
template<> class LIMIT<Int64>
{
static const Int64 MIN
// Changed to
static constexpr Int64 MIN
static const Int64 MAX
// Changed to
static constexpr Int64 MAX
// Removed
static constexpr Int64 Min()
// Removed
static constexpr Int64 Max()
};
template<> class LIMIT<UInt64>
{
static const UInt64 MIN
// Changed to
static constexpr UInt64 MIN
static const UInt64 MAX
// Changed to
static constexpr UInt64 MAX
// Removed
static constexpr UInt64 Min()
// Removed
static constexpr UInt64 Max()
};
template<> class LIMIT<Int32>
{
static const Int32 MIN
// Changed to
static constexpr Int32 MIN
static const Int32 MAX
// Changed to
static constexpr Int32 MAX
// Removed
static constexpr Int32 Min()
// Removed
static constexpr Int32 Max()
};
template<> class LIMIT<UInt32>
{
public:
static const UInt32 MIN
// Changed to
static constexpr UInt32 MIN
static const UInt32 MAX
// Changed to
static constexpr UInt32 MAX
// Removed
static constexpr UInt32 Min()
// Removed
static constexpr UInt32 Max()
};
template<> class LIMIT<Int16>
{
public:
static const Int16 MIN
// Changed to
static constexpr Int16 MIN
static const Int16 MAX
// Changed to
static constexpr Int16 MAX
// Removed
static constexpr Int16 Min()
// Removed
static constexpr Int16 Max()
};
template<> class LIMIT<UInt16>
{
public:
static const UInt16 MIN
// Changed to
static constexpr UInt16 MIN
static const UInt16 MAX
// Changed to
static constexpr UInt16 MAX
// Removed
static constexpr UInt16 Min()
// Removed
static constexpr UInt16 Max()
};
template<> class LIMIT<Char>
{
public:
static const Char MIN
// Changed to
static constexpr Char MIN
static const Char MAX
// Changed to
static constexpr Char MAX
// Removed
static constexpr Char Min()
// Removed
static constexpr Char Max()
};
template<> class LIMIT<UChar>
{
public:
static const UChar MIN
// Changed to
static constexpr UChar MIN
static const UChar MAX
// Changed to
static constexpr UChar MAX
// Removed
static constexpr UChar Min()
// Removed
static constexpr UChar Max()
};
template<> class LIMIT<Float32>
{
public:
static constexpr Float32 Min()
// Changed to
static constexpr Float32 MIN
static constexpr Float32 Max()
// Changed to
static constexpr Float32 MAX
};
template<> class LIMIT<Float64>
{
public:
static constexpr Float64 Min()
// Changed to
static constexpr Float64 MIN
static constexpr Float64 Max()
// Changed to
static constexpr Float64 MAX
};
static const Int NOTOK
// Changed to
static constexpr Int NOTOK
static const Float64 PI
// Changed to
static constexpr Float64 PI
static const Float64 PI_INV
// Changed to
static constexpr Float64 PI_INV
static const Float64 PI2
// Changed to
static constexpr Float64 PI2
static const Float64 PI2_INV
// Changed to
static constexpr Float64 PI2_INV
static const Float64 PI05
// Changed to
static constexpr Float64 PI05

c4d_basedraw.h

class ImageRef;
class BaseDraw
{
Bool PointInRange(const Vector& p, Int32 x, Int32 y) const;
// Changed to
Bool PointInRange(const Vector& p, Int32 x, Int32 y, Float range = 10.0_f) const;
void GetViewportImage(maxon::ImageRef& viewportImage) const;
void RenderViewportWithoutPostEffects(maxon::ImageRef& image) const;
}

c4d_baseobject.h

{
Int32 GetEditorModeH(void) const;
Int32 GetRenderModeH(void) const;
}

c4d_colors.h

c4d_gedata.h

enum DA
{
DA_DATA = 260
}
class GeData
{
GeData(const maxon::Data &n)
const maxon::Data& GetData(void) const;
void SetData(const maxon::Data& v);
}

c4d_general.h

c4d_includes.h

// Removed
#include "description/oheadphone.h"
#include "description/oloudspeaker.h"
#include "description/omicrophone.h"

c4d_library.h

#define LIBOFFSET(s, m) (Int32)((UInt)(&(((s*)0)->m)))
// Changed to
#define LIBOFFSET(s, m) (Int32)((UInt)(&(((s*)nullptr)->m)))

c4d_painter.h

{
}
#define GETACTIVEUVSET_ISLANDS (1 << 10) ///< Get the UV islands.

c4d_shader.h

c4d_thread.h

c4d_shader.h

c4d_tooldata.h

// Removed
class AtomArray;
class String;
class BaseBitmap;
class BaseObject;
class BaseDraw;
class BaseThread;
class CDialog;

c4d_videopostdata.h

#define VPMagicBulletLooks 1054755
#define VPBUFFER_MAGICBULLETLOOKS 206
#define VPPRIORITY_MAGICBULLETLOOKS -100
#define VPPRIORITY_WATERMARK -1000
#define PLUGINFLAG_VIDEOPOST_STATIC (1 << 8)
#define PLUGINFLAG_VIDEOPOST_OFFBYDEFAULT (1 << 9)
#define MSG_VIDEOPOST_SETPREVIEW_VIEWPORT 1055286
#define MSG_VIDEOPOST_SETPREVIEW 1055287

ge_prepass.h

// Removed
#define Omicrophone 5138
#define Oloudspeaker 5139
#define Oheadphone 5151
enum class LINESTILE
{
}
enum class NBIT
{
NODE_TEMP = 96,
}
#define SKY_OBJECT 1011146
#define MDATA_UVSTRAIGHTEN_ALIGN 2270
#define MDATA_UVSTRAIGHTEN_KEEP_LENGTH 2271
#define MDATA_UVSTRAIGHTEN_EQUIDISTANT 2272
#define MDATA_UVRECTANGULARIZE_ALIGN 2280
#define MDATA_UVRECTANGULARIZE_EQUIDISTANT 2281
// Removed
#define WPREF_REFRESHTIME 10008
#define WPREF_NODE_EDITOR_GRID 1055258
#define WPREF_NODE_EDITOR_NAVIGATOR 1055259
#define WPREF_NODE_EDITOR_WIRE_STYLE 1055260
#define WPREF_NODE_EDITOR_ERRORS 1055261
#define WPREF_NODE_EDITOR_SNAP_GRID 1055262
#define WPREF_NODE_EDITOR_WIRE_STYLE_BEZIER 0
#define WPREF_NODE_EDITOR_WIRE_STYLE_STRAIGHT 1
#define EVMSG_SETMODE 1055256
#define EVMSG_TL_FCURVE_POS -200000079
#define EVMSG_TL_FCURVE_ROT -200000080
#define EVMSG_TL_FCURVE_SCALE -200000081
#define VIEWCOLOR_UV_GRID_MAJOR 106
#define VIEWCOLOR_UV_GRID_MINOR 107
#define VIEWCOLOR_INACTIVE_MODIFIER 108
#define EXECUTIONPRIORITY_SCENENODE 10000
enum class OBJECTSTATE
{
}
enum class VIEWPORTTYPE
{
NONE = 0,
MAIN_VIEW = 1,
UV_VIEW = 2
}
enum class DRAWFLAGS
{
// Removed
NO_REDUCTION = (1 << 2)
}
enum class SCENENODES_IDS
{
SCENEHOOK_ID = 1054188,
MSGUPDATE_LEGACYOBJ_ID = 180420109,
}

gui.h

enum
{
}

matrix4.h

using Matrix4d32 = maxon::SqMat4<Vector4d32>;
// Changed to
using Matrix4d64 = maxon::SqMat4<Vector4d64>;
// Changed to
using Matrix4d = maxon::SqMat4<Vector4d>;
// Changed to
using Matrix4d = maxon::SqrMat4<Vector4d>; ///< Matrix4 for double-precision @C4D versions.

operatingsystem.h

class ObserverObjectRef;
Bool (*SetMaxonData )(GeData *data, const maxon::Data* b);
const maxon::Data& (*GetMaxonData )(const GeData *data);
Bool (*PointInRange )(const BaseDraw *bd, const Vector &p, Int32 x, Int32 y);
// Changed to
Bool (*PointInRange )(const BaseDraw *bd, const Vector &p, Int32 x, Int32 y, Float range);
void (*GetViewportImage )(const BaseDraw* bd, maxon::ImageRef& viewportImage);
void (*RenderViewportWithoutPostEffects )(const BaseDraw* bd, maxon::ImageRef& image);
maxon::Block<Int32> (*UVGetIslands)(TempUVHandle* handle);

core.framework

maxon/math/col.h

Col3() : r(0), g(0), b(0) { }
// Changed to
constexpr Col3() : r(0), g(0), b(0) { }
explicit Col3(ValueTypeParam in) : r(in), g(in), b(in) { }
// Changed to
explicit constexpr Col3(ValueTypeParam in) : r(in), g(in), b(in) { }
explicit Col3(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz) : r(ix), g(iy), b(iz) { }
// Changed to
explicit constexpr Col3(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz) : r(ix), g(iy), b(iz) { }
template <typename T2, Int S2> explicit Col3(const Col3<T2, S2>& v) : r((T)v.r), g((T)v.g), b((T)v.b) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col3(const Col3<T2, S2>& v) : r((T)v.r), g((T)v.g), b((T)v.b) { }
template <typename T2, Int S2> explicit Col3(const Vec3<T2, S2>& v) : r((T)v.x), g((T)v.y), b((T)v.z) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col3(const Vec3<T2, S2>& v) : r((T)v.x), g((T)v.y), b((T)v.z) { }
template <typename T2, Int S2> explicit Col3(const Col4<T2, S2>& v) : r((T)v.r * (T)v.a), g((T)v.g * (T)v.a), b((T)v.b * (T)v.a) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col3(const Col4<T2, S2>& v) : r((T)v.r * (T)v.a), g((T)v.g * (T)v.a), b((T)v.b * (T)v.a) { }
template <Int S2> Col3(const Col3<T, S2>& v) : r(v.r), g(v.g), b(v.b) { }
// Changed to
template <Int S2> constexpr Col3(const Col3<T, S2>& v) : r(v.r), g(v.g), b(v.b) { }
explicit Col3(ENUM_DONT_INITIALIZE v) { }
// Changed to
explicit constexpr Col3(ENUM_DONT_INITIALIZE v) { }
MAXON_IMPLICIT Col3(const typename std::conditional<STRIDE == 1, DummyParamType, Col3>::type& src) : MAXON_MOVE_MEMBERS(r, g, b)
// Changed to
MAXON_IMPLICIT constexpr Col3(const typename std::conditional<STRIDE == 1, DummyParamType, Col3>::type& src) : MAXON_MOVE_MEMBERS(r, g, b)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const

maxon/math/col4.h

Col4() : r(0), g(0), b(0), a(T(1)) { }
// Changed to
constexpr Col4() : r(0), g(0), b(0), a(T(1)) { }
explicit Col4(ValueTypeParam in) : r(in), g(in), b(in), a(T(1)) { }
// Changed to
explicit constexpr Col4(ValueTypeParam in) : r(in), g(in), b(in), a(T(1)) { }
explicit Col4(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz, ValueTypeParam iw) : r(ix), g(iy), b(iz), a(iw) { }
// Changed to
explicit constexpr Col4(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz, ValueTypeParam iw) : r(ix), g(iy), b(iz), a(iw) { }
template <typename T2, Int S2> explicit Col4(const Col4<T2, S2>& v) : r((T)v.r), g((T)v.g), b((T)v.b), a((T)v.a) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col4(const Col4<T2, S2>& v) : r((T)v.r), g((T)v.g), b((T)v.b), a((T)v.a) { }
template <typename T2, Int S2> explicit Col4(const Vec4<T2, S2>& v) : r((T)v.x), g((T)v.y), b((T)v.z), a((T)v.w) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col4(const Vec4<T2, S2>& v) : r((T)v.x), g((T)v.y), b((T)v.z), a((T)v.w) { }
template <Int S2> Col4(const Col4<T, S2>& v) : r(v.r), g(v.g), b(v.b), a(v.a) { }
// Changed to
template <Int S2> constexpr Col4(const Col4<T, S2>& v) : r(v.r), g(v.g), b(v.b), a(v.a) { }
template <typename T2, Int S2> explicit Col4(const Col3<T2, S2>& v, T iw = T(1)) : r((T)v.r), g((T)v.g), b((T)v.b), a(iw) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Col4(const Col3<T2, S2>& v, T iw = T(1)) : r((T)v.r), g((T)v.g), b((T)v.b), a(iw) { }
explicit Col4(ENUM_DONT_INITIALIZE v) { }
// Changed to
explicit constexpr Col4(ENUM_DONT_INITIALIZE v) { }
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
template <typename V> Col4& operator *=(const SqMat4<V>& m)
// Changed to
template <typename V> Col4& operator *=(const SqrMat4<V>& m)

maxon/math/vec.h

Vec3() : x(0), y(0), z(0) { }
// Changed to
constexpr Vec3() : x(0), y(0), z(0) { }
explicit Vec3(ValueTypeParam in) : x(in), y(in), z(in) { }
// Changed to
explicit constexpr Vec3(ValueTypeParam in) : x(in), y(in), z(in) { }
explicit Vec3(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz) : x(ix), y(iy), z(iz) { }
// Changed to
explicit constexpr Vec3(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz) : x(ix), y(iy), z(iz) { }
template <typename T2, Int S2> explicit Vec3(const Vec3<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec3(const Vec3<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z) { }
template <typename T2, Int S2> explicit Vec3(const Col3<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec3(const Col3<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b) { }
template <Int S2> Vec3(const Vec3<T, S2>& v) : x(v.x), y(v.y), z(v.z) { }
// Changed to
template <Int S2> constexpr Vec3(const Vec3<T, S2>& v) : x(v.x), y(v.y), z(v.z) { }
template <typename T2, Int S2> explicit 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> explicit constexpr Vec3(const Vec2<T2, S2>& v, T vz = T()) : x((T)v.x), y((T)v.y), z(vz) { }
template <typename T2, Int S2> explicit Vec3(const Vec4<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec3(const Vec4<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z) { }
template <typename T2, Int S2> explicit Vec3(const Col4<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec3(const Col4<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b) { }
explicit Vec3(ENUM_DONT_INITIALIZE v) { }
// Changed to
explicit constexpr Vec3(ENUM_DONT_INITIALIZE v) { }
MAXON_IMPLICIT Vec3(const typename std::conditional<STRIDE == 1, DummyParamType, Vec3>::type& src) : MAXON_MOVE_MEMBERS(x, y, z)
// Changed to
MAXON_IMPLICIT constexpr Vec3(const typename std::conditional<STRIDE == 1, DummyParamType, Vec3>::type& src) : MAXON_MOVE_MEMBERS(x, y, z)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const

maxon/math/vec2.h

Vec2() : x(0), y(0) { }
// Changed to
constexpr Vec2() : x(0), y(0) { }
explicit Vec2(ValueTypeParam in) : x(in), y(in) { }
// Changed to
explicit constexpr Vec2(ValueTypeParam in) : x(in), y(in) { }
explicit Vec2(ValueTypeParam ix, ValueTypeParam iy) : x(ix), y(iy) { }
// Changed to
explicit constexpr Vec2(ValueTypeParam ix, ValueTypeParam iy) : x(ix), y(iy) { }
template <typename T2, Int S2> explicit 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>& v) : x((T)v.x), y((T)v.y) { }
template <Int S2> Vec2(const Vec2<T, S2>& v) : x(v.x), y(v.y) { }
// Changed to
template <Int S2> constexpr Vec2(const Vec2<T, S2>& v) : x(v.x), y(v.y) { }
template <typename T2, Int S2> explicit Vec2(const Vec3<T2, S2>& v) : x((T)v.x), y((T)v.y) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec2(const Vec3<T2, S2>& v) : x((T)v.x), y((T)v.y) { }
explicit Vec2(ENUM_DONT_INITIALIZE v) { }
// Changed to
explicit constexpr Vec2(ENUM_DONT_INITIALIZE v) { }
MAXON_IMPLICIT Vec2(const typename std::conditional<STRIDE == 1, DummyParamType, Vec2>::type& src) : MAXON_MOVE_MEMBERS(x, y)
// Changed to
MAXON_IMPLICIT constexpr Vec2(const typename std::conditional<STRIDE == 1, DummyParamType, Vec2>::type& src) : MAXON_MOVE_MEMBERS(x, y)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const

maxon/math/vec4.h

Vec4() : x(0), y(0), z(0), w(0) { }
// Changed to
constexpr Vec4() : x(0), y(0), z(0), w(0) { }
explicit Vec4(ValueTypeParam in) : x(in), y(in), z(in), w(in) { }
// Changed to
explicit constexpr Vec4(ValueTypeParam in) : x(in), y(in), z(in), w(in) { }
explicit Vec4(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz, ValueTypeParam iw) : x(ix), y(iy), z(iz), w(iw) { }
// Changed to
explicit constexpr Vec4(ValueTypeParam ix, ValueTypeParam iy, ValueTypeParam iz, ValueTypeParam iw) : x(ix), y(iy), z(iz), w(iw) { }
template <typename T2, Int S2> explicit Vec4(const Vec4<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z), w((T)v.w) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec4(const Vec4<T2, S2>& v) : x((T)v.x), y((T)v.y), z((T)v.z), w((T)v.w) { }
template <typename T2, Int S2> explicit Vec4(const Col4<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b), w((T)v.a) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec4(const Col4<T2, S2>& v) : x((T)v.r), y((T)v.g), z((T)v.b), w((T)v.a) { }
template <Int S2> Vec4(const Vec4<T, S2>& v) : x(v.x), y(v.y), z(v.z), w(v.w) { }
// Changed to
template <Int S2> constexpr Vec4(const Vec4<T, S2>& v) : x(v.x), y(v.y), z(v.z), w(v.w) { }
template <typename T2, Int S2> explicit Vec4(const Vec3<T2, S2>& v, T iw = T(1)) : x((T)v.x), y((T)v.y), z((T)v.z), w(iw) { }
// Changed to
template <typename T2, Int S2> explicit constexpr Vec4(const Vec3<T2, S2>& v, T iw = T(1)) : x((T)v.x), y((T)v.y), z((T)v.z), w(iw) { }
explicit Vec4(ENUM_DONT_INITIALIZE v) { }
// Changed to
explicit constexpr Vec4(ENUM_DONT_INITIALIZE v) { }
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
template <typename V> Vec4& operator *=(const SqMat4<V>& m)
// Changed to
template <typename V> Vec4& operator *=(const SqrMat4<V>& m)

maxon/utilities/apibaseid.h

class LiteralId
{
template <UInt N> explicit constexpr LiteralId(const Char (&str)[N]) : _value(str), _hash(GetHashCode<N>(str))
// Changed to
template <UInt N> explicit constexpr LiteralId(const Char (&str)[N]) : _value(str), _hash(GetHashCode(str))
constexpr UInt GetHashCode() const
// Changed to
constexpr HashInt GetHashCode() const
template <UInt N> constexpr LiteralId(bool dummy, const Char (&str)[N]) : _value(str), _hash(GetHashCode<N>(str))
// Changed to
template <UInt N> constexpr LiteralId(bool dummy, const Char (&str)[N]) : _value(str), _hash(GetHashCode(str))
}

maxon/utilities/apibasemath.h

// Changed to
static constexpr Float32 MINVALUE_FLOAT32
// Changed to
static constexpr Float32 MAXVALUE_FLOAT32
// Changed to
static constexpr Float64 MINVALUE_FLOAT64
// Changed to
static constexpr Float64 MAXVALUE_FLOAT64
// Changed to
// Changed to
// Changed to
// Changed to
// Changed to
static constexpr Float32 MINRANGE_FLOAT32
// Changed to
static constexpr Float32 MAXRANGE_FLOAT32
// Changed to
static constexpr Float64 MINRANGE_FLOAT64
// Changed to
static constexpr Float64 MAXRANGE_FLOAT64
static const Float MINVALUE_FLOAT
// Changed to
static constexpr Float MINVALUE_FLOAT
static const Float MAXVALUE_FLOAT
// Changed to
static constexpr Float MAXVALUE_FLOAT
static const Float MINRANGE_FLOAT
// Changed to
static constexpr Float MINRANGE_FLOAT
static const Float MAXRANGE_FLOAT
// Changed to
static constexpr Float MAXRANGE_FLOAT
static const Float MINVALUE_FLOAT
// Changed to
static constexpr Float MINVALUE_FLOAT
static const Float MAXVALUE_FLOAT
// Changed to
static constexpr Float MAXVALUE_FLOAT
static const Float MINRANGE_FLOAT
// Changed to
static constexpr Float MINRANGE_FLOAT
static const Float MAXRANGE_FLOAT
// Changed to
static constexpr Float MAXRANGE_FLOAT
template <> class LIMIT<Bool>
{
public:
static constexpr Bool MIN
static constexpr Bool MAX
};
template <> class LIMIT<Int64>
{
static const Int64 MIN
// Changed to
static constexpr Int64 MIN
static const Int64 MAX
// Changed to
static constexpr Int64 MAX
// Removed
static Int64 Min()
static Int64 Max()
}
template <> class LIMIT<UInt64>
{
static const UInt64 MIN
// Changed to
static constexpr UInt64 MIN
static const UInt64 MAX
// Changed to
static constexpr UInt64 MAX
// Removed
static UInt64 Min()
static UInt64 Max()
}
template <> class LIMIT<Int32>
{
static const Int32 MIN
// Changed to
static constexpr Int32 MIN
static const Int32 MAX
// Changed to
static constexpr Int32 MAX
// Removed
static Int32 Min()
static Int32 Max()
}
template <> class LIMIT<UInt32>
{
static const UInt32 MIN
// Changed to
static constexpr UInt32 MIN
static const UInt32 MAX
// Changed to
static constexpr UInt32 MAX
// Removed
static UInt32 Min()
static UInt32 Max()
}
template <> class LIMIT<Int16>
{
static const Int16 MIN
// Changed to
static constexpr Int16 MIN
static const Int16 MAX
// Changed to
static constexpr Int16 MAX
// Removed
static Int16 Min()
static Int16 Max()
}
template <> class LIMIT<UInt16>
{
static const UInt16 MIN
// Changed to
static constexpr UInt16 MIN
static const UInt16 MAX
// Changed to
static constexpr UInt16 MAX
// Removed
static UInt16 Min()
static UInt16 Max()
}
template <> class LIMIT<Char>
{
static const Char MIN
// Changed to
static constexpr Char MIN
static const Char MAX
// Changed to
static constexpr Char MAX
// Removed
static Char Min()
static Char Max()
}
template <> class LIMIT<UChar>
{
static const UChar MIN
// Changed to
static constexpr UChar MIN
static const UChar MAX
// Changed to
static constexpr UChar MAX
// Removed
static UChar Min()
static UChar Max()
}
template <> class LIMIT<Float32>
{
static Float32 Min()
// Changed to
static constexpr Float32 MIN
static Float32 Max()
// Changed to
static constexpr Float32 MAX
}
template <> class LIMIT<Float64>
{
static Float64 Min()
// Changed to
static constexpr Float64 MIN
static Float64 Max()
// Changed to
static constexpr Float64 MAX
}
static const Int NOTOK
// Changed to
static constexpr Int NOTOK
static const Float64 PI
// Changed to
static constexpr Float64 PI
static const Float64 PI_INV
// Changed to
static constexpr Float64 PI_INV
static const Float64 PI2
// Changed to
static constexpr Float64 PI2
static const Float64 PI2_INV
// Changed to
static constexpr Float64 PI2_INV
static const Float64 PI05
// Changed to
static constexpr Float64 PI05
static constexpr Float64 PI05_INV
static const Float64 SQRT2
// Changed to
static constexpr Float64 SQRT2
static const Float64 SQRT_PI2
// Changed to
static constexpr Float64 SQRT_PI2
static const Float64 SQRT2_INV
// Changed to
static constexpr Float64 SQRT2_INV
static const Float64 SQRT3
// Changed to
static constexpr Float64 SQRT3
static const Float64 LOG2
// Changed to
static constexpr Float64 LOG2
template <Int X, Int... Y> struct Sum<X, Y...>
{
static const Int value
// Changed to
static constexpr Int value
static const Int value
// Changed to
static constexpr Int value
static const T value
// Changed to
static constexpr T value
static const T value
// Changed to
static constexpr T value
}

maxon/utilities/classhelpers.h

// Removed
#define PRIVATE_MAXON_HASHCODE1(m1) maxon::DefaultCompare::GetHashCode(m1)
#define PRIVATE_MAXON_HASHCODE2(m1, m2) (PRIVATE_MAXON_HASHCODE1(m1) * 31 + maxon::DefaultCompare::GetHashCode(m2))
#define PRIVATE_MAXON_HASHCODE3(m1, m2, m3) (PRIVATE_MAXON_HASHCODE2(m1, m2) * 31 + maxon::DefaultCompare::GetHashCode(m3))
#define PRIVATE_MAXON_HASHCODE4(m1, m2, m3, m4) (PRIVATE_MAXON_HASHCODE3(m1, m2, m3) * 31 + maxon::DefaultCompare::GetHashCode(m4))
#define PRIVATE_MAXON_HASHCODE5(m1, m2, m3, m4, m5) (PRIVATE_MAXON_HASHCODE4(m1, m2, m3, m4) * 31 + maxon::DefaultCompare::GetHashCode(m5))
#define PRIVATE_MAXON_HASHCODE6(m1, m2, m3, m4, m5, m6) (PRIVATE_MAXON_HASHCODE5(m1, m2, m3, m4, m5) * 31 + maxon::DefaultCompare::GetHashCode(m6))
#define PRIVATE_MAXON_HASHCODE7(m1, m2, m3, m4, m5, m6, m7) (PRIVATE_MAXON_HASHCODE6(m1, m2, m3, m4, m5, m6) * 31 + maxon::DefaultCompare::GetHashCode(m7))
#define PRIVATE_MAXON_HASHCODE8(m1, m2, m3, m4, m5, m6, m7, m8) (PRIVATE_MAXON_HASHCODE7(m1, m2, m3, m4, m5, m6, m7) * 31 + maxon::DefaultCompare::GetHashCode(m8))
#define PRIVATE_MAXON_HASHCODE9(m1, m2, m3, m4, m5, m6, m7, m8, m9) (PRIVATE_MAXON_HASHCODE8(m1, m2, m3, m4, m5, m6, m7, m8) * 31 + maxon::DefaultCompare::GetHashCode(m9))
#define PRIVATE_MAXON_HASHCODE10(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) (PRIVATE_MAXON_HASHCODE9(m1, m2, m3, m4, m5, m6, m7, m8, m9) * 31 + maxon::DefaultCompare::GetHashCode(m10))
#define PRIVATE_MAXON_HASHCODE11(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) (PRIVATE_MAXON_HASHCODE10(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) * 31 + maxon::DefaultCompare::GetHashCode(m11))
#define PRIVATE_MAXON_HASHCODE12(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) (PRIVATE_MAXON_HASHCODE11(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) * 31 + maxon::DefaultCompare::GetHashCode(m12))
#define PRIVATE_MAXON_HASHCODE13(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) (PRIVATE_MAXON_HASHCODE12(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) * 31 + maxon::DefaultCompare::GetHashCode(m13))
#define PRIVATE_MAXON_HASHCODE14(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) (PRIVATE_MAXON_HASHCODE13(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) * 31 + maxon::DefaultCompare::GetHashCode(m14))
#define PRIVATE_MAXON_HASHCODE15(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) (PRIVATE_MAXON_HASHCODE14(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) * 31 + maxon::DefaultCompare::GetHashCode(m15))
#define PRIVATE_MAXON_HASHCODE_C(count, ...) MAXON_EXPAND(PRIVATE_MAXON_HASHCODE##count(__VA_ARGS__))
#define PRIVATE_MAXON_HASHCODE_B(count, ...) PRIVATE_MAXON_HASHCODE_C(count, __VA_ARGS__)
#define PRIVATE_MAXON_HASHCODE_A(count, ...) PRIVATE_MAXON_HASHCODE_B(count, __VA_ARGS__)
#define MAXON_HASHCODE(...) PRIVATE_MAXON_HASHCODE_A(MAXON_VA_NARGS(__VA_ARGS__), __VA_ARGS__)
// Changed to
#define MAXON_HASHCODE(...) maxon::DefaultCompare::GetCombinedHashCode(__VA_ARGS__)
#define MAXON_OPERATOR_EQUALITY_HASHCODE(T, ...) maxon::Bool operator ==(const T& other) const { return (this == &other) || (MAXON_MAKE_LIST(PRIVATE_MAXON_EQUALITY_OPERATORS, , &&, , __VA_ARGS__)); } \
maxon::Bool operator !=(const T& other) const { return !this->operator ==(other); } \
maxon::UInt GetHashCode() const { return PRIVATE_MAXON_HASHCODE_A(MAXON_VA_NARGS(__VA_ARGS__), __VA_ARGS__); }
// Changed to
#define MAXON_OPERATOR_EQUALITY_HASHCODE(T, ...) maxon::Bool operator ==(const T& other) const { return (this == &other) || (MAXON_MAKE_LIST(PRIVATE_MAXON_EQUALITY_OPERATORS, , &&, , __VA_ARGS__)); } \
maxon::Bool operator !=(const T& other) const { return !this->operator ==(other); } \
maxon::HashInt GetHashCode() const { return MAXON_HASHCODE(__VA_ARGS__); }

maxon/utilities/compare.h

// Changed to
// Changed to
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Bool i)
// Changed to
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Char i)
// Changed to
// Changed to
// Changed to
// Changed to
// Changed to
static UInt GetHashCode(Utf16Char i)
// Changed to
static HashInt GetHashCode(Utf16Char i)
static UInt GetHashCode(Utf32Char i)
// Changed to
static HashInt GetHashCode(Utf32Char i)
// Changed to
// Changed to
// Changed to
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const T* key)
// Changed to
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const T* key)
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(T* key)
// Changed to
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(T* key)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(std::nullptr_t)
// Changed to
static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(std::nullptr_t)
template <typename E> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const maxon::details::EnumWrapper<E>& key)
// Changed to
template <typename E> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const maxon::details::EnumWrapper<E>& key)
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const K& key)
// Changed to
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const K& key)
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCodeHelper(const K& key, OverloadRank0)
// Changed to
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCodeHelper(const K& key, OverloadRank0)
static UInt GetHashCode(const Char* key)
// Changed to
static constexpr HashInt GetHashCode(const Char* key)
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const K& key)
// Changed to
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const K& key)
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const K& key)
// Changed to
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const K& key)
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const K& key)
// Changed to
template <typename K> static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const K& key)

maxon/utilities/compilerdetection.h

#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT(T, M) ((size_t)(&((T*) 0)->M))
// Changed to
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT(T, M) ((size_t)(&((T*)nullptr)->M))
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT(T, M) ((size_t)(&((T*) 0)->M))
// Changed to
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT(T, M) ((size_t)(&((T*)nullptr)->M))

maxon/utilities/datadescriptiondefinition_include.h

class RenameList
{
RenameList(const RenameList* parent = nullptr)
Result<void> Add(const CString& from, const CString& to)
Result<InternedId> Rename(const InternedId& original) const
}
struct IncludeHelper
{
IncludeHelper() = default;
IncludeHelper(const IncludeHelper& parent)
Bool _ignoreExportFlag = false;
RenameList _includeRenameList;
HashSet<Id> _includeFilterAttributes;
Tuple<Id, InternedId> _includedFromId;
InternedId _groupId;
Result<void> PrepareInclude(const DataDescriptionEntry& props, const InternedId& groupId, const Tuple<Id, InternedId>& includedFromId,
const HashSet<Id>& includeFilterAttributes)
Result<Bool> IsFiltered(const InternedId& id) const
Result<void> Rename(const Id& category, const InternedId& id, DataDescriptionEntry& props) const
}

maxon/utilities/defaultdoc.h

UInt GetHashCode() const;
// Changed to
HashInt GetHashCode() const;

maxon/utilities/hash.h

struct DefaultHash
{
static constexpr UInt32 Mix(UInt32 h)
static constexpr UInt64 Mix(UInt64 h)
static constexpr HashInt SplitMix(HashInt value)
static constexpr HashInt EMPTY_HASH = 0
MAXON_IMPLICIT DefaultHash(HashInt start = EMPTY_HASH)
void Combine(HashInt value)
void CombineUnordered(HashInt value)
operator HashInt() const
template <typename... R> static HashInt CombineHashes(HashInt first, R... rest)
}
struct FNV1aHash
{
using ValueType = HashInt;
#ifdef MAXON_TARGET_64BIT
static constexpr HashInt PRIME = UINT64_C(1099511628211);
static constexpr HashInt BASIS = UINT64_C(14695981039346656037);
#else
static constexpr HashInt PRIME = UINT32_C(16777619);
static constexpr HashInt BASIS = UINT32_C(2166136261);
#endif
HashInt state = BASIS;
void Combine(Char c)
void Combine(UChar c)
void Combine(Utf16Char c)
void Combine(Utf32Char c)
operator HashInt() const
}

maxon/utilities/memoryallocationbase.h

UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const

maxon/apibase.h

#define MAXON_API_ABI_VERSION 21014
// Changed to
#define MAXON_API_ABI_VERSION 23008
// Removed
constexpr inline UInt UIntPow(UInt x, Int exp)
// Removed
constexpr inline UInt PrivateGetHashCode(const char* str, Int len)
// Removed
constexpr inline UInt PrivateGetHashCode(const Utf32Char* str, Int len)
using HashInt = UInt;
static const void* const g_zeroPtr = 0;
// Changed to
static const void* const g_zeroPtr = nullptr;
class UnitType
{
UInt GetHashCode() const { return 0; }
// Changed to
HashInt GetHashCode() const { return 0; }
}
class GenericArithmetic
{
UInt GetHashCode() const { return 0; }
// Changed to
HashInt GetHashCode() const { return 0; }
}
template <> struct HasBaseHelper<Generic, InternedId, 0> : public std::false_type
{
}
template <typename D> struct DefaultHasBase
{
template <typename I> struct Check
{
static const maxon::Bool value = std::is_base_of<I, D>::value;
static I* Cast(D* ptr) { return ptr; }
};
}
template <typename DT, typename BT> struct CheckHasBaseHelper
{
static constexpr Int value = CheckHasBase<DT>::value;
};
template <typename T> struct CheckHasBaseHelper<T, T>
{
static constexpr Int value = 2;
};
template <typename D, typename B> struct HasBase
{
using Helper = maxon::details::HasBaseHelper<DT, BT, STD_IS_REPLACEMENT(same, DT, BT) ? 2 : Int(CheckHasBase<DT>::value)>;
// Changed to
}
template <typename D, typename B> struct HasErasedBase
{
using Helper = maxon::details::HasBaseHelper<EDT, EBT, STD_IS_REPLACEMENT(same, EDT, EBT) ? 2 : Int(CheckHasBase<EDT>::value)>;
// Changed to
}
struct HashValue
{
UInt64 low = 0;
UInt64 high = 0;
HashValue() = default;
HashValue(UInt64 l, UInt64 h) : low(l), high(h) { }
MAXON_OPERATOR_EQUALITY_HASHCODE(HashValue, low, high);
};
template <UInt64 MODULE_ID_HASH = PrivateGetHashCode(MAXON_MODULE_ID, SIZEOF(MAXON_MODULE_ID)-1)> struct ModuleInfoWrapper
// Changed to
template <UInt64 MODULE_ID_HASH = CStringCompare::GetHashCode(MAXON_MODULE_ID)> struct ModuleInfoWrapper
enum class VALUEKIND : UInt64
{
// Removed
NAMED_TUPLE = 1LL << 22,
// Changed to
NAMED_TUPLE = 1LL << 60,
STRUCT = 1LL << 23,
// Changed to
STRUCT = 1LL << 22,
SIMD = 1LL << 24,
// Changed to
SIMD = 1LL << 23,
BLOCK = 1LL << 25,
// Changed to
BLOCK = 1LL << 24,
STRIDED_BLOCK = 1LL << 26,
// Changed to
STRIDED_BLOCK = 1LL << 25,
ARRAY = 1LL << 27,
// Changed to
ARRAY = 16LL << 55,
BASEARRAY = 1LL << 28,
// Changed to
BASEARRAY = 1LL << 26,
BLOCKARRAY = 1LL << 29,
// Changed to
BLOCKARRAY = 1LL << 27,
RESULT = 1LL << 30,
// Changed to
RESULT = 1LL << 28,
DELEGATE = 1LL << 31,
// Changed to
DELEGATE = 1LL << 29,
FUNCTION = 1LL << 32,
// Changed to
FUNCTION = 1LL << 30,
CONST_QUALIFIED = 1LL << 33,
// Changed to
CONST_QUALIFIED = 1LL << 31,
OPAQUE_QUALIFIED = 1LL << 34,
// Changed to
OPAQUE_QUALIFIED = 1LL << 32,
SOURCE_LEVEL = 1LL << 35,
// Changed to
SOURCE_LEVEL = 1LL << 33,
DEEP_CONSTNESS = 1LL << 36,
// Changed to
DEEP_CONSTNESS = 1LL << 34,
INT_SIZE_OR_LESS = 1LL << 37,
// Changed to
INT_SIZE_OR_LESS = 1LL << 35,
ZERO_INITIALIZED = 1LL << 38,
// Changed to
ZERO_INITIALIZED = 1LL << 36,
ORDERED = 1LL << 39,
// Changed to
ORDERED = 1LL << 37,
// Changed to
// Changed to
// Changed to
// Changed to
OBJECT_REF = 1LL << 44,
// Changed to
OBJECT_REF = 1LL << 42,
VALUE = 1LL << 45,
// Changed to
VALUE = 1LL << 43,
// Changed to
NEVER_NULLPTR = 1LL << 47,
// Changed to
NEVER_NULLPTR = 1LL << 45,
SIGNED = 1LL << 48,
// Changed to
SIGNED = 1LL << 46,
// Changed to
// Changed to
ABSTRACT = 1LL << 49,
// Changed to
ABSTRACT = 1LL << 51,
CONTAINER = 1LL << 54,
// Changed to
CONTAINER = 1LL << 55,
EMPTY_CONTAINER = 2LL << 54,
// Changed to
EMPTY_CONTAINER = 2LL << 55,
// Changed to
// Changed to
ARRAY_CONTAINER = 5LL << 54,
// Changed to
ARRAY_CONTAINER = 5LL << 55,
CONTAINER_MASK = 15LL << 54,
// Changed to
CONTAINER_MASK = 31LL << 55,
CONTAINER_REF = 1LL << 58,
// Changed to
CONTAINER_REF = 1LL << 51,
GENERIC_CONTAINER = 1LL << 52,
// Changed to
GENERIC_CONTAINER = 1LL << 59,
// Changed to
NAMED = 1LL << 50,
// Changed to
}

maxon/applicationid.h

namespace APPLICATIONID
{
// Removed
static const LiteralId PYTHON3{"net.maxon.application.python3"};
static const LiteralId DRAWPORT_UNITTESTS{ "net.maxon.application.drawport_unittests" };
}

maxon/array.h

class PersistentIdGeneratorInterface
{
public:
MAXON_METHOD Result<void> InitializeBuffer(PersistentIdBuffer& buffer) const
MAXON_METHOD void FreeBuffer(PersistentIdBuffer& buffer) const
MAXON_METHOD Result<void> Move(Int index, PersistentIdBuffer& buffer) const
MAXON_METHOD Result<void> Advance(Int index, PersistentIdBuffer& buffer) const
}
template <typename TYPE> class StaticArrayInterface
// Changed to
template <typename TYPE> class StaticArrayInterface : public GenericContainerInterface MAXON_GENERIC_BASE(NamedTuple<TYPE>)
template <typename TYPE> class StaticArrayInterface : public GenericContainerInterface MAXON_GENERIC_BASE(NamedTuple<TYPE>)
{
template <typename T> MAXON_FUNCTION ResultMem Set(Int index, T&& value)
// changed to
template <typename A> MAXON_FUNCTION ResultMem Set(Int index, A&& value)
// Removed
MAXON_METHOD Result<Int> GetWritableBlock(Int index, SimdBlock<TYPE>& block);
// Removed
MAXON_METHOD Result<StaticArrayInterface*> MakeWritable(Bool cloneElements = true) const;
MAXON_METHOD Result<Int> GetBlock(Int index, SimdBlock<NonConstValueType>& block);
Int GetBlock(Int index, StridedBlock<NonConstValueType>& block);
MAXON_METHOD const PersistentIdGenerator& GetPersistentIdGenerator() const;
// Removed
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
// Removed
MAXON_METHOD Bool IsEqual(const StaticArrayInterface* other, EQUALITY equality) const;
// Removed
MAXON_METHOD UInt GetHashCode() const;
template <typename COLLECTION_TYPE> class IteratorTemplate
{
explicit IteratorTemplate(CollectionType& a) : _array(&a)
explicit IteratorTemplate(CollectionType& a, Int start = 0) : _array(&a)
// Changed to
explicit IteratorTemplate(CollectionType& a, Int start) : _array(&a)
IteratorTemplate() : _indexPtr(nullptr)
// Changed to
IteratorTemplate() : _index(LIMIT<Int>::MIN)
}
MAXON_FUNCTION ConstIterator Begin() const
// Changed to
MAXON_FUNCTION typename StaticArrayInterface<TYPE>::ConstIterator Begin() const
MAXON_FUNCTION ConstIterator End() const
// Changed to
MAXON_FUNCTION typename StaticArrayInterface<TYPE>::ConstIterator End() const
// Removed
using StaticArrayInterfaceMarker = void;
}
// Removed
template <typename T> struct StrongCOWRefHandler::MakeWritableHelper<T, typename T::StaticArrayInterfaceMarker>
// Removed
template <typename TYPE> class VArrayInterface : public StaticArrayInterface<TYPE>
template <typename TYPE> class ArrayInterface : public ArrayBase0<ArrayInterface<TYPE>, TYPE, VArrayInterface<TYPE>, DefaultCompare>
// Changed to
template <typename TYPE> class ArrayInterface : public ArrayBase0<ArrayInterface<TYPE>, TYPE, StaticArrayInterface<TYPE>, DefaultCompare>
template <typename TYPE> class ArrayInterface : public ArrayBase0<ArrayInterface<TYPE>, TYPE, StaticArrayInterface<TYPE>, DefaultCompare>
{
// Removed
using Super::CopyFrom;
MAXON_METHOD Int GetBlock(Int index, Block<const TYPE, false>& block) const;
// Changed to
MAXON_METHOD Int GetBlock(Int index, Block<const TYPE>& block) const;
Int GetBlock(Int index, Block<TYPE, false>& block)
// Changed to
Int GetBlock(Int index, Block<typename Super::NonConstValueType>& block);
// Removed
Int GetBlock(Int index, StridedBlock<const TYPE>& block) const
// Removed
Int GetBlock(Int index, StridedBlock<TYPE>& block)
MAXON_METHOD ResultRef<TYPE> Insert(Int index);
MAXON_FUNCTION ResultRef<TYPE> Insert(Int index, const TYPE& value)
MAXON_FUNCTION ResultRef<TYPE> Insert(Int index, TYPE&& value)
MAXON_METHOD ResultMem Insert(Int index, const Block<const TYPE>& values);
MAXON_METHOD ResultMem Insert(Int index, const MoveBlock<TYPE>& values);
MAXON_METHOD ResultRef<TYPE> Append();
MAXON_FUNCTION ResultRef<TYPE> Append(const TYPE& value)
MAXON_FUNCTION ResultRef<TYPE> Append(TYPE&& value)
template <typename A> MAXON_FUNCTION ResultRef<TYPE> Append(A&& value)
MAXON_METHOD ResultMem Erase(Int index, Int count = 1);
template <typename C> typename ArrayInterface::template IteratorTemplate<C> Erase(const typename ArrayInterface::template IteratorTemplate<C>& it)
MAXON_METHOD ResultMem SwapErase(Int index, Int count = 1);
MAXON_METHOD void Flush();
MAXON_METHOD Result<void> CopyFrom(const ArrayInterface& other);
MAXON_METHOD void SetPersistentIdGenerator(const PersistentIdGenerator& generator);
template <typename T> MAXON_FUNCTION void AssertType() const
// Changed to
template <typename DT> MAXON_FUNCTION void AssertType() const
template <typename T> ArrayInterface<T>& AssertCast()
// Changed to
template <typename T2> ArrayInterface<T2>& AssertCast()
template <typename T> const ArrayInterface<T>& AssertCast() const
// Changed to
template <typename T2> const ArrayInterface<T2>& AssertCast() const
MAXON_FUNCTION ConstIterator Begin() const
// Changed to
MAXON_FUNCTION typename ArrayInterface<TYPE>::ConstIterator Begin() const
MAXON_FUNCTION ConstIterator End() const
// Changed to
MAXON_FUNCTION typename ArrayInterface<TYPE>::ConstIterator End() const
}
inline void FreeArrayIteratorPersistentId(PersistentIdBuffer* idBuffer, const PersistentIdGeneratorInterface* ig)
inline Result<void> MoveArrayIteratorPersistentId(Int index, PersistentIdBuffer* idBuffer, const PersistentIdGeneratorInterface* ig)
template <Bool RANDOM_ACCESS, Bool LOAD_ELEMENTS, typename ARRAY> inline Result<Int> ValidateArrayIterator(const ARRAY& array, Int index, ViewIteratorMember* members, const MemberMap* map, Int* state, PersistentIdBuffer* idBuffer, const PersistentIdGeneratorInterface* ig)
inline Result<void> InitArrayIteratorPersistentId(PersistentIdBuffer* idBuffer, const PersistentIdGeneratorInterface* ig)
template <typename ARRAY> inline Result<Int> InitArrayIterator(const ARRAY& array, ViewIteratorMember* members, const MemberMap* map, Int* state, PersistentIdBuffer* idBuffer, const PersistentIdGeneratorInterface* ig)
inline Result<void> AdvanceArrayIteratorPersistentId(Int index, PersistentIdBuffer& idBuffer, const PersistentIdGeneratorInterface* ig)
template <typename ARRAY> class ArrayImpl
{
const ContainerDataType<>& GetContainerType() const
GenericContainerInterface::INTERFACES GetInterfaces() const
Int FindMemberIndex(const InternedId& name) const
Int GetIteratorStateSize(const MemberMap* map) const
Result<Int> InitIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const
Result<Int> ValidateIterator(Int index, ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const
void FreeIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const
Result<Int> MoveIterator(Int index, ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const
Result<void> AdvancePersistentId(Int index, const Char* state, PersistentIdBuffer& idBuffer) const
const PersistentIdGenerator& GetPersistentIdGenerator() const
void SetPersistentIdGenerator(const PersistentIdGenerator& generator)
// Removed
Result<Int> GetWritableBlock(Int index, SimdBlock<ValueType>& block)
Result<Int> GetBlock(Int index, SimdBlock<NonConstValueType>& block)
Int GetBlock(Int index, Block<const ValueType, false>& block) const
// Changed to
Int GetBlock(Int index, Block<const ValueType>& block) const
Int GetBlock(Int index, Block<NonConstValueType>& block)
Result<void> CopyFrom(const VArrayInterface<ValueType>& other)
// Changed to
Result<void> CopyFrom(const ArrayInterface<ValueType>& other)
Result<Interface*> MakeWritable(Bool cloneElements) const
// Changed to
Result<GenericContainerInterface*> MakeWritable(Bool cloneElements) const
Result<GenericContainerInterface*> Clone(Bool cloneElements) const
Bool IsEqual(const StaticArrayInterface<ValueType>* other, EQUALITY equality) const
// Changed to
Bool IsEqual(const GenericContainerInterface* o, EQUALITY equality) const
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
HashValue GetHashValue() const
template <typename T> inline typename std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void>>::type Data::SetImpl(T&& data, OverloadRank1)
// Changed to
template <typename DEST, typename SRC> inline typename std::enable_if<GetCollectionKind<SRC>::value == COLLECTION_KIND::ARRAY, Result<void>>::type Data::SetImpl(SRC&& data, OverloadRank1)
}

maxon/arraymap.h

template <typename ARRAY, typename ENTRY, typename COMPARE> class ArrayMapSortedArray : public SortedArray<ArrayMapSortedArray<ARRAY, ENTRY, COMPARE>, typename ARRAY::template Type<ENTRY>>
{
static UInt GetHashCode(const ENTRY& a) { return COMPARE::GetHashCode(a); }
// Changed to
static HashInt GetHashCode(const ENTRY& a) { return COMPARE::GetHashCode(a); }
}

maxon/basebitset.h

template <typename ALLOCATOR = DefaultAllocator> class BaseBitSet
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/baseref.h

template <typename T> StrongReferenceCounter& PrivateGetReferenceCounter(const T* obj);
// Changed to
inline StrongReferenceCounter& PrivateGetReferenceCounter(const void* obj);
template <typename T> void PrivateFreeWithDestructor(const T* obj);
// Changed to
template <typename T> inline void PrivateFreeWithDestructor(const T* obj);
template <typename T, typename HANDLER> class BaseRef
{
const T& operator [](Int) const = delete;
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
static const BaseRef& NullValue()
// Changed to
static const BaseRef& NullValueRef()
static typename std::conditional<Bool(HANDLER::KIND & VALUEKIND::UNIQUE_REFERENCE), BaseRef, const BaseRef&>::type NullValue()
}

maxon/block.h

template <typename COLLECTION, Bool STRIDED> class BaseIterator
{
template <typename SUPER> class ResultFunctions : public SUPER
{
Bool operator !=(const Result<BaseIterator>& other) const
void operator ++()
Result<BaseIterator::ValueType&> operator *()
}
}

maxon/branch.h

const Bool MAXON_CONCAT(V,DefaultValue)
// Changed to
const maxon::Bool MAXON_CONCAT(V,DefaultValue)
Bool V = false;
//Changed to
maxon::Bool V = false;

maxon/bytesvalue.h

class BytesValue
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/collection.h

template <typename COLLECTION, typename VALUETYPE, typename SUPER, typename HASH> class ArrayBase0 : public Collection<COLLECTION, VALUETYPE, SUPER>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename COLLECTION, typename VALUETYPE, typename SUPER, typename HASH> class SetBase0 : public Collection<COLLECTION, VALUETYPE, SUPER>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename COLLECTION, typename KEYTYPE, typename VALUETYPE, typename SUPER, typename HASH> class MapBase0 : public BaseCollection<COLLECTION, SUPER>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/configurationdatabase.h

class Configuration
{
// Removed
static MAXON_METHOD void DeprecatedQueryBool(const String& key, Bool& result, CONFIGURATIONENTRY_ORIGIN& origin, CONFIGURATIONENTRY_STATE& state);
// Removed
static MAXON_METHOD void DeprecatedQueryInt(const String& key, Int& result, CONFIGURATIONENTRY_ORIGIN& origin, CONFIGURATIONENTRY_STATE& state);
// Removed
static MAXON_METHOD void DeprecatedQueryFloat(const String& key, Float& result, CONFIGURATIONENTRY_ORIGIN& origin, CONFIGURATIONENTRY_STATE& state);
// Removed
static MAXON_METHOD void DeprecatedQueryString(const String& key, String& result, CONFIGURATIONENTRY_ORIGIN& origin, CONFIGURATIONENTRY_STATE& state);
}

maxon/containerbase.h

class GenericContainerInterface
{
enum class INTERFACES
{
NONE = 0,
V_ARRAY = 32,
ARRAY = 64,
} MAXON_ENUM_FLAGS_CLASS(INTERFACES);
MAXON_METHOD const ContainerDataType<>& GetContainerType() const;
MAXON_METHOD INTERFACES GetInterfaces() const;
MAXON_METHOD Result<GenericContainerInterface*> MakeWritable(Bool cloneElements = true) const;
MAXON_METHOD Result<GenericContainerInterface*> Clone(Bool cloneElements = true) const;
MAXON_METHOD String ToString(const FormatStatement* formatStatement) const;
MAXON_METHOD HashInt GetHashCode() const;
MAXON_METHOD HashValue GetHashValue() const;
MAXON_METHOD Bool IsEqual(const GenericContainerInterface* other, EQUALITY equality) const;
MAXON_METHOD Int FindMemberIndex(const InternedId& name) const;
MAXON_FUNCTION Int FindMemberIndex(const Member& member) const;
MAXON_METHOD Result<Int> GetCount() const;
MAXON_METHOD Int GetIteratorStateSize(const MemberMap* map) const;
MAXON_METHOD Result<Int> InitIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const;
MAXON_METHOD Result<Int> ValidateIterator(Int index, ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const;
MAXON_METHOD void FreeIterator(ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const;
MAXON_METHOD Result<Int> MoveIterator(Int index, ViewIteratorMember* members, const MemberMap* map, Char* state, PersistentIdBuffer* idBuffer) const;
MAXON_METHOD Result<void> AdvancePersistentId(Int index, const Char* state, PersistentIdBuffer& idBuffer) const;
};

maxon/contiguousrangemap.h

template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class ContiguousRangeMap
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/datadescription.h

class DataDescriptionInterface
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}

maxon/datadescription_data.h

using VariadicIdsType = BaseArray<VariadicIdsElement>;
// Changed to
using VariadicIdsType = Array<VariadicIdsElement>;
namespace DESCRIPTION
{
namespace BASE
{
MAXON_ATTRIBUTE(Int, DBVERSION, "net.maxon.description.base.dbversion");
MAXON_ATTRIBUTE(Bool, LIMITVALUE, "net.maxon.description.data.base.limitvalue");
// Changed to
MAXON_ATTRIBUTE(Id, LIMITVALUE, "net.maxon.description.data.base.limitvalue",
RESOURCE_DEFINE(ENUM_NONE, Id("none"))
RESOURCE_DEFINE(ENUM_MIN, Id("min"))
RESOURCE_DEFINE(ENUM_MAX, Id("max"))
RESOURCE_DEFINE(ENUM_BOTH, Id("both")));
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, INCLUDERENAME, "net.maxon.description.data.base.includerename");
// Changed to
MAXON_ATTRIBUTE(Array<Id>, INCLUDERENAME, "net.maxon.description.data.base.includerename");
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, INCLUDEFILTER, "net.maxon.description.data.base.includefilter");
// Changed to
MAXON_ATTRIBUTE(Array<Id>, INCLUDEFILTER, "net.maxon.description.data.base.includefilter");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(BaseArray<maxon::Tuple<maxon::Id, maxon::Data>>), ENUM, "net.maxon.description.data.base.enum");
// Changed to
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Array<Tuple<Id, Data>>), ENUM, "net.maxon.description.data.base.enum");
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, VARIADICCOMMANDS, "net.maxon.description.data.base.variadiccommands");
// Changed to
MAXON_ATTRIBUTE(Array<Id>, VARIADICCOMMANDS, "net.maxon.description.data.base.variadiccommands");
MAXON_ATTRIBUTE(String, WARNINGS, "net.maxon.description.data.base.warnings");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Tuple<maxon::Id, maxon::InternedId>), INCLUDEDFROM, "net.maxon.description.data.base.includedfrom");
// Changed to
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Tuple<Id, InternedId>), INCLUDEDFROM, "net.maxon.description.data.base.includedfrom");
MAXON_ATTRIBUTE(Group, GROUPINFO, "net.maxon.description.data.base.groupinfo");
}
namespace INFO
{
// Removed
RESOURCE_DEFINE(ENUM_TYPE, Id("type"))
// Removed
RESOURCE_DEFINE(ENUM_STRUCT, Id("struct"))
// Removed
RESOURCE_DEFINE(ENUM_GLOBAL, Id("global")));
RESOURCE_DEFINE(ENUM_ATTRIBUTE, Id("attribute")));
// Removed
MAXON_ATTRIBUTE(Int, ICON, "net.maxon.description.data.info.icon");
MAXON_ATTRIBUTE(Bool, DYNAMICBUNDLE, "net.maxon.description.data.info.dynamicbundle");
}
}

maxon/datadescription_ui.h

namespace DESCRIPTION
{
namespace UI
{
namespace BASE
{
MAXON_ATTRIBUTE(Id, DEFAULTCLASSIFICATION, "net.maxon.description.ui.base.defaultclassification",
RESOURCE_DEFINE(ENUM_NONE, Id("none"))
RESOURCE_DEFINE(ENUM_INPUT, Id("input"))
RESOURCE_DEFINE(ENUM_OUTPUT, Id("output")));
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, BASELINK_ACCEPT, "net.maxon.description.ui.base.baselink.accept");
// Changed to
MAXON_ATTRIBUTE(Array<Id>, BASELINK_ACCEPT, "net.maxon.description.ui.base.baselink.accept");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(BaseArray<maxon::Tuple<maxon::InternedId, maxon::InternedId>>), PRESETMEMBERS, "net.maxon.description.ui.base.presetmembers");
// Changed to
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Array<Tuple<InternedId, InternedId>>), PRESETMEMBERS, "net.maxon.description.ui.base.presetmembers");
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, ENUM, "net.maxon.description.ui.base.enum");
// Changed to
MAXON_ATTRIBUTE(Array<Id>, ENUM, "net.maxon.description.ui.base.enum");
}
}
}

maxon/datadescriptiondatabase.h

static MAXON_METHOD Result<BaseArray<Tuple<Id, Data, String>>> GetEffectiveEnumList(const DataDictionary& dataEntry,
const DataDictionary& guiEntry, const DataDescription& stringDescription, Bool resolveExtensionPointsAndGui,
const AssetRepositoryRef& repository);
// Changed to
static MAXON_METHOD Result<BaseArray<Tuple<Id, Data, String>>> GetEffectiveEnumList(const DataDictionary& dataEntry,
const DataDictionary& guiEntry, const DataDescription& stringDescription, Bool resolveExtensionPointsAndGui,
const AssetRepositoryRef& repository, const Data* filterData);
using ProcessEnumListDelegate = Delegate<Result<void>(const Id& epId, const DataDictionary& guiEntry, const AssetRepositoryRef& repository,
const ValueReceiver<Tuple<Id, Data, String>&&>& addValue)>;
// Changed to
using ProcessEnumListDelegate = Delegate<Result<void>(const Id& epId, const DataDictionary& guiEntry, const AssetRepositoryRef& repository, const Data* filterData,
const ValueReceiver<Tuple<Id, Data, String>&&>& addValue)>;
inline Bool UseFilterData(const Data* filterData, const Data& compare)

maxon/datadescriptiondefinition_conversion.h

maxon/datadescriptiondefinitiondatabase.h

enum class DBVERSION;
class DataDescriptionDefinitionDatabaseInterface
{
static MAXON_METHOD Result<void> FixDatabaseProps(DBVERSION version, DataDictionary& entry);
}

maxon/datadictionary.h

class DataDictionaryInterface
{
template <typename KEY> MAXON_FUNCTION Bool Existing(KEY&& key) const
// Changed to
template <typename KEY> MAXON_FUNCTION Bool Contains(KEY&& key) const
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
MAXON_FUNCTION Result<typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type> Get(KEY&& key) const
// Changed to
MAXON_FUNCTION Result<typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type> Get(KEY&& key) const
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, const T& defaultValue) const
// Changed to
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value&& GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, const T& defaultValue) const
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, T&& defaultValue) const
// Changed to
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value&& GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, T&& defaultValue) const
MAXON_FUNCTION typename IsFidClass<KEY>::type GetOrDefault(KEY&& key) const;
// Changed to
MAXON_FUNCTION typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault(KEY&& key) const;
}
static Result<typename IsFidClass<ATTRIBUTETYPE>::type> GetDataDescriptionValue2(ATTRIBUTETYPE&& attribute, const ConstDataPtr& key)
// Changed to
static Result<TT> GetDataDescriptionValue2(ATTRIBUTETYPE&& attribute, const ConstDataPtr& key)
template <typename KEY> inline typename IsFidClass<KEY>::type GetDefaultFromFidIfAvailable(KEY&& key, OverloadRank0)
// Changed to
template <typename TT, typename KEY> inline TT GetDefaultFromFidIfAvailable(KEY&& key, OverloadRank0)
inline typename SFINAEHelper<typename IsFidClass<KEY>::type, decltype(std::remove_reference<KEY>::type::DEFAULTVALUE)>::type
// Changed to
inline typename SFINAEHelper<TT, decltype(std::remove_reference<KEY>::type::DEFAULTVALUE)>::type
template <typename KEY>
typename IsFidClass<KEY>::type DataDictionaryInterface::GetOrDefault(KEY&& key) const
// Changed to
template <typename T, typename KEY>
typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type DataDictionaryInterface::GetOrDefault(KEY&& key) const
}

maxon/datadictionaryobject.h

class DataDictionaryObjectInterface
{
template <typename KEY> MAXON_FUNCTION Bool Existing(KEY&& key) const
// Changed to
template <typename KEY> MAXON_FUNCTION Bool Contains(KEY&& key) const
MAXON_FUNCTION Result<typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type> Get(KEY&& key) const
// Changed to
MAXON_FUNCTION Result<typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type> Get(KEY&& key) const
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, const T& defaultValue) const
// Changed to
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value&& GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, const T& defaultValue) const
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, T&& defaultValue) const
// Changed to
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value&& GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY, typename IsFidClass<KEY>::type, T>::type Get(KEY&& key, T&& defaultValue) const
template <typename KEY>
MAXON_FUNCTION typename IsFidClass<KEY>::type GetOrDefault(KEY&& key) const;
// Changed to
template <typename T = void, typename KEY>
MAXON_FUNCTION typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault(KEY&& key) const;
}
template <typename KEY>
typename IsFidClass<KEY>::type DataDictionaryObjectInterface::GetOrDefault(KEY&& key) const
// Changed to
template <typename T, typename KEY>
typename std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type DataDictionaryObjectInterface::GetOrDefault(KEY&& key) const
}

maxon/dataserialize.h

struct IDENT_VOID
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
#define CONSTHASH(x) static const maxon::UInt MAXON_CONCAT(x, Hash) = maxon::PrivateGetHashCode(#x, (maxon::Int)sizeof(#x) - 1) // subtract one as sizeof includes the terminating 0C
// Changed to
#define CONSTHASH(x) static const maxon::UInt MAXON_CONCAT(x, Hash) = maxon::CStringCompare::GetHashCode(#x)

maxon/datatype.h

#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM(enumtype, id, size, flags, names, ...)
// Changed to
#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM(enumtype, cppname, id, size, flags, names, ...) \
MAXON_DATATYPE_SCALAR(HashValue, "net.maxon.datatype.hash");
template <typename T> struct MemberTypeBase<T, typename std::enable_if<STD_IS_REPLACEMENT(base_of, InternedId, T), typename SFINAEHelper<void, typename T::ValueType>::type>::type>
// Changed to
template <typename T> struct MemberTypeBase<T, typename std::enable_if<maxon::details::HasBaseHelper<T, InternedId, 0>::value, typename SFINAEHelper<void, typename T::ValueType>::type>::type>
template <typename T> struct MemberType : public MemberTypeBase<T>
// Changed to
template <typename T, Bool GENERIC_FOR_UNKNOWN_TYPE = false> struct MemberType : public MemberTypeBase<T>
template <typename T> struct MemberType<T&> : public MemberTypeBase<T>
// Changed to
template <typename T, Bool GENERIC_FOR_UNKNOWN_TYPE> struct MemberType<T&, GENERIC_FOR_UNKNOWN_TYPE> : public MemberTypeBase<T>
template <typename T> struct MemberType<T&&> : public MemberTypeBase<T>
// Changed to
template <typename T, Bool GENERIC_FOR_UNKNOWN_TYPE> struct MemberType<T&&, GENERIC_FOR_UNKNOWN_TYPE> : public MemberTypeBase<T>
template <typename T> inline Result<void> Data::SetImpl(T&& data, OverloadRank0)
// Changed to
template <typename DEST, typename SRC> inline Result<void> Data::SetImpl(SRC&& data, OverloadRank0)
template <typename DEST> inline Result<void> Data::SetImpl(Data&& data, OverloadRank1)
template <typename DEST> inline Result<void> Data::SetImpl(const Data& data, OverloadRank1)
template <typename DEST> inline Result<void> Data::SetImpl(Data& data, OverloadRank1)

maxon/datatype_builder.h

#define FOLDER_BASIC Id("#$01Basic")
#define FOLDER_ADVANCED Id("#$02Advanced")
#define FOLDER_STRUCTURE Id("#$03Structure")
#define FOLDER_MODULES Id("#$04Modules")
{
class ParametricTypeInterface;
struct DataTypeComponent
{
Int _identifier = -1;
String _compName, _name;
DataType _type;
Id _typeId;
Id _parametricTypeId;
const ParametricTypeInterface* _additionalRefType = nullptr;
BaseArray<DataTypeComponent> _children;
String ToString(const FormatStatement* formatStatement) const
};
class DataTypeBuilderInterface : MAXON_INTERFACE_BASES(Object)
{
static MAXON_METHOD Result<String> GetDataTypeName(const DataType& dt, DATATYPEBUILDERNAME category);
static MAXON_METHOD Result<Tuple<String, Bool>> RecurseDataType(DATATYPEBUILDERNAME category, const Member& dt, const ParametricTypeInterface* parentTypeId, Int& globalIdentifier, BaseArray<DataTypeComponent>& components);
};
class DataTypeBuilderEntry
{
MAXON_DISALLOW_COPY_AND_ASSIGN(DataTypeBuilderEntry);
public:
Result<void> CopyFrom(const DataTypeBuilderEntry& src)
GetFolderDelegate getFolder;
GetChildrenCountDelegate getChildrenCount;
InstantiateDataTypeDelegate instantiateDataType;
GetParentTypeSupportDelegate getParentTypeSupport;
};
MAXON_DATATYPE(DataTypeBuilderEntry, "net.maxon.datatype.datatypebuilderentry");
MAXON_REGISTRY(DataTypeBuilderEntry, DataTypeBuilderRegistry, "net.maxon.registry.datatypebuilderregistry");
#define MAXON_REGISTER_DATATYPEBUILDER_TYPE(TYPE, STRING, HUMAN, FOLDER)

maxon/datatypebase.h

class DataTypePtr
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class DataTypeImpl
{
template <typename T, typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, const T* dummy1, const C* dummy2,
VALUEKIND flags = VALUEKIND::NONE, const NonvirtualInterfaceImplementation* impl = nullptr,
VALUEKIND kind = ValueKindHelper<T, GetDirectlyReferencedType<T>::value>::KIND, const ParametricTypeInterface* pt = nullptr)
// Changed to
template <typename T, typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, const T* dummy1, const C* dummy2,
VALUEKIND flags = VALUEKIND::NONE, const NonvirtualInterfaceImplementation* impl = nullptr,
VALUEKIND kind = ValueKindHelper<T, GetDirectlyReferencedType<T>::value>::KIND, const ParametricTypeInterface* pt = nullptr, const DataTypeImpl* extra = nullptr)
template <typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, Int size, Int alignment, const C* dummy2, VALUEKIND kind, const ParametricTypeInterface* pt = nullptr)
// Changed to
template <typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, Int size, Int alignment, const C* dummy2, VALUEKIND kind, const ParametricTypeInterface* pt = nullptr, const DataTypeImpl* extra = nullptr)
void Construct(void* dest) const
void Construct(void* dest, Int count) const
// Changed to
void Construct(void* dest, Int dstride, Int count) const
void Destruct(const void* dest) const
void Destruct(const void* dest, Int count) const
// Changed to
void Destruct(const void* dest, Int dstride, Int count) const
void MoveConstruct(void* dest, void* src) const
void MoveConstruct(void* dest, void* src, Int count) const
// Changed to
void MoveConstruct(void* dest, Int dstride, void* src, Int sstride, Int count) const
void MoveFrom(void* dest, void* src) const
void MoveFrom(void* dest, void* src, Int count) const
// Changed to
void MoveFrom(void* dest, Int dstride, void* src, Int sstride, Int count) const
Result<void> CopyFrom(void* dest, const void* src, Int count) const
// Changed to
Result<void> CopyFrom(void* dest, const void* src) const
// Removed
Result<Bool> UpdateFrom(void* dest, const void* src) const
Result<void> CopyFrom(void* dest, Int dstride, const void* src, Int sstride, Int count) const
UInt GetHashCode(const void* s1) const
// Changed to
HashInt GetHashCode(const void* s1) const
HashValue GetHashValue(const void* s1) const
const StrongRef<const DataTypeImpl>& PrivateGetExtraType() const
}
class DataTypeImpl::Primary
{
template <typename... ARGS> explicit Primary(ARGS&&... args) : type(std::forward<ARGS>(args)...)
// Changed to
template <typename... ARGS> explicit Primary(const Char* cppName, const ModuleInfo* module, ARGS&&... args)
const Char* _cppName = nullptr;
const ModuleInfo* _module = nullptr;
}
class DataType
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class Data
{
friend class DataDictionaryInterface;
friend class DataDictionaryObjectInterface;
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
template <typename DEST, typename SRC> Result<void> SetImpl(SRC&& data, OverloadRank0);
template <typename DEST> Result<void> SetImpl(const Data& data, OverloadRank1);
template <typename DEST> Result<void> SetImpl(Data& data, OverloadRank1);
template <typename T> Result<void> SetImpl(T&& data, OverloadRank0);
// Changed to
template <typename DEST> Result<void> SetImpl(Data&& data, OverloadRank1);
template <typename T> typename std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void>>::type SetImpl(T&& data, OverloadRank1);
// Changed to
template <typename DEST, typename SRC> typename std::enable_if<GetCollectionKind<SRC>::value == COLLECTION_KIND::ARRAY, Result<void>>::type SetImpl(SRC&& data, OverloadRank1);
}
class ConstDataPtr
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class MoveDataPtr
{
static void Construct(const DataTypeImpl* type, void* dest, Int count);
// Changed to
static void Construct(const DataTypeImpl* type, void* dest, Int dstride, Int count);
static void Destruct(const DataTypeImpl* type, const void* dest, Int count);
// Changed to
static void Destruct(const DataTypeImpl* type, const void* dest, Int dstride, Int count);
static void MoveConstruct(const DataTypeImpl* type, void* dest, void* src, Int count);
// Changed to
static void MoveConstruct(const DataTypeImpl* type, void* dest, Int dstride, void* src, Int sstride, Int count);
static void MoveFrom(const DataTypeImpl* type, void* dest, void* src, Int count);src);
// Changed to
static void MoveFrom(const DataTypeImpl* type, void* dest, Int dstride, void* src, Int sstride, Int count);
static Result<void> CopyFrom(const DataTypeImpl* type, void* dest, const void* src, Int count);
// Changed to
static Result<void> CopyFrom(const DataTypeImpl* type, void* dest, Int dstride, const void* src, Int sstride, Int count);
// Removed
static Result<Bool> UpdateFrom(const DataTypeImpl* type, void* dest, const void* src);
static UInt GetHashCode(const DataTypeImpl* type, const void* a);
// Changed to
static HashInt GetHashCode(const DataTypeImpl* type, const void* a);
static HashValue GetHashValue(const DataTypeImpl* type, const void* a);
}

maxon/datatypefunctions.h

template <typename T> class DefaultDataTypeFunctionsBase : public DataTypeReferenceFunctions<T, EmptyClass>
{
static void Construct(const DataTypeImpl*, void* dest, Int count)
// Changed to
static void Construct(const DataTypeImpl*, void* dest, Int dstride, Int count)
static void Destruct(const DataTypeImpl*, const void* dest, Int count)
// Changed to
static void Destruct(const DataTypeImpl*, const void* dest, Int dstride, Int count)
static void MoveConstruct(const DataTypeImpl*, void* dest, void* src, Int count)
// Changed to
static void MoveConstruct(const DataTypeImpl*, void* dest, Int dstride, void* src, Int sstride, Int count)
static void MoveFrom(const DataTypeImpl*, void* dest, void* src, Int count)
// Changed to
static void MoveFrom(const DataTypeImpl*, void* dest, Int dstride, void* src, Int sstride, Int count)
static Result<void> CopyFrom(const DataTypeImpl*, void* dest, const void* src, Int count)
// Changed to
static Result<void> CopyFrom(const DataTypeImpl*, void* dest, Int dstride, const void* src, Int sstride, Int count)
// Removed
static Result<Bool> UpdateFrom(const DataTypeImpl* type, void* dest, const void* src)
static UInt GetHashCode(const DataTypeImpl*, const void* s1) { return CompareTemplate<true>::GetHashCode(*(const T*)s1); }
// Changed to
static HashInt GetHashCode(const DataTypeImpl*, const void* s1) { return CompareTemplate<true>::GetHashCode(*(const T*)s1); }
static HashValue GetHashValue(const DataTypeImpl*, const void* s1) { return {CompareTemplate<true>::GetHashCode(*(const T*)s1), 0}; }
}
template <typename T> class InterfaceDataTypeFunctions : public DataTypeReferenceFunctions<T, AbstractDataTypeFunctions>
{
static UInt GetHashCode(const DataTypeImpl* type, const void* a)
// Changed to
static HashInt GetHashCode(const DataTypeImpl* type, const void* a)
}

maxon/datatypefunctions.h

class InternedId
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
struct Member
{
Member() = default;
MAXON_IMPLICIT Member(const DataType& t = DataType::NullValue(), const InternedId& n = InternedId()) : type(t), name(n)
// Changed to
MAXON_IMPLICIT Member(const DataType& t, const InternedId& n = InternedId()) : type(t), name(n)
MAXON_IMPLICIT Member(DataType&& t, InternedId&& n = InternedId()) : type(std::move(t)), name(std::move(n))
}
struct TypeArguments
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class DataTypeLib
{
static MAXON_METHOD Result<const MemberMap*> PrivateGetMemberMap(const DataTypeImpl* containerType, const DataTypeImpl* runtimeType);
// Changed to
static MAXON_METHOD Result<const MemberMap*> GetMemberMap(const DataTypeImpl* containerType, const DataTypeImpl* runtimeType);
}

maxon/datetime.h

class LocalDateTime
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class UniversalDateTime
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/errorbase.h

// Removed
#define MAXON_ERROR_REGISTERX(error, baseclass, id)

maxon/foreach.h

template <typename C> class AutoIterator : public ForEachIterator<AutoIterator<C>>
{
template <typename SUPER> using ResultFunctions = ResultIteratorFunctions<SUPER>;
}
template <typename FILTER, typename I> class FilterForEachIterator : public ForEachIterator<FilterForEachIterator<FILTER, I>>
{
FilterForEachIterator() = default;
}

maxon/generic_basearray.h

class GenericBaseArray : private BaseArray<Char>
{
ResultMem EnsureCapacity(const DataType& elementType, Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags);
// Changed to
ResultMem EnsureCapacity(const DataType& elementType, Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags = COLLECTION_RESIZE_FLAGS::DEFAULT);
ResultMem SetCapacityHint(const DataType& elementType, Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags)
// Changed to
ResultMem SetCapacityHint(const DataType& elementType, Int requestedCapacity, COLLECTION_RESIZE_FLAGS resizeFlags = COLLECTION_RESIZE_FLAGS::DEFAULT)
ResultRef<Generic> Append(const DataType& elementType);
UInt GetHashCode(const DataType& elementType) const;
// Changed to
HashInt GetHashCode(const DataType& elementType) const;
Int GetMemorySize(const DataType& elementType) const
}

maxon/hashmap.h

template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT LAYOUT = ENTRY_HANDLER::LAYOUT> class HashMapEntryBase
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE_KEY>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE_KEY>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename V, typename HASH = DefaultCompare, typename ENTRY_HANDLER = HashMapKeyValuePair, typename ALLOCATOR = DefaultAllocator, HASHMAP_MODE MODE = HASHMAP_MODE::DEFAULT, Int INITIAL_CAPACITY = 16, Int LOAD_FACTOR = (MODE == HASHMAP_MODE::SYNCHRONIZED) ? 0 : 10> class HashMap
: public MapBase<HashMap<K, V, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR>, K, V, EmptyClass, HASH>
{
template <typename VALUEHASH> class Hash
{
static UInt GetHashCode(const HashMap& m)
// Changed to
static HashInt GetHashCode(const HashMap& m)
}
}
template <typename T, typename HASH = DefaultCompare, typename ENTRY_HANDLER = HashMapKeyValuePair, typename ALLOCATOR = DefaultAllocator, HASHMAP_MODE MODE = HASHMAP_MODE::DEFAULT, Int INITIAL_CAPACITY = 16, Int LOAD_FACTOR = (MODE == HASHMAP_MODE::SYNCHRONIZED) ? 0 : 10> class HashSet
: public SetBase<HashSet<T, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR>, T, Protected<HashMap<T, UnitType, HASH, ENTRY_HANDLER, ALLOCATOR, MODE, INITIAL_CAPACITY, LOAD_FACTOR>>, HASH>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/hierarchyobject.h

class HierarchyObjectInterface : MAXON_INTERFACE_BASES(ObserverObjectInterface)
{
// Removed
MAXON_OBSERVABLE(Result<void>, DeprecatedObservableHierarchyInsert, (const HierarchyObjectRef<>& sender, const HierarchyObjectRef<>& object), ObservableCombinerRunAllComponent);
// Removed
MAXON_OBSERVABLE(Result<void>, DeprecatedObservableHierarchyRemove, (const HierarchyObjectRef<>& sender, const HierarchyObjectRef<>& object), ObservableCombinerRunAllComponent);
}

maxon/interfacebase.h

class ClassInterface;
class ClassInfo;
class NonvirtualInterfaceImplementation
{
template <typename C> NonvirtualInterfaceImplementation(C* dummy, const Char* clsName, const NonvirtualInterfaceReference& ref, NonvirtualInterfaceReference::MTableInitializer init, EntityBase::FLAGS flags, TranslationUnit* unit, const Char* file)
// Changed to
template <typename C> NonvirtualInterfaceImplementation(C* dummy, const Char* clsName, const Char* cppName, const NonvirtualInterfaceReference& ref, NonvirtualInterfaceReference::MTableInitializer init, EntityBase::FLAGS flags, TranslationUnit* unit, const Char* file)
}
template <typename SUPER> class RefBaseFunctions : public SUPER
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/ioconnection.h

class IoConnectionInterface
{
MAXON_OBSERVABLE_STATIC(Bool, ObservableErrorOpenFile, (const Url& url, OPENSTREAMFLAGS flags), ObservableCombinerRunAllBoolUntilFalse);
}

maxon/ioenums.h

maxon/jobqueue.h

class JobQueueInterface
{
MAXON_METHOD void EnableThreadAffinity(UInt ownerId);
}

maxon/legacyhash.h

#define PRIVATE_MAXON_HASHCODE1(m1) maxon::LegacyHash::GetHashCode(m1)
#define PRIVATE_MAXON_HASHCODE2(m1, m2) (PRIVATE_MAXON_HASHCODE1(m1) * 31 + maxon::LegacyHash::GetHashCode(m2))
#define PRIVATE_MAXON_HASHCODE3(m1, m2, m3) (PRIVATE_MAXON_HASHCODE2(m1, m2) * 31 + maxon::LegacyHash::GetHashCode(m3))
#define PRIVATE_MAXON_HASHCODE4(m1, m2, m3, m4) (PRIVATE_MAXON_HASHCODE3(m1, m2, m3) * 31 + maxon::LegacyHash::GetHashCode(m4))
#define PRIVATE_MAXON_HASHCODE5(m1, m2, m3, m4, m5) (PRIVATE_MAXON_HASHCODE4(m1, m2, m3, m4) * 31 + maxon::LegacyHash::GetHashCode(m5))
#define PRIVATE_MAXON_HASHCODE6(m1, m2, m3, m4, m5, m6) (PRIVATE_MAXON_HASHCODE5(m1, m2, m3, m4, m5) * 31 + maxon::LegacyHash::GetHashCode(m6))
#define PRIVATE_MAXON_HASHCODE7(m1, m2, m3, m4, m5, m6, m7) (PRIVATE_MAXON_HASHCODE6(m1, m2, m3, m4, m5, m6) * 31 + maxon::LegacyHash::GetHashCode(m7))
#define PRIVATE_MAXON_HASHCODE8(m1, m2, m3, m4, m5, m6, m7, m8) (PRIVATE_MAXON_HASHCODE7(m1, m2, m3, m4, m5, m6, m7) * 31 + maxon::LegacyHash::GetHashCode(m8))
#define PRIVATE_MAXON_HASHCODE9(m1, m2, m3, m4, m5, m6, m7, m8, m9) (PRIVATE_MAXON_HASHCODE8(m1, m2, m3, m4, m5, m6, m7, m8) * 31 + maxon::LegacyHash::GetHashCode(m9))
#define PRIVATE_MAXON_HASHCODE10(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) (PRIVATE_MAXON_HASHCODE9(m1, m2, m3, m4, m5, m6, m7, m8, m9) * 31 + maxon::LegacyHash::GetHashCode(m10))
#define PRIVATE_MAXON_HASHCODE11(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) (PRIVATE_MAXON_HASHCODE10(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10) * 31 + maxon::LegacyHash::GetHashCode(m11))
#define PRIVATE_MAXON_HASHCODE12(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) (PRIVATE_MAXON_HASHCODE11(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11) * 31 + maxon::LegacyHash::GetHashCode(m12))
#define PRIVATE_MAXON_HASHCODE13(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) (PRIVATE_MAXON_HASHCODE12(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12) * 31 + maxon::LegacyHash::GetHashCode(m13))
#define PRIVATE_MAXON_HASHCODE14(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) (PRIVATE_MAXON_HASHCODE13(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13) * 31 + maxon::LegacyHash::GetHashCode(m14))
#define PRIVATE_MAXON_HASHCODE15(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15) (PRIVATE_MAXON_HASHCODE14(m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14) * 31 + maxon::LegacyHash::GetHashCode(m15))
#define PRIVATE_MAXON_HASHCODE_C(count, ...) MAXON_EXPAND(PRIVATE_MAXON_HASHCODE##count(__VA_ARGS__))
#define PRIVATE_MAXON_HASHCODE_B(count, ...) PRIVATE_MAXON_HASHCODE_C(count, __VA_ARGS__)
#define PRIVATE_MAXON_HASHCODE_A(count, ...) PRIVATE_MAXON_HASHCODE_B(count, __VA_ARGS__)
#define MAXON_HASHCODE_LEGACY(...) PRIVATE_MAXON_HASHCODE_A(MAXON_VA_NARGS(__VA_ARGS__), __VA_ARGS__)
struct LegacyHash : public DefaultCompare
{
#ifdef MAXON_TARGET_64BIT
#else
#endif
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Bool i)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Char i)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(UChar i)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Int16 i)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Int32 h)
static UInt GetHashCode(Utf16Char i)
static UInt GetHashCode(Utf32Char i)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(Int64 h)
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const T* key)
template <typename T> static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(T* key)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(std::nullptr_t)
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const Tuple<Int, Int>& tuple)
};

maxon/lib_math.h

#define MATH_SQUAREMATRIX SqrMat3<Vec3<FLOAT>>
template <typename FLOAT>
template <typename FLOAT>
template <typename FLOAT>
MATH_MATRIX VectorToMatrix(const MATH_VECTOR& dirVector, const MATH_VECTOR& upVector);
#define MATH_SQUAREMATRIX2 SqrMat2<Vec2<FLOAT>>

maxon/machineinfo.h

namespace MACHINEINFO
{
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, LANGUAGES, "net.maxon.machineinfo.languages");
// Changed to
MAXON_ATTRIBUTE(BaseArray<Id>, LANGUAGES, "net.maxon.machineinfo.languages");
}

maxon/map.h

template <typename K, typename V> class MapInterface : public MapBase0<MapInterface<K, V>, K, V, EmptyClass, DefaultCompare>
{
MAXON_ADD_TO_CONST_REFERENCE_CLASS(UInt GetHashCode() const { CriticalStop("Not implemented."); return 0; };);
// Changed to
MAXON_ADD_TO_CONST_REFERENCE_CLASS(HashInt GetHashCode() const { CriticalStop("Not implemented."); return 0; };);
}

maxon/matrix.h

template <typename V> struct SqMat3
// Changed to
template <typename V> struct SqrMat3
{
SqMat3() : v1(ValueType(1), ValueType(0), ValueType(0)), v2(ValueType(0), ValueType(1), ValueType(0)), v3(ValueType(0), ValueType(0), ValueType(1))
// Changed to
constexpr SqrMat3() : v1(ValueType(1), ValueType(0), ValueType(0)), v2(ValueType(0), ValueType(1), ValueType(0)), v3(ValueType(0), ValueType(0), ValueType(1))
SqMat3(const V& v1_in, const V& v2_in, const V& v3_in) : v1(v1_in), v2(v2_in), v3(v3_in) { }
// Changed to
constexpr SqrMat3(const V& v1_in, const V& v2_in, const V& v3_in) : v1(v1_in), v2(v2_in), v3(v3_in) { }
template <typename V2> explicit SqMat3(const SqMat3<V2>& m) : v1(m.v1), v2(m.v2), v3(m.v3) { }
// Changed to
template <typename V2> explicit constexpr SqrMat3(const SqrMat3<V2>& m) : v1(m.v1), v2(m.v2), v3(m.v3) { }
// Changed to
explicit constexpr SqrMat3(ENUM_DONT_INITIALIZE v) : v1(maxon::DONT_INITIALIZE), v2(maxon::DONT_INITIALIZE), v3(maxon::DONT_INITIALIZE) { }
template <typename V2> explicit SqMat3(const SqMat2<V2>& m) :
// Changed to
template <typename V2> explicit constexpr SqrMat3(const SqrMat2<V2>& m) :
template <typename V2> SqMat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat3<V2>& m2) const
// Changed to
template <typename V2> SqrMat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat3<V2>& m2) const
friend SqMat3 operator *(ValueTypeParam s, const SqMat3& m)
// Changed to
friend SqrMat3 operator *(ValueTypeParam s, const SqrMat3& m)
SqMat3 operator *(ValueTypeParam s) const
// Changed to
SqrMat3 operator *(ValueTypeParam s) const
SqMat3 operator /(ValueTypeParam s) const
// Changed to
SqrMat3 operator /(ValueTypeParam s) const
SqMat3 operator +(const SqMat3& m2) const
// Changed to
SqrMat3 operator +(const SqrMat3& m2) const
SqMat3 operator -(const SqMat3& m2) const
// Changed to
SqrMat3 operator -(const SqrMat3& m2) const
BoolType operator ==(const SqMat3& other) const
// Changed to
BoolType operator ==(const SqrMat3& other) const
BoolType operator !=(const SqMat3& other) const
// Changed to
BoolType operator !=(const SqrMat3& other) const
SqMat3 operator ~() const
// Changed to
SqrMat3 operator ~() const
SqMat3 GetNormalized() const
// Changed to
SqrMat3 GetNormalized() const
SqMat3 GetTransposed() const
// Changed to
SqrMat3 GetTransposed() const
SqMat3 GetTensorMatrix() const
// Changed to
SqrMat3 GetTensorMatrix() const
SqMat3& operator *=(const V& v)
// Changed to
SqrMat3& operator *=(const V& v)
SqMat3& operator *=(ValueTypeParam r)
// Changed to
SqrMat3& operator *=(ValueTypeParam r)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
static const SqMat3& NullValue()
// Changed to
static const SqrMat3& NullValue()
SqMat3<V> sqmat;
// Changed to
SqrMat3<V> sqmat;
Mat3() : off(), sqmat() { }
// Changed to
constexpr Mat3() : off(), sqmat() { }
Mat3(const V& off_in, const V& v1_in, const V& v2_in, const V& v3_in) : off(off_in), sqmat(v1_in, v2_in, v3_in) { }
// Changed to
constexpr Mat3(const V& off_in, const V& v1_in, const V& v2_in, const V& v3_in) : off(off_in), sqmat(v1_in, v2_in, v3_in) { }
Mat3(const V& off_in, const SqMat3<V>& mat_in) : off(off_in), sqmat(mat_in) { }
// Changed to
constexpr Mat3(const V& off_in, const SqrMat3<V>& mat_in) : off(off_in), sqmat(mat_in) { }
MAXON_IMPLICIT Mat3(const SqMat3<V>& mat_in) : off(), sqmat(mat_in) { }
// Changed to
MAXON_IMPLICIT constexpr Mat3(const SqrMat3<V>& mat_in) : off(), sqmat(mat_in) { }
template <typename V2> explicit Mat3(const Mat3<V2>& m) : off(m.off), sqmat(m.sqmat) { }
// Changed to
template <typename V2> explicit constexpr Mat3(const Mat3<V2>& m) : off(m.off), sqmat(m.sqmat) { }
explicit Mat3(ENUM_DONT_INITIALIZE v) : off(maxon::DONT_INITIALIZE), sqmat(maxon::DONT_INITIALIZE) { }
// Changed to
explicit constexpr Mat3(ENUM_DONT_INITIALIZE v) : off(maxon::DONT_INITIALIZE), sqmat(maxon::DONT_INITIALIZE) { }
template <typename V2> explicit Mat3(const Mat2<V2>& m) : off(m.off), sqmat(m.sqmat) { }
// Changed to
template <typename V2> explicit constexpr Mat3(const Mat2<V2>& m) : off(m.off), sqmat(m.sqmat) { }
template <typename V2> Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat3<V2>& m2) const
// Changed to
template <typename V2> Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat3<V2>& m2) const
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename V, typename V2> inline Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat3<V>& m, const Mat3<V2>& m2)
// Changed to
template <typename V, typename V2> inline Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat3<V>& m, const Mat3<V2>& m2)
using SquareMatrix32 = SqMat3<Vector32>;
// Changed to
using SquareMatrix32 = SqrMat3<Vector32>;
using SquareMatrix64 = SqMat3<Vector64>;
// Changed to
using SquareMatrix64 = SqrMat3<Vector64>;
using SquareMatrix = SqMat3<Vector>;
// Changed to
using SquareMatrix = SqrMat3<Vector>;
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqMat3<T>**, OverloadRank1)
// Changed to
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqrMat3<T>**, OverloadRank1)
template <typename T> struct IsZeroInitialized<SqMat3<T>> : public IsZeroInitialized<T> { };
// Changed to
template <typename T> struct IsZeroInitialized<SqrMat3<T>> : public IsZeroInitialized<T> { };

maxon/matrix2d.h

template <typename V> struct SqMat2
// Changed to
template <typename V> struct SqrMat2
{
SqMat2() : v1(ValueType(1), ValueType(0)), v2(ValueType(0), ValueType(1))
// Changed to
constexpr SqrMat2() : v1(ValueType(1), ValueType(0)), v2(ValueType(0), ValueType(1))
SqMat2(const V& v1_in, const V& v2_in) : v1(v1_in), v2(v2_in) { }
// Changed to
constexpr SqrMat2(const V& v1_in, const V& v2_in) : v1(v1_in), v2(v2_in) { }
template <typename V2> explicit SqMat2(const SqMat2<V2>& m) : v1(m.v1), v2(m.v2) { }
// Changed to
template <typename V2> explicit constexpr SqrMat2(const SqrMat2<V2>& m) : v1(m.v1), v2(m.v2) { }
explicit SqMat2(ENUM_DONT_INITIALIZE v) : v1(v), v2(v) { }
// Changed to
explicit constexpr SqrMat2(ENUM_DONT_INITIALIZE v) : v1(v), v2(v) { }
template <typename V2> SqMat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat2<V2>& m2) const
// Changed to
template <typename V2> SqrMat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat2<V2>& m2) const
friend SqMat2 operator *(ValueTypeParam s, const SqMat2& m)
// Changed to
friend SqrMat2 operator *(ValueTypeParam s, const SqrMat2& m)
SqMat2 operator *(ValueTypeParam s) const
// Changed to
SqrMat2 operator *(ValueTypeParam s) const
SqMat2 operator /(ValueTypeParam s) const
// Changed to
SqrMat2 operator /(ValueTypeParam s) const
SqMat2 operator +(const SqMat2& m2) const
// Changed to
SqrMat2 operator +(const SqrMat2& m2) const
SqMat2 operator
// Changed to
SqrMat2 operator
BoolType operator ==(const SqMat2& other) const
// Changed to
BoolType operator ==(const SqrMat2& other) const
BoolType operator !=(const SqMat2& other) const
// Changed to
BoolType operator !=(const SqrMat2& other) const
SqMat2 operator ~() const
// Changed to
SqrMat2 operator ~() const
SqMat2 GetNormalized() const
// Changed to
SqrMat2 GetNormalized() const
SqMat2& operator *=(const V& v)
// Changed to
SqrMat2& operator *=(const V& v)
SqMat2& operator *=(ValueTypeParam r)
// Changed to
SqrMat2& operator *=(ValueTypeParam r)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
static const SqMat2& NullValue()
// Changed to
static const SqrMat2& NullValue()
SqMat2<V> sqmat;
// Changed to
SqrMat2<V> sqmat;
Mat2(const V& off_in, const SqMat2<V>& mat_in) : off(off_in), sqmat(mat_in) { }
// Changed to
Mat2(const V& off_in, const SqrMat2<V>& mat_in) : off(off_in), sqmat(mat_in) { }
MAXON_IMPLICIT Mat2(const SqMat2<V>& mat_in) : off(), sqmat(mat_in) { }
// Changed to
MAXON_IMPLICIT Mat2(const SqrMat2<V>& mat_in) : off(), sqmat(mat_in) { }
template <typename V2> Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat2<V2>& m2) const
// Changed to
template <typename V2> Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat2<V2>& m2) const
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename V, typename V2> inline Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat2<V>& m, const Mat2<V2>& m2)
// Changed to
template <typename V, typename V2> inline Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat2<V>& m, const Mat2<V2>& m2)
using SquareMatrix2d32 = SqMat2<Vector2d32>;
// Changed to
using SquareMatrix2d32 = SqrMat2<Vector2d32>;
using SquareMatrix2d64 = SqMat2<Vector2d64>;
// Changed to
using SquareMatrix2d64 = SqrMat2<Vector2d64>;
using SquareMatrix2d = SqMat2<Vector2d>;
// Changed to
using SquareMatrix2d = SqrMat2<Vector2d>;
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqMat2<T>**, OverloadRank1)
// Changed to
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqrMat2<T>**, OverloadRank1)
template <typename T> struct IsZeroInitialized<SqMat2<T>> : public IsZeroInitialized<T> { };
// Changed to
template <typename T> struct IsZeroInitialized<SqrMat2<T>> : public IsZeroInitialized<T> { };

maxon/matrix4d.h

template <typename V> struct SqMat4
// Changed to
template <typename V> struct SqrMat4
{
SqMat4() : v1(ValueType(1), ValueType(0), ValueType(0), ValueType(0)), v2(ValueType(0), ValueType(1), ValueType(0), ValueType(0)),
// Changed to
constexpr SqrMat4() : v1(ValueType(1), ValueType(0), ValueType(0), ValueType(0)), v2(ValueType(0), ValueType(1), ValueType(0), ValueType(0)),
SqMat4(const V& v1_in, const V& v2_in, const V& v3_in, const V& v4_in) : v1(v1_in), v2(v2_in), v3(v3_in), v4(v4_in) { }
// Changed to
constexpr SqrMat4(const V& v1_in, const V& v2_in, const V& v3_in, const V& v4_in) : v1(v1_in), v2(v2_in), v3(v3_in), v4(v4_in) { }
template <typename V2> explicit SqMat4(const SqMat4<V2>& m) : v1(m.v1), v2(m.v2), v3(m.v3), v4(m.v4) { }
// Changed to
template <typename V2> explicit constexpr SqrMat4(const SqrMat4<V2>& m) : v1(m.v1), v2(m.v2), v3(m.v3), v4(m.v4) { }
template <typename V2> explicit SqMat4(const Mat3<V2>& m) : v1(m.sqmat.v1, typename V2::ValueType(0)), v2(m.sqmat.v2, typename V2::ValueType(0)), v3(m.sqmat.v3, typename V2::ValueType(0)), v4(m.off, typename V2::ValueType(1)) { }
// Changed to
template <typename V2> explicit constexpr SqrMat4(const Mat3<V2>& m) : v1(m.sqmat.v1, typename V2::ValueType(0)), v2(m.sqmat.v2, typename V2::ValueType(0)), v3(m.sqmat.v3, typename V2::ValueType(0)), v4(m.off, typename V2::ValueType(1)) { }
explicit SqMat4(ENUM_DONT_INITIALIZE v) : v1(v), v2(v), v3(v), v4(v) { }
// Changed to
explicit constexpr SqrMat4(ENUM_DONT_INITIALIZE v) : v1(v), v2(v), v3(v), v4(v) { }
template <typename V2> SqMat4<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat4<V2>& m2) const
// Changed to
template <typename V2> SqrMat4<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat4<V2>& m2) const
friend SqMat4 operator *(ValueTypeParam s, const SqMat4& m)
// Changed to
friend SqrMat4 operator *(ValueTypeParam s, const SqrMat4& m)
SqMat4 operator *(ValueTypeParam s) const
// Changed to
SqrMat4 operator *(ValueTypeParam s) const
SqMat4 operator /(ValueTypeParam s) const
// Changed to
SqrMat4 operator /(ValueTypeParam s) const
SqMat4 operator +(const SqMat4& m2) const
// Changed to
SqrMat4 operator +(const SqrMat4& m2) const
SqMat4 operator
// Changed to
SqrMat4 operator
BoolType operator ==(const SqMat4& other) const
// Changed to
BoolType operator ==(const SqrMat4& other) const
BoolType operator !=(const SqMat4& other) const
// Changed to
BoolType operator !=(const SqrMat4& other) const
SqMat4 operator ~() const
// Changed to
SqrMat4 operator ~() const
SqMat4 GetNormalized() const
// Changed to
SqrMat4 GetNormalized() const
SqMat4 GetTransposed() const
// Changed to
SqrMat4 GetTransposed() const
SqMat4& operator *=(const V& v)
// Changed to
SqrMat4& operator *=(const V& v)
SqMat4& operator *=(ValueTypeParam r)
// Changed to
SqrMat4& operator *=(ValueTypeParam r)
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
static const SqMat4& NullValue()
// Changed to
static const SqrMat4& NullValue()
}
using SquareMatrix4d32 = SqMat4<Vector4d32>;
// Changed to
using SquareMatrix4d32 = SqrMat4<Vector4d32>;
using SquareMatrix4d64 = SqMat4<Vector4d64>;
// Changed to
using SquareMatrix4d64 = SqrMat4<Vector4d64>;
using SquareMatrix4d = SqMat4<Vector4d>;
// Changed to
using SquareMatrix4d = SqrMat4<Vector4d>;
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqMat4<T>**, OverloadRank1)
// Changed to
template <GET_DATATYPE_POLICY POLICY, typename T> inline Result<DataType> PrivateGetDataType(SqrMat4<T>**, OverloadRank1)
template <typename T> struct IsZeroInitialized<SqMat4<T>> : public IsZeroInitialized<T> { };
// Changed to
template <typename T> struct IsZeroInitialized<SqrMat4<T>> : public IsZeroInitialized<T> { };

maxon/moduleversioninfo.h

namespace MODULEVERSIONINFO
{
MAXON_ATTRIBUTE(BaseArray<maxon::String>, USEDINMODULE, "net.maxon.moduleversioninfo.usedinmodule");
// Changed to
MAXON_ATTRIBUTE(BaseArray<String>, USEDINMODULE, "net.maxon.moduleversioninfo.usedinmodule");
}

maxon/objectbase.h

class InterfaceDefinition
{
InterfaceDefinition(const InterfaceReference& ref, TranslationUnit* unit, EntityBase::FLAGS flags);
// Changed to
InterfaceDefinition(const InterfaceReference& ref, TranslationUnit* unit, EntityBase::FLAGS flags, const Char* cppName);
inline const Char* GetCppName() const
}
class ObjectInterface : protected ObjectSuper
{
MAXON_METHOD Result<void> InitObject();
// Changed to
MAXON_METHOD Result<void> InitObject(const void* argument);
MAXON_METHOD Result<void> HandleMessage(const InternedId& message, const void* argument);
MAXON_FUNCTION UInt GetHashCode() const { return GetHashCodeImpl(); }
// Changed to
MAXON_FUNCTION HashInt GetHashCode() const { return GetHashCodeImpl(); }
MAXON_METHOD UInt GetHashCodeImpl() const;
//Changed to
MAXON_METHOD HashInt GetHashCodeImpl() const;
MAXON_METHOD HashValue GetHashValueImpl() const;
}
template <typename R, typename SRC, typename RESULT = typename CastHelper<R, SRC>::AssertCastType> inline RESULT AssertCast(SRC&& ref)
// Changed to
template <typename R, typename SRC, typename RESULT = typename maxon::details::CastHelper<R, SRC>::AssertCastType> inline RESULT AssertCast(SRC&& ref)
template <typename R, typename SRC, typename RESULT = typename CastHelper<R, SRC>::type> inline RESULT Cast(SRC&& ref)
// Changed to
template <typename R, typename SRC, typename RESULT = typename maxon::details::CastHelper<R, SRC>::type> inline RESULT Cast(SRC&& ref)
template <typename R, typename SRC> inline typename SFINAEHelper<Result<R>, typename R::ReferencedType, typename SRC::ReferencedType>::type Cast(Result<SRC>&& src)
// Changed to
template <typename R, typename SRC, typename RESULT = typename maxon::details::CastHelper<R, SRC>::type> inline Result<RESULT> Cast(Result<SRC>&& src)
template <typename R, typename SRC> inline typename SFINAEHelper<Result<R>, typename R::ReferencedType, typename SRC::ReferencedType>::type AssertCast(Result<SRC>&& src)
// Changed to
template <typename R, typename SRC, typename RESULT = typename maxon::details::CastHelper<R, SRC>::type> inline Result<RESULT> AssertCast(Result<SRC>&& src)
{
#define MAXON_COMPONENT_SIMPLE(I)
}
template <typename... INTERFACES> const InterfaceReference* const InterfacesBlock<INTERFACES...>::value[sizeof...(INTERFACES)] = { &INTERFACES::_interface... };
// Changed to
template <typename... INTERFACES> const InterfaceReference* const InterfacesBlock<INTERFACES...>::value[sizeof...(INTERFACES)] = { INTERFACES::PrivateGetInterface()... };
inline Id GetFunctionName(const Char* funcName)
// Changed to
constexpr inline const Char* GetFunctionName(const Char* funcName)
#define MAXON_FUNCTIONNAME maxon::GetFunctionName(__FUNCTION__)
// Changed to
#define MAXON_FUNCTIONNAME maxon::Id(maxon::GetFunctionName(__FUNCTION__))

maxon/observable.h

static constexpr Int ADDOBSERVER_DEFAULTPRIORITY = 0;
class ObservableBaseInterface
{
MAXON_METHOD Result<void> AddObserver(ObserverObjectInterface* observer, const FunctionBaseRef& observerFunction);
// Changed to
MAXON_METHOD Result<void> AddObserver(ObserverObjectInterface* observer, const FunctionBaseRef& observerFunction, Int priority = ADDOBSERVER_DEFAULTPRIORITY);
}
template <typename DELEGATE> class MAXON_WARN_UNUSED_CLASS ObservableRef : public ObservableNotifyRef<typename DELEGATE::Super>
{
template <typename FN> Result<FunctionBaseRef> AddObserver(ObserverObjectInterface* observer, FN&& fn) const
// Changed to
template <typename FN> Result<FunctionBaseRef> AddObserver(ObserverObjectInterface* observer, FN&& fn, Int priority = ADDOBSERVER_DEFAULTPRIORITY) const
template <typename FN> Result<FunctionBaseRef> AddObserver(ObserverObjectInterface* observer, FN&& fn, const JobQueueRef& queue) const
// Changed to
template <typename FN> Result<FunctionBaseRef> AddObserver(ObserverObjectInterface* observer, FN&& fn, const JobQueueRef& queue, Int priority = ADDOBSERVER_DEFAULTPRIORITY) const
template <typename FN> Result<FunctionBaseRef> AddObserver(FN&& fn) const
// Changed to
template <typename FN> Result<FunctionBaseRef> AddObserver(FN&& fn, Int priority = ADDOBSERVER_DEFAULTPRIORITY) const
template <typename FN, typename = typename std::enable_if<!STD_IS_REPLACEMENT(convertible, typename std::decay<FN>::type, ObserverObjectInterface*)>::type> Result<FunctionBaseRef> AddObserver(FN&& fn, const JobQueueRef& queue) const
// Changed to
template <typename FN, typename = typename std::enable_if<!STD_IS_REPLACEMENT(convertible, typename std::decay<FN>::type, ObserverObjectInterface*)>::type> Result<FunctionBaseRef> AddObserver(FN&& fn, const JobQueueRef& queue, Int priority = ADDOBSERVER_DEFAULTPRIORITY) const
}

maxon/optional.h

class Opt
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename T>
class Opt<const T&>
{
const T& GetValueOr(T&& defaultValue) const = delete;
// Changed to
T GetValueOr(T&& defaultValue) const
}

maxon/parametric_type.h

class ParametricTypeDecorator
{
static Result<DataType> Instantiate(const DataType& type, const ParametricType& decoType)
template <typename TYPEDECORATOR1, typename... TYPEDECORATOR>
static Result<DataType> Instantiate(const DataType& type, TYPEDECORATOR1 decoType, TYPEDECORATOR... decoTypes)
}

maxon/partialorder.h

template <typename T, typename ARRAY = BaseArraySelector<>, typename COMPARE = DefaultCompare, Bool KEEP_DUPLICATES = false, Bool MINIMAL = false> class MaximalElements : private ARRAY::template Type<T>
{
using Super::operator [];
// Removed
const T& operator [](Int index) const { return Super::operator [](index); }
}

maxon/range.h

template <typename T> class Range
{
Range() : _minValue(LIMIT<ScalarType>::Max()), _maxValue(LIMIT<ScalarType>::Min()) { }
// Changed to
constexpr Range() : _minValue(LIMIT<ScalarType>::MAX), _maxValue(LIMIT<ScalarType>::MIN) { }
explicit Range(const T& v) : _minValue(v), _maxValue(v) { }
// Changed to
explicit constexpr Range(const T& v) : _minValue(v), _maxValue(v) { }
Range(const T& rangeMin, const T& rangeMax) : _minValue(rangeMin), _maxValue(rangeMax) { }
// Changed to
constexpr Range(const T& rangeMin, const T& rangeMax) : _minValue(rangeMin), _maxValue(rangeMax) { }
void Reset() { _minValue = T(LIMIT<ScalarType>::Max()); _maxValue = T(LIMIT<ScalarType>::Min()); }
// Changed to
void Reset() { _minValue = T(LIMIT<ScalarType>::MAX); _maxValue = T(LIMIT<ScalarType>::MIN); }
}

maxon/rangemap.h

template <typename K> struct RangeSetPair
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class RangeMap
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
template <typename T, typename MAP = BurstTrieMapSelector<>> class RangeSet : private RangeMap<T, UnitType, MAP>
{
// Removed
using Super::GetHashCode;
HashInt GetHashCode() const
}
template <typename RANGETYPE>
Int GetRangeItemCount(const RANGETYPE& data);

maxon/set.h

template <typename TYPE> class SetInterface : public SetBase0<SetInterface<TYPE>, TYPE, EmptyClass, DefaultCompare>
{
MAXON_ADD_TO_CONST_REFERENCE_CLASS(UInt GetHashCode() const { CriticalStop("Not implemented."); return 0; };);
// Changed to
MAXON_ADD_TO_CONST_REFERENCE_CLASS(HashInt GetHashCode() const { CriticalStop("Not implemented."); return 0; };);
}

maxon/sse_vector4i32.h

class Vector4i32
{
MAXON_ATTRIBUTE_FORCE_INLINE explicit Vector4i32(Int32 i)
// Changed to
MAXON_ATTRIBUTE_FORCE_INLINE explicit Vector4i32(Int32 i, Bool setAll = true)
static MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 UnpackLow(const Vector4i32& a, const Vector4i32& b)
static MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 UnpackHigh(const Vector4i32& a, const Vector4i32& b)
}

maxon/streamconversion.h

namespace STREAMCONVERSIONTEST
{
MAXON_ATTRIBUTE(BaseArray<ConversionTestSet>, CONVERSIONTESTSET, "net.maxon.streamconversiontest.conversiontestset");
// Changed to
MAXON_ATTRIBUTE(Array<ConversionTestSet>, CONVERSIONTESTSET, "net.maxon.streamconversiontest.conversiontestset");
MAXON_ATTRIBUTE(Array<ConversionTestSet>, CONVERSIONTESTSET, "net.maxon.streamconversiontest.conversiontestset");
// Changed to
MAXON_ATTRIBUTE(Array<UChar>, SRCDATA, "net.maxon.streamconversiontest.srcdata");
MAXON_ATTRIBUTE(BaseArray<UChar>, COMPAREDATA, "net.maxon.streamconversiontest.comparedata");
// Changed to
MAXON_ATTRIBUTE(Array<UChar>, COMPAREDATA, "net.maxon.streamconversiontest.comparedata");
}

maxon/string.h

template <typename INTERFACETYPE, typename REFTYPE, typename CHARTYPE> class StringTemplate
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}

maxon/system.h

namespace details
{
template <typename T> StrongReferenceCounter& PrivateGetReferenceCounter(const T* object)
// Changed to
StrongReferenceCounter& PrivateGetReferenceCounter(const void* object)
}

maxon/thread.h

// Removed
#ifdef USE_API_MAXON
// Removed
class BaseThread;
// Removed
// Removed
// Removed
// Removed
#endif

maxon/timevalue.h

class TimeValue
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/tuple.h

template <UInt32 INDEX, UInt32 PRE_OFFSET, UInt32 PRE_MAX_ALIGN> class TupleStorageLayout<INDEX, PRE_OFFSET, PRE_MAX_ALIGN>
{
static void GetOffset();
}
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...>
{
using Super = TupleStorageLayout<INDEX + 1, UInt32(Align(PRE_OFFSET, UInt32(SZ_ALIGN >> 33))) + UInt32(SZ_ALIGN), Max(PRE_MAX_ALIGN, UInt32(SZ_ALIGN >> 33)), REST...>;
using Super::GetOffset;
}
template <typename T1, typename T2> class TupleStorage<T1, T2>
{
// Removed
static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, second); }
static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, first); }
template <typename I> static Int GetOffset(I* x) { return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>()>::GetOffset(x); }
// Removed
static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, first); }
static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, second); }
static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, third); }
template <typename I> static Int GetOffset(I* x) { return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>(), GetSizeAndAlignment<T3>()>::GetOffset(x); }
// Removed
static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, first); }
static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, second); }
static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, third); }
static Int GetOffset(typename std::integral_constant<UInt32, 3>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, fourth); }
template <typename I> static Int GetOffset(I* x) { return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>(), GetSizeAndAlignment<T3>(), GetSizeAndAlignment<T4>()>::GetOffset(x); }
// Removed
static Int GetOffset(typename std::integral_constant<UInt32, 0>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, first); }
static Int GetOffset(typename std::integral_constant<UInt32, 1>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, second); }
static Int GetOffset(typename std::integral_constant<UInt32, 2>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, third); }
static Int GetOffset(typename std::integral_constant<UInt32, 3>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, fourth); }
static Int GetOffset(typename std::integral_constant<UInt32, 4>::type*) { return MAXON_OFFSETOF_NON_STANDARD_LAYOUT(TupleStorage, fifth); }
template <typename I> static Int GetOffset(I* x) { return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>(), GetSizeAndAlignment<T3>(), GetSizeAndAlignment<T4>(), GetSizeAndAlignment<T5>()>::GetOffset(x); }
}
// Removed
template <typename HASH> inline UInt TupleGetHashCode()
// Removed
template <typename HASH, typename T1, typename... T> inline UInt TupleGetHashCode(const T1& a1, const T&... rest)
template <typename... T> class Tuple : public maxon::details::TupleStorage<T...>
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
template <typename HASH> UInt GetHashCode() const
// Changed to
template <typename HASH> HashInt GetHashCode() const
}
template <> class Tuple<>
{
UInt GetHashCode() cons
// Changed to
HashInt GetHashCode() const
template <typename HASH> UInt GetHashCode() const
// Changed to
template <typename HASH> HashInt GetHashCode() const
}
class IgnoredPlaceholder
{
template <typename T>
void operator =(const T&) const { }
// Changed to
const IgnoredPlaceholder& operator =(const T&) const
}

maxon/unicodeutils.h

enum class CHARACTERTYPE : UChar
{
UNKNOWN = 0,
LU, // Letter, Uppercase
LL, // Letter, Lowercase
LT, // Letter, Titlecase
LM, // Letter, Modifier
LO, // Letter, Other
MN, // Mark, Nonspacing
MC, // Mark, Spacing Combining
ME, // Mark, Enclosing
ND, // Number, Decimal Digit
NL, // Number, Letter
NO, // Number, Other
PC, // Punctuation, Connector
PD, // Punctuation, Dash
PS, // Punctuation, Open
PE, // Punctuation, Close
PI, // Punctuation, Initial quote(may behave like Ps or Pe depending on usage)
PF, // Punctuation, Final quote(may behave like Ps or Pe depending on usage)
PO, // Punctuation, Other
SM, // Symbol, Math
SC, // Symbol, Currency
SK, // Symbol, Modifier
SO, // Symbol, Other
ZS, // Separator, Space
ZL, // Separator, Line
ZP, // Separator, Paragraph
CC, // Other, Control
CF, // Other, Format
CS, // Other, Surrogate
CO, // Other, Private Use
CN, // Other, Not Assigned(no characters in the file have this property)
}
class UnicodeUtils
{
static MAXON_METHOD CHARACTERTYPE GetCharacterType(Utf32Char chr);
}
template <typename TYPE> MAXON_ATTRIBUTE_FORCE_INLINE Bool IsUnicodeLetter(TYPE chr);

maxon/url.h

class UrlInterface
{
MAXON_FUNCTION UInt GetHashCode() const;
// Changed to
MAXON_FUNCTION HashInt GetHashCode() const;
}

maxon/uuid.h

class UuidInterface
{
MAXON_FUNCTION UInt GetHashCode() const;
// Changed to
MAXON_FUNCTION HashInt GetHashCode() const;
}

maxon/vector.h

template <typename T> struct SqMat4;
// Changed to
template <typename T> struct SqrMat4;
namespace ParametricTypes
{
MAXON_DECLARATION(ParametricType, SqMat, "net.maxon.parametrictype.sqmat");
// Changed to
MAXON_DECLARATION(ParametricType, SqrMat, "net.maxon.parametrictype.sqmat");
}

maxon/viewiterator.h

struct ViewIteratorMember
{
template <Bool ENABLE_SIMD = true> void Advance()
// Changed to
template <Bool ENABLE_SIMD> void Advance()
template <Bool ENABLE_SIMD = true> void Advance(Int advanceCount)
// Changed to
template <Bool ENABLE_SIMD> void Advance(Int advanceCount)
}

maxon/weakref.h

template <typename REFERENCE> class WeakRef : public WeakRefBase
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/win_com.h

class GUIDHASH
{
static MAXON_ATTRIBUTE_FORCE_INLINE UInt GetHashCode(const GUID& guid)
// Changed to
static MAXON_ATTRIBUTE_FORCE_INLINE HashInt GetHashCode(const GUID& guid)
}

corenodes.framework

maxon/corenodes.h

class CoreNodeBaseInterface
{
MAXON_ATTRIBUTE_CLASS(Id, TypeId, "datatype");
}
class CoreNodeGroupInterface : public CoreNodeBaseInterface
{
template <typename NODECLASS> ResultOk<void> PrivateAutoCreatePorts()
// Changed to
template <typename NODECLASS> ResultOk<void> PrivateAutoCreatePorts(const Generic*, const void*)
}
namespace details
{
template <typename N, typename... ARGS> inline Result<typename std::decay<typename GetSignature<decltype(&N::Init)>::Parameters::template At<0>::type>::type> CreateNode(const Id& nodeId, ARGS&&... args)
// Changed to
template <typename N, typename... ARGS> inline Result<typename std::decay<typename GetSignature<decltype(&N::Init)>::Parameters::template At<0>::type>::type> CreateNode(OverloadRank0, const Id& nodeId, ARGS&&... args)
template <typename N, typename = decltype(&N::GetPortType), typename... ARGS> inline Result<typename std::decay<typename GetSignature<decltype(&N::Init)>::Parameters::template At<0>::type>::type> CreateNode(OverloadRank1, const Id& nodeId, ARGS&&... args)
}

maxon/corenodes_conversion.h

constexpr LiteralId CORENODE_CONVERT_BASEID{"net.maxon.corenode.convert"};
template <typename DEST, typename SRC> inline CONVERSION_FLAGS GetScalarConversionFlags()
class ConversionSequence
{
// Removed
ConversionSequence() = default;
// Removed
ConversionSequence(const CoreNode& c1, CONVERSION_FLAGS flags) : _flags(flags), _count(1)
// Removed
ConversionSequence(const CoreNode& c1, const CoreNode& c2, CONVERSION_FLAGS flags) : _flags(flags), _count(2)
// Removed
ConversionSequence(const Block<const CoreNode>& seq, CONVERSION_FLAGS flags) : _flags(flags), _count(seq.GetCount())
CoreNode& operator [](Int index);
~ConversionSequence();
}

maxon/corenodes_helpers.h

enum class WIRETYPE
{
SUBTRACTIVE_DOMAIN = 0x40000, // The subtractive domain of the source node shall be subtracted from the target node's domain. If the source node introduces factors, then these are subtracted.
ELEMENT_DOMAIN = 0x80000, // The element domain is used for array/container output ports to transport the domain of their elements.
MATCH_DOMAIN = 0x100000,
INDUCED_DOMAIN = 0x200000,
FIX_DOMAIN = 0x400000,
CONDITIONAL_DOMAIN = 0x800000, // Only used when the target node receives subtractive domains through SUBTRACTIVE_DOMAIN wires: Add the domain of the source node to the target node.
INTERSECTION_DOMAIN = 0x1000000,
// Changed to
}
class InPortId : public PortId
{
static constexpr WIRETYPE DEFAULT_WIRE = WIRETYPE::DEFAULT_INPUT;
}
class OutPortId : public PortId
{
static constexpr WIRETYPE DEFAULT_WIRE = WIRETYPE::DEFAULT_OUTPUT;
}
class IdBuilder
{
template <typename... INSTANTIATIONTYPE, typename BASETYPE>
static corenodes::IdBuilder Create(BASETYPE baseId);
template <Bool B, typename... T> IdBuilder&& Append()';
void AppendParam(const Char* str);
}

maxon/corenodes_instances.h

class MicroNode
{
enum class TYPE
{
// Removed
PARAMETER_MASK = 0x800,
// Removed
PARAMETERS = PARAMETER_MASK + 1,
// Removed
CONTAINER_PARAMETER = CONTAINER_OUTPUT_ELEMENT | PARAMETER_MASK,
// Removed
ARRAY_PARAMETER = ARRAY_OUTPUT_ELEMENT | PARAMETER_MASK,
// Removed
FACTOR_REFERENCE_MASK = 0x400000,
// Removed
}
enum class FLAGS
{
// Removed
HIDDEN = 1 << 5,
DONT_WRAP = 1 << 5,
// Removed
SUSPEND = 1 << 16,
KEEP_LETTER_CASE = 1 << 17,
INDEPENDENT = 1 << 18,
FACTOR_REFERENCE = 1 << 20,
OPTIONAL_INPUT = 1 << 21,
CURRENT_ITV_GROUP = 1 << 22,
NEXT_ITV_GROUP = 1 << 23,
HIDDEN = 1 << 24,
// Changed to
}
}
template <typename T, Bool OUTPUT = false> class VariadicPort;
// Changed to
template <typename T, Bool OUTPUT = false, Bool AS_INPUT = false> class VariadicPort;
class MicroNodeInterface : public CoreNodeInstanceBaseInterface
{
MAXON_FUNCTION void AddFlags(MicroNode::FLAGS flags)
// Changed to
MAXON_METHOD void AddFlags(MicroNode::FLAGS flags);
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const CString& prefix, const Data& arg, WIRETYPE wires = WIRETYPE::ALL, const DataType& type = GetZeroRef<DataType>())
// Changed to
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const CString& prefix, const Data& arg, WIRETYPE wires = VARIADIC_ACCESS::VPort::DEFAULT_WIRE, const DataType& type = GetZeroRef<DataType>(), MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const CString& prefix, Int count, Int base = 0, WIRETYPE wires = WIRETYPE::ALL)
// Changed to
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const CString& prefix, Int count, Int base = 0, WIRETYPE wires = VARIADIC_ACCESS::VPort::DEFAULT_WIRE, MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const Block<const Member>& members, WIRETYPE wires = WIRETYPE::ALL)
// Changed to
template <typename VARIADIC_ACCESS, typename MN> MAXON_FUNCTION Result<BaseArray<typename VARIADIC_ACCESS::VPort::PortId>> AddVariadicPort(VARIADIC_ACCESS MN::* acc, const Block<const Member>& members, WIRETYPE wires = VARIADIC_ACCESS::VPort::DEFAULT_WIRE, MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
MAXON_FUNCTION Result<InPortId> Export(const InPortId& parentPort, WIRETYPE wires = WIRETYPE::ALL, ACCESS_INDEX index = ACCESS_INDEX::UNUSED, const DataType& type = DataType::NullValue())
// Changed to
MAXON_FUNCTION Result<InPortId> Export(const InPortId& parentPort, WIRETYPE wires = WIRETYPE::DEFAULT_INPUT, ACCESS_INDEX index = ACCESS_INDEX::UNUSED, const DataType& type = DataType::NullValue(), MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
MAXON_FUNCTION Result<OutPortId> Export(const OutPortId& parentPort, WIRETYPE wires = WIRETYPE::ALL, ACCESS_INDEX index = ACCESS_INDEX::UNUSED, const DataType& type = DataType::NullValue())
// Changed to
MAXON_FUNCTION Result<OutPortId> Export(const OutPortId& parentPort, WIRETYPE wires = WIRETYPE::DEFAULT_OUTPUT, ACCESS_INDEX index = ACCESS_INDEX::UNUSED, const DataType& type = DataType::NullValue(), MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
template <typename PORT> MAXON_FUNCTION Result<typename PORT::PortIdType> Export(const PORT& parentPort, WIRETYPE wires = WIRETYPE::ALL, ACCESS_INDEX index = ACCESS_INDEX::UNUSED)
// Changed to
template <typename PORT> MAXON_FUNCTION Result<typename PORT::PortIdType> Export(const PORT& parentPort, WIRETYPE wires = PORT::PortIdType::DEFAULT_WIRE, ACCESS_INDEX index = ACCESS_INDEX::UNUSED, MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
}
class CoreNodeInstanceInterface : public CoreNodeInstanceBaseInterface
{
MAXON_FUNCTION Result<InPortId> Export(const InPortId& inport, const InPortId& parentPort = InPortId::NullValue(), WIRETYPE wires = WIRETYPE::ALL)
// Changed to
MAXON_FUNCTION Result<InPortId> Export(const InPortId& inport, const InPortId& parentPort = InPortId::NullValue(), WIRETYPE wires = WIRETYPE::DEFAULT_INPUT)
MAXON_FUNCTION Result<OutPortId> Export(const OutPortId& outport, const OutPortId& parentPort = OutPortId::NullValue(), WIRETYPE wires = WIRETYPE::ALL)
// Changed to
MAXON_FUNCTION Result<OutPortId> Export(const OutPortId& outport, const OutPortId& parentPort = OutPortId::NullValue(), WIRETYPE wires = WIRETYPE::DEFAULT_OUTPUT)
}

maxon/corenodes_lib.h

class CoreNodesLib
{
// Removed
static MAXON_METHOD Result<const ConversionSequence*> GetConversion(const DataType& to, const DataType& from);
static MAXON_METHOD Result<const ConversionSequence*> GetConversion(const DataType& to, const DataType& from, Bool allowIterations);
// Changed to
static MAXON_METHOD Result<const ConversionSequence*> GetConversion(const DataType& to, const DataType& from, Bool allowIterations = false);
}

maxon/micronodes.h

class VariableMicroNode final : public VariableBase
{
// Changed to
}
class BasicMicroNode : public MicroNode
{
// Changed to
// Changed to
}
class BatchMicroNode : public MicroNode
{
// Changed to
// Changed to
}

maxon/micronodes_ports.h

namespace corenodes
{
#define MAXON_PORT_INPUT_NAMED(T, name, portId) PRIVATE_MAXON_INPUT_PORT_NAMED(T, name, portId, false, false, -1)
#define MAXON_PORT_OUTPUT_NAMED(T, name, portId) PRIVATE_MAXON_OUTPUT_PORT_NAMED(T, name, portId, VariableMicroNode, false, false, -1)
namespace details
{
struct SourceCodePortId
{
// Removed
MAXON_OPERATOR_EQUALITY_HASHCODE(SourceCodePortId, hash, linearIndex);
MAXON_OPERATOR_STRUCT(SourceCodePortId, hash, linearIndex);
}
template <typename PORTIDTYPE>
inline constexpr UInt GetPortHashCodeHelper(PORTIDTYPE const& inId)
inline constexpr UInt GetPortHashCodeHelper(LiteralId const& inId)
template <Int LENGTH>
inline constexpr UInt GetPortHashCodeHelper(const char (&inId)[LENGTH])
}
}

maxon/micronodes_runtime.h

class MicroNodeRuntime
{
// Removed
static MAXON_METHOD ExecutionTime GetTime(const Context& ctx);
}
template <Int PORTCOUNT> class BatchVarAccess
{
explicit BatchVarAccess(const VarAccess& access) : _access(&access), _context(access._context), _index(access._frame->GetIndex()), _blockEnd(access._frame->GetBlockEnd())
// Changed to
explicit BatchVarAccess(const VarAccess& access) : _context(access._context), _index(access._frame->GetIndex()), _blockEnd(access._frame->GetBlockEnd())
explicit BatchVarAccess(ENUM_DONT_INITIALIZE) : _access(nullptr)
// Changed to
explicit BatchVarAccess(ENUM_DONT_INITIALIZE)
}
template <> void Destruct<corenodes::FrameData>(corenodes::FrameData* data);

maxon/variadic_port.h

template <typename T, Bool OUTPUT> class VariadicPort
// Changed to
template <typename T, Bool OUTPUT, Bool AS_INPUT> class VariadicPort
{
static constexpr WIRETYPE DEFAULT_WIRE = OUTPUT ? WIRETYPE::DEFAULT_OUTPUT : WIRETYPE::DEFAULT_INPUT;
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const CString& prefix, Int count, Int base)
// Changed to
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const CString& prefix, Int count, Int base, MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const CString& prefix, const Data& arg, const DataType& type = GetPortType<T>())
// Changed to
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const CString& prefix, const Data& arg, const DataType& type = GetPortType<T>(), MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const Block<const Member>& members)
// Changed to
static Result<VariadicPort> Create(MicroNodeGroupInterface* node, const Block<const Member>& members, MicroNode::FLAGS flags = MicroNode::FLAGS::NONE)
template <typename PORTS> class Ports
{
using ValueType = typename std::conditional<OUTPUT, typename std::remove_const<T>::type&, T>::type;
corenodes::details::PortOps<T, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator [](Int index) const
// Changed to
corenodes::details::PortOps<ValueType, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator [](Int index) const
corenodes::details::PortOps<T, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator *() const
// Changed to
corenodes::details::PortOps<ValueType, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator *() const
class Iterator
{
corenodes::details::PortOps<T, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator *() const
// Changed to
corenodes::details::PortOps<ValueType, corenodes::details::PortArrayAccess<typename PORTS::Ports::Access>, void> operator *() const
}
}
class Access
{
Access() = default;
explicit Access(ACCESS_INDEX b = ACCESS_INDEX::UNUSED, Int cnt = 0) : _base(b), _count(cnt)
// Changed to
explicit Access(ACCESS_INDEX b, Int cnt = 0) : _base(b), _count(cnt)
}
template <typename MNI> Result<void> ConnectMicroNode(MicroNodePtr<MNI> node, Access MNI::* a, WIRETYPE wtype = WIRETYPE::ALL)
// Changed to
template <typename MNI> Result<void> ConnectMicroNode(MicroNodePtr<MNI> node, Access MNI::* a, WIRETYPE wtype = DEFAULT_WIRE)
}

crypt.framework

maxon/cryptography_hash.h

namespace HASH_HMAC
{
MAXON_ATTRIBUTE(BaseArray<UChar>, KEY, "net.maxon.streamconversion.hmac.key");
// Changed to
MAXON_ATTRIBUTE(Array<UChar>, KEY, "net.maxon.streamconversion.hmac.key");
}

image.framework

maxon/gfx_basictypes.h

template <typename T> struct DrawRect
{
Bool Contains(const Vec2<T,1>& point) const
}

maxon/gfx_image.h

namespace IMAGEPROPERTIES
{
namespace LAYER
{
namespace ADJUSTMENT
{
MAXON_ATTRIBUTE(BaseArray<Char>, PSD_DATA, "net.maxon.image.layer.psd_data");
// Changed to
MAXON_ATTRIBUTE(Array<Char>, PSD_DATA, "net.maxon.image.layer.psd_data");
}
}
}

maxon/gfx_image_bits.h

class BITS
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/gfx_image_colorprofile.h

class ColorProfileInterface
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}
class ColorProfileConvertInterface
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}

maxon/gfx_image_exif.h

namespace EXIFDATA
{
namespace PROPERTIES
{
MAXON_ATTRIBUTE(BaseArray<UInt16>, CFA_REPEAT_PATTERN_DIM, UInt16(0x828D));
// Changed to
MAXON_ATTRIBUTE(Array<UInt16>, CFA_REPEAT_PATTERN_DIM, UInt16(0x828D));
MAXON_ATTRIBUTE(BaseArray<UInt16>, ISO_SPEED_RATINGS, UInt16(0x8827));
// Changed to
MAXON_ATTRIBUTE(Array<UInt16>, ISO_SPEED_RATINGS, UInt16(0x8827));
MAXON_ATTRIBUTE(BaseArray<UInt16>, SUBJECT_AREA, UInt16(0x9214));
// Changed to
MAXON_ATTRIBUTE(Array<UInt16>, SUBJECT_AREA, UInt16(0x9214));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, WHITE_POINT, UInt16(0x013E));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, WHITE_POINT, UInt16(0x013E));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, YCBCR_COEFFICIENTS, UInt16(0x0211));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, YCBCR_COEFFICIENTS, UInt16(0x0211));
}
namespace GPS
{
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, DEST_LATITUDE, UInt16(0x0014));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, DEST_LATITUDE, UInt16(0x0014));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, DEST_LONGITUDE, UInt16(0x0016));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, DEST_LONGITUDE, UInt16(0x0016));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, LATITUDE, UInt16(0x0002));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, LATITUDE, UInt16(0x0002));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, LONGITUDE, UInt16(0x0008));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, LONGITUDE, UInt16(0x0008));
MAXON_ATTRIBUTE(BaseArray<UIntVector2d32>, TIME_STAMP, UInt16(0x0007));
// Changed to
MAXON_ATTRIBUTE(Array<UIntVector2d32>, TIME_STAMP, UInt16(0x0007));
}
}

maxon/gfx_image_pixelformat_template.h

maxon/half.h

template <> class LIMIT<HalfFloat<Float32>>
{
static constexpr Float32 Min() { return 6.10e-5f; }
// Changed to
static constexpr Float32 MIN = -6.55e+4f;
static constexpr Float32 Max() { return 6.55e+4f; }
// Changed to
static constexpr Float32 MAX = 6.55e+4f;
}

maxon/layerset.h

class LayerSetInterface
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}

maxon/mediasession_base.h

namespace MEDIASESSION
{
namespace EXPORT
{
MAXON_ATTRIBUTE(BaseArray<maxon::Char>, CUSTOMDATA, "net.maxon.mediasession.export.customdata");
// Changed to
MAXON_ATTRIBUTE(Array<Char>, CUSTOMDATA, "net.maxon.mediasession.export.customdata");
}
}
namespace MEDIAFORMAT
{
namespace IMAGELAYER
{
namespace ADJUSTMENT
{
MAXON_ATTRIBUTE(BaseArray<Char>, PSD_DATA, "net.maxon.mediaformat.layer.psd_data");
// Changed to
MAXON_ATTRIBUTE(Array<Char>, PSD_DATA, "net.maxon.mediaformat.layer.psd_data");
}
}
namespace VIDEO
{
// Changed to
}
namespace AUDIO
{
MAXON_ATTRIBUTE(BaseArray<DataDictionary>, MARKERARRAY, "net.maxon.mediaformat.audio.markerarray");
// Changed to
MAXON_ATTRIBUTE(Array<DataDictionary>, MARKERARRAY, "net.maxon.mediaformat.audio.markerarray");
}
}

maxon/mediasession_export_rla.h

namespace MEDIASESSION
{
namespace RLA
{
namespace EXPORT
{
MAXON_ATTRIBUTE(maxon::rla::MAXRenderInfo, MAXRENDERINFO, "net.maxon.mediasession.rla.export.maxrenderinfo");
// Changed to
MAXON_ATTRIBUTE(rla::MAXRenderInfo, MAXRENDERINFO, "net.maxon.mediasession.rla.export.maxrenderinfo");
MAXON_ATTRIBUTE(BaseArray<maxon::Char>, NAMETAB, "net.maxon.mediasession.rla.export.nametab");
// Changed to
MAXON_ATTRIBUTE(Array<Char>, NAMETAB, "net.maxon.mediasession.rla.export.nametab");
}
}
}

math.framework

maxon/apibasemath_extension.h

template <> class LIMIT<Vector2d32>
{
static Vector2d32 Min() { return Vector2d32(-3.402823466e+38f); }
// Changed to
static constexpr Vector2d32 MIN = Vector2d32(-3.402823466e+38f);
static Vector2d32 Max() { return Vector2d32(3.402823466e+38f); }
// Changed to
static constexpr Vector2d32 MAX = Vector2d32(3.402823466e+38f);
}
template <> class LIMIT<Vector2d64>
{
static Vector2d64 Min() { return Vector2d64(-1.7976931348623158e+308); }
// Changed to
static constexpr Vector2d64 MIN = Vector2d64(-1.7976931348623158e+308);
static Vector2d64 Max() { return Vector2d64(1.7976931348623158e+308); }
// Changed to
static constexpr Vector2d64 MAX = Vector2d64(1.7976931348623158e+308);
}
template <> class LIMIT<Vector4d32>
{
static Vector4d32 Min() { return Vector4d32(-3.402823466e+38f); }
// Changed to
static constexpr Vector4d32 MIN = Vector4d32(-3.402823466e+38f);
static Vector4d32 Max() { return Vector4d32(3.402823466e+38f); }
// Changed to
static constexpr Vector4d32 MAX = Vector4d32(3.402823466e+38f);
}
template <> class LIMIT<Vector4d64>
{
static Vector4d64 Min() { return Vector4d64(-1.7976931348623158e+308); }
// Changed to
static constexpr Vector4d64 MIN = Vector4d64(-1.7976931348623158e+308);
static Vector4d64 Max() { return Vector4d64(1.7976931348623158e+308); }
// Changed to
static constexpr Vector4d64 MAX = Vector4d64(1.7976931348623158e+308);
}
template <> class LIMIT<Vector32>
{
static Vector32 Min() { return Vector32(-3.402823466e+38f); }
// Changed to
static constexpr Vector32 MIN = Vector32(-3.402823466e+38f);
static Vector32 Max() { return Vector32(3.402823466e+38f); }
// Changed to
static constexpr Vector32 MAX = Vector32(3.402823466e+38f);
}
template <> class LIMIT<Vector64>
{
static Vector64 Min() { return Vector64(-1.7976931348623158e+308); }
// Changed to
static constexpr Vector64 MIN = Vector64(-1.7976931348623158e+308);
static Vector64 Max() { return Vector64(1.7976931348623158e+308); }
// Changed to
static constexpr Vector64 MAX = Vector64(1.7976931348623158e+308);
}
template <> class LIMIT<Matrix32>
{
// Changed to
// Changed to
}
template <> class LIMIT<Matrix64>
{
// Changed to
// Changed to
}
template <> class LIMIT<Color32>
{
static Color32 Min() { return Color32(-3.402823466e+38f); }
// Changed to
static constexpr Color32 MIN = Color32(-3.402823466e+38f);
static Color32 Max() { return Color32(3.402823466e+38f); }
// Changed to
static constexpr Color32 MAX = Color32(3.402823466e+38f);
}
template <> class LIMIT<Color64>
{
static Color64 Min() { return Color64(-1.7976931348623158e+308); }
// Changed to
static constexpr Color64 MIN = Color64(-1.7976931348623158e+308);
static Color64 Max() { return Color64(1.7976931348623158e+308); }
// Changed to
static constexpr Color64 MAX = Color64(1.7976931348623158e+308);
}
template <> class LIMIT<ColorA32>
{
static ColorA32 Min() { return ColorA32(-3.402823466e+38f); }
// Changed to
static constexpr ColorA32 MIN = ColorA32(-3.402823466e+38f);
static ColorA32 Max() { return ColorA32(3.402823466e+38f); }
// Changed to
static constexpr ColorA32 MAX = ColorA32(3.402823466e+38f);
}
template <> class LIMIT<ColorA64>
{
static ColorA64 Min() { return ColorA64(-1.7976931348623158e+308); }
// Changed to
static constexpr ColorA64 MIN = ColorA64(-1.7976931348623158e+308);
static ColorA64 Max() { return ColorA64(1.7976931348623158e+308); }
// Changed to
static constexpr ColorA64 MAX = ColorA64(1.7976931348623158e+308);
}

maxon/big_integer.h

class BigIntegerInterface
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/gradient.h

class GradientInterface
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}
class GradientRenderDataInterface
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

maxon/noise.h

class NoiseInterface
{
static MAXON_METHOD NoiseInterface* Alloc(MAXON_SOURCE_LOCATION_DECLARATION);
MAXON_METHOD Result<void> Init(UInt32 seed, Int permutationTablePower);
MAXON_METHOD UInt32 GetSeed() const;
MAXON_METHOD Int GetPermutationTablePower() const;
MAXON_METHOD const BaseArray<UInt16>* GetPermutationTable() const;
MAXON_METHOD Result<void> GetGradientTable(Bool gradient3D, BaseArray<Vector4d32>& gradient) const;
MAXON_METHOD Result<void> GetFbmTable(FbmTableRef table, BaseArray<Float32>& fbm) const;
MAXON_METHOD const BaseArray<Vector4d32>* GetRandomTable() const;
MAXON_FUNCTION Float32 SNoise(const Vector32& p, Float32 time) const;
MAXON_METHOD Float32 PeriodicSNoise(const Vector32& p, Int repeatX, Int repeatY, Int repeatZ) const;
MAXON_METHOD Float32 PeriodicSNoise(const Vector4d32& p, Int repeatX, Int repeatY, Int repeatZ, Int repeatT) const;
MAXON_METHOD void Voronoi(const Vector32& p, Int maximumOrder, Float32* distance, Int32* index) const;
MAXON_METHOD void Voronoi(const Vector4d32& p, Int maximumOrder, Float32* distance, Int32* index) const;
MAXON_METHOD ResultMemT<FbmTableRef> InitFbm(Float32 lacunarity, Float32 gain) const;
MAXON_METHOD Float32 Fbm(FbmTableRef table, Vector32 p, Float32 octaves) const;
MAXON_METHOD Float32 Turbulence(Vector32 p, Float32 octaves, Bool absolute) const;
MAXON_METHOD Float32 Turbulence(Vector4d32 p, Float32 octaves, Bool absolute) const;
MAXON_METHOD Float32 RidgedMultifractal(FbmTableRef table, Vector32 p, Float32 octaves, Float32 offset, Float32 threshold) const;
MAXON_METHOD Float32 RidgedMultifractal(FbmTableRef table, Vector4d32 p, Float32 octaves, Float32 offset, Float32 threshold) const;
};
namespace NOISEPROPERTY
{
MAXON_ATTRIBUTE(Float, LACUNARITY, 0);
MAXON_ATTRIBUTE(Float, GAIN, 1);
MAXON_ATTRIBUTE(Float, EXPONENT, 2);
}
class RenderNoiseInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
MAXON_METHOD Result<void> Init(UInt32 seed, Int permutationTablePower, const DataDictionary& additionalParameters);
MAXON_METHOD Float32 Noise(const Vector32& p, Float32 time, Float32 octaves = 6.0, Bool absolute = false, Float32 sampleRadius = 0.0) const;
MAXON_METHOD Float32 Noise(const Vector2d32& p, Float32 time, Float32 octaves = 6.0, Bool absolute = false, Float32 sampleRadius = 0.0) const;
};
namespace RenderNoiseClasses
{
MAXON_DECLARATION(RenderNoiseClasses::EntryType, PERLIN, "net.maxon.render.rendernoiseclass.perlin");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, FBM, "net.maxon.render.rendernoiseclass.fbm");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, TURBULENCE, "net.maxon.render.rendernoiseclass.turbulence");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, RIDGEDMULTIFRACTAL, "net.maxon.render.rendernoiseclass.ridgedmultifractal");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, GASEOUS, "net.maxon.render.rendernoiseclass.gaseous");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, ELECTRIC, "net.maxon.render.rendernoiseclass.electric");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, BOX, "net.maxon.render.rendernoiseclass.box");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, BLISTEREDTURBULENCE, "net.maxon.render.rendernoiseclass.blisteredturbulence");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, CRANAL, "net.maxon.render.rendernoiseclass.cranal");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, BUYA, "net.maxon.render.rendernoiseclass.buya");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, DENTS, "net.maxon.render.rendernoiseclass.dents");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, CELL, "net.maxon.render.rendernoiseclass.cell");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, DISPLACEDTURBULENCE, "net.maxon.render.rendernoiseclass.displacedturbulence");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, HAMA, "net.maxon.render.rendernoiseclass.hama");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, LUKA, "net.maxon.render.rendernoiseclass.luka");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, MOD, "net.maxon.render.rendernoiseclass.mod");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, NAKI, "net.maxon.render.rendernoiseclass.naki");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, NUTOUS, "net.maxon.render.rendernoiseclass.nutous");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, OBER, "net.maxon.render.rendernoiseclass.ober");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, PEZO, "net.maxon.render.rendernoiseclass.pezo");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, POXO, "net.maxon.render.rendernoiseclass.poxo");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, SEMA, "net.maxon.render.rendernoiseclass.sema");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, STUPL, "net.maxon.render.rendernoiseclass.stupl");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, VL, "net.maxon.render.rendernoiseclass.vl");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, WAVYTURBULENCE, "net.maxon.render.rendernoiseclass.wavyturbulence");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, ZADA, "net.maxon.render.rendernoiseclass.zada");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, CELLVORONOI, "net.maxon.render.rendernoiseclass.cellvoronoi");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, DISPLACEDVORONOI, "net.maxon.render.rendernoiseclass.displacedvoronoi");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, VORONOI1, "net.maxon.render.rendernoiseclass.voronoi1");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, VORONOI2, "net.maxon.render.rendernoiseclass.voronoi2");
MAXON_DECLARATION(RenderNoiseClasses::EntryType, VORONOI3, "net.maxon.render.rendernoiseclass.voronoi3");
}

maxon/quaternion.h

template <typename ValueType> class Quaternion
{
using MatrixType = SqMat3<Vec3<ValueType>>;
// Changed to
using MatrixType = SqrMat3<Vec3<ValueType>>;
}

maxon/splinemapper.h

#define SPLINE_KNOT_GET_ID(flags) ((flags >> 16) & 0x0000ffff)
// Changed to
#define SPLINEMAPPER_KNOT_GET_ID(flags) ((Int(flags) >> 16) & 0x0000ffff)
#define SPLINE_KNOT_SET_ID(flags, flag_id) (flags = (flags & 65535) | ((flag_id & 0x0000ffff) << 16))
// Changed to
#define SPLINEMAPPER_KNOT_SET_ID(flags, flag_id) (flags = SPLINEMAPPER_KNOT_FLAGS((Int(flags) & 65535) | ((flag_id & 0x0000ffff) << 16)))
// Changed to
{
NONE = 0,
SELECTED = (1 << 6),
}
struct SplineMapperKnot
{
Bool operator == (SplineMapperKnot& k)
// Changed to
Bool operator == (const SplineMapperKnot& k) const
Bool operator != (SplineMapperKnot& k)
// Changed to
Bool operator != (const SplineMapperKnot& k) const
UInt GetHashCode() const
Int flags = 0;
// Changed to
MAXON_METHOD Result<Int> InsertKnot(Float x, Float y, Int flags, Bool adaptTangents);
// Changed to
MAXON_METHOD Result<Int> InsertKnot(Float x, Float y, SPLINEMAPPER_KNOT_FLAGS flags, Bool adaptTangents);
}
class SplineMapperInterface
{
MAXON_METHOD Bool IsEqual(const SplineMapperInterface* other, EQUALITY equality) const;
MAXON_METHOD UInt GetHashCode() const;
}

mesh_misc.framework

maxon/distancequery.h

class DistanceQueryInterface
{
MAXON_METHOD Result<void> Init(const Block<const Vector> points, const Block<const SimplePolygon> polygons, const Matrix& objectPosition);
}

maxon/vertexwrapper.h

template <typename TYPE> class PrivateVertexWrapper
{
UInt GetHashCode() const
// Changed to
HashInt GetHashCode() const
}

misc.framework

maxon/gmlwriter.h

struct GmlNode
{
GmlNode() = default;
explicit GmlNode(const void* n = nullptr, Int i = -1) : node(n), index(i) { }
// Changed to
explicit GmlNode(const void* n, Int i = -1) : node(n), index(i) { }
const void* node;
// Changed to
const void* node = nullptr;
Int index;
// Changed to
Int index = -1;
}

maxon/io.h

template <typename T> inline Result<void> WriteDocument(const Url& url, const Id& id, const T& object, IOFORMAT format = IOFORMAT::DEFAULT, const DataDictionary& dict = DataDictionary())
// Changed to
template <typename T> inline Result<void> WriteDocument(const Url& url, OPENSTREAMFLAGS flags, const Id& id, const T& object, IOFORMAT format = IOFORMAT::DEFAULT, const DataDictionary& dict = DataDictionary())

maxon/sourcecontrol.h

class ProgressMonitorRef;
class SourceControlChangeEntry
{
UInt GetHashCode() const;
// Changed to
HashInt GetHashCode() const;
MAXON_METHOD Result<void> SyncFile(const Url& path, Int changeList = -1, ProgressMonitorRef monitor = ProgressMonitorRef());
// Changed to
MAXON_METHOD Result<void> SyncFile(const Url& path, Int changeList = -1, const ProgressMonitorRef& monitor = GetZeroRef<ProgressMonitorRef>());
MAXON_METHOD Result<void> SyncFileRevision(const Url& path, Int revision = -1, ProgressMonitorRef monitor = ProgressMonitorRef());
// Changed to
MAXON_METHOD Result<void> SyncFileRevision(const Url& path, Int revision = -1, const ProgressMonitorRef& monitor = GetZeroRef<ProgressMonitorRef>());
MAXON_METHOD Result<String> RunNativeCommand(const String& command, const ArrayInterface<String>& arguments, WritableArrayInterface<DataDictionary>& result, ProgressMonitorRef monitor = ProgressMonitorRef(), const SCTypeConversion& typeConversion = SCTypeConversion(), const String& input = String());
// Changed to
MAXON_METHOD Result<String> RunNativeCommand(const String& command, const ArrayInterface<String>& arguments, WritableArrayInterface<DataDictionary>& result, const ProgressMonitorRef& monitor = GetZeroRef<ProgressMonitorRef>(), const SCTypeConversion& typeConversion = SCTypeConversion(), const String& input = String());
}
inline Result<void> SCCCheckOutFile(const Url& url, Bool outputError)
inline Result<void> SCCAddFile(const Url& url, Bool outputError)

network.framework

maxon/network_ip.h

class NetworkAdapterInterface
{
MAXON_METHOD UInt GetHashCode() const;
// Changed to
MAXON_METHOD HashInt GetHashCode() const;
}

python.framework

cpython.h

{
struct PythonDll
{
// Removed
StringDecodingRef _defaultStringDecoder;
// Removed
StringEncodingRef _defaultStringEncoder;
}
{
struct CPyMemAllocatorEx {
void* ctx;
void* (*malloc) (void* ctx, size_t size);
void* (*calloc) (void* ctx, size_t nelem, size_t elsize);
void* (*realloc) (void* ctx, void* ptr, size_t new_size);
void (*free) (void* ctx, void* ptr);
} ;
class CPythonLibraryInterface
{
// Removed
MAXON_METHOD void PrivateCPyRandom_Init();
// Removed
MAXON_METHOD CPyRef CPy_InitModule(const ModuleDefinition& module);
MAXON_METHOD CPyRef CPyModule_Create(const ModuleDefinition& module);
MAXON_METHOD Result<void> CPy_SetPath(const BaseArray<Url>& paths);
MAXON_METHOD Bool CPyString_Check(const CPyRef& o);
// Changed to
MAXON_METHOD Bool CPyUnicode_Check(const CPyRef& o);
MAXON_METHOD CPyRef CPyString_FromString(const Char* str) const;
// Changed to
MAXON_METHOD CPyRef CPyUnicode_FromString(const Char* str) const;
MAXON_METHOD CPyRef CPyString_FromStringAndSize(const Block<const Char>& block);
// Changed to
MAXON_METHOD CPyRef CPyUnicode_FromStringAndSize(const Block<const Char>& block);
MAXON_METHOD Result<String> CPyString_AsString(const CPyRef& str);
// Changed to
MAXON_METHOD Result<String> CPyUnicode_AsString(const CPyRef& str);
MAXON_METHOD const Char* CPyString_AsCString(const CPyRef& str);
// Changed to
MAXON_METHOD const Char* CPyUnicode_AsCString(const CPyRef& str);
MAXON_METHOD Int CPyString_Size(const CPyRef& str);
// Changed to
MAXON_METHOD Int CPyUnicode_GetLength(const CPyRef& str);
MAXON_METHOD CPyRef CPyImport_GetModuleDict();
// Removed
MAXON_METHOD void CPyEval_AcquireLock();
// Removed
MAXON_METHOD void CPyEval_ReleaseLock();
MAXON_METHOD Bool CPyInt_Check(const CPyRef& o);
// Changed to
MAXON_METHOD Bool CPyLong_Check(const CPyRef& o);
MAXON_METHOD CPyRef CPyInt_FromInt16(Int16 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromInt16(Int16 value);
MAXON_METHOD CPyRef CPyInt_FromUInt16(UInt16 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromUInt16(UInt16 value);
MAXON_METHOD CPyRef CPyInt_FromInt32(Int32 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromInt32(Int32 value);
MAXON_METHOD CPyRef CPyInt_FromUInt32(UInt32 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromUInt32(UInt32 value);
MAXON_METHOD CPyRef CPyInt_FromInt64(Int64 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromInt64(Int64 value);
MAXON_METHOD CPyRef CPyInt_FromUInt64(UInt64 value);
// Changed to
MAXON_METHOD CPyRef CPyLong_FromUInt64(UInt64 value);
MAXON_METHOD Int16 CPyInt_AsInt16(const CPyRef& o);
// Changed to
MAXON_METHOD Int16 CPyLong_AsInt16(const CPyRef& o);
MAXON_METHOD UInt16 CPyInt_AsUInt16(const CPyRef& o);
// Changed to
MAXON_METHOD UInt16 CPyLong_AsUInt16(const CPyRef& o);
MAXON_METHOD Int32 CPyInt_AsInt32(const CPyRef& o);
// Changed to
MAXON_METHOD Int32 CPyLong_AsInt32(const CPyRef& o);
MAXON_METHOD UInt32 CPyInt_AsUInt32(const CPyRef& o);
// Changed to
MAXON_METHOD UInt32 CPyLong_AsUInt32(const CPyRef& o);
MAXON_METHOD Int64 CPyInt_AsInt64(const CPyRef& o);
// Changed to
MAXON_METHOD Int64 CPyLong_AsInt64(const CPyRef& o);
MAXON_METHOD UInt64 CPyInt_AsUInt64(const CPyRef& o);
// Changed to
MAXON_METHOD UInt64 CPyLong_AsUInt64(const CPyRef& o);
MAXON_FUNCTION T CPyInt_As(const CPyRef& o);
// Changed to
MAXON_FUNCTION T CPyLong_As(const CPyRef& o);
MAXON_FUNCTION CPyRef CPyInt_From(std::enable_if_t<STD_IS_REPLACEMENT(same, T, Int32), Int32> o);
// Changed to
MAXON_FUNCTION CPyRef CPyLong_From(std::enable_if_t<std::is_same<T, Int32>::value, Int32> o);
MAXON_FUNCTION CPyRef CPyInt_From(std::enable_if_t<STD_IS_REPLACEMENT(same, T, Int64), Int64> o);
// Changed to
MAXON_FUNCTION CPyRef CPyLong_From(std::enable_if_t<std::is_same<T, Int64>::value, Int64> o);
MAXON_METHOD Result<void> CPyMem_SetAllocator(CPyMemAllocatorDomain domain, CPyMemAllocatorEx* allocator);
// Removed
MAXON_METHOD Int32* CPy_UseClassExceptionsFlag();
// Removed
MAXON_METHOD Int32* CPy_TabcheckFlag();
// Removed
MAXON_METHOD Int32* CPy_UnicodeFlag();
// Removed
MAXON_METHOD Int32* CPy_DivisionWarningFlag();
// Removed
MAXON_METHOD Int32* CPy_QnewFlag();
// Removed
MAXON_METHOD Int32* CPy_Py3kWarningFlag();
// Removed
MAXON_METHOD Int32* CPy_CheckInterval();
MAXON_METHOD CPyTypeConstRef CPyString_Type();
// Changed to
MAXON_METHOD CPyTypeConstRef CPyUnicode_Type();
// Removed
MAXON_METHOD CPyTypeConstRef CPyInt_Type();
MAXON_METHOD const PyChar* ConvertAndCacheString(const String& str, const StringEncodingRef& encoding);
// Changed to
MAXON_METHOD const PyChar* ConvertAndCacheString(const String& str, PyStringEncodings encoding, UInt* size = nullptr);
}
class PyModuleInterface : MAXON_INTERFACE_BASES(LibraryInterface)
{
MAXON_METHOD Result<void> GetFunctions27(BaseArray<NativePyCFunctionTable>& functions);
// Changed to
MAXON_METHOD Result<void> GetFunctions37(BaseArray<NativePyCFunctionTable>& functions);
}
template <typename T>
MAXON_FUNCTION T CPythonLibraryInterface::CPyInt_As(const CPyRef& o)
// Changed to
template <typename T>
MAXON_FUNCTION T CPythonLibraryInterface::CPyLong_As(const CPyRef& o)
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyInt_From(std::enable_if_t<STD_IS_REPLACEMENT(same, T, Int32), Int32> o)
// Changed to
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyLong_From(std::enable_if_t<std::is_same<T, Int32>::value, Int32> o)
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyInt_From(std::enable_if_t<STD_IS_REPLACEMENT(same, T, Int64), Int64> o)
// Changed to
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyLong_From(std::enable_if_t<std::is_same<T, Int64>::value, Int64> o)
}
namespace CPythonLibs
{
MAXON_DECLARATION(Class<LibraryRef>, Lib27, "net.maxon.python.cpythonlibs.cpy27");
// Changed to
MAXON_DECLARATION(Class<LibraryRef>, Lib37, "net.maxon.python.cpythonlibs.cpy37");
}
// Removed
#define Python27Output(formatString, ...)
#define Python37Output(formatString, ...)

maxon/cpython_raw.h

enum class PYTHONFLAG
{
// Removed
USECLASSEXCEPTIONS = 1 << 8,
// Removed
TABCHECK = 1 << 10,
// Removed
UNICODE_ = 1 << 11,
// Removed
QNEW = 1 << 16,
}

maxon/cpython27_raw.h changed to maxon/cpython37_raw.h

maxon/cpython37_raw.h

namespace maxon::py27
// Changed to
namespace maxon::py37
struct TpFlags
{
// Removed
static const Int64 INT_SUBCLASS = (1L << 23);
}
struct NativePyModuleDefBase : public NativePyObject
{
NativePyObject* (*m_init)(void);
Int m_index = 0;
NativePyObject* m_copy = nullptr;
};
struct NativePyCodeObject
{
Int32 co_kwonlyargcount; // #keyword only arguments
Int32 co_firstlineno; // first source line number
Int* co_cell2arg; // Maps cell vars which are arguments
void* co_extra;
}
class NativePyErr_StackItem
{
NativePyObject* exc_type;
NativePyObject* exc_value;
NativePyObject* exc_traceback;
NativePyErr_StackItem* previous_item = nullptr;
}
struct NativePyThreadState
{
struct _ts *prev = nullptr;
Int32 recursion_depth;
// Changed to
Int32 recursion_depth = 0;
Char overflowed = 0;
Char recursion_critical = 0;
Int32 stackcheck_counter = 0;
// Removed
NativePyObject *curexc_type;
// Removed
NativePyObject *curexc_value;
// Removed
NativePyObject *curexc_traceback;
// Removed
NativePyObject *exc_type;
// Removed
NativePyObject *exc_value;
// Removed
NativePyObject *exc_traceback;
NativePyErr_StackItem _exc_state;
NativePyErr_StackItem exc_info;
// Changed to
NativePyObject *dict = nullptr;
// Removed
Int32 tick_counter;
Int32 gilstate_counter;
// Changed to
Int32 gilstate_counter = 0;
void(*on_delete)(void *);
void *on_delete_data;
Int32 coroutine_origin_tracking_depth = 0;
NativePyObject* coroutine_wrapper = nullptr;
Int32 in_coroutine_wrapper = 0;
NativePyObject* async_get_firstiter = nullptr;
NativePyObject* async_gen_finalizer = nullptr;
NativePyObject* context = nullptr;
UInt64 context_ver = 0;
UInt64 id;
}
struct NativePyFrameObject
{
Char f_trace_lines = 0;
Char f_trace_opcodes = 0;
// Removed
NativePyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
// Removed
NativePyThreadState *f_tstate;
NativePyObject* f_gen = nullptr;
Char f_executing = 0;
}
struct NativePyTypeObject
{
void* tp_finalize = nullptr;
}

maxon/cpython_raw.h

// Removed
#if defined(MAXON_TARGET_LINUX)
// Removed
#ifdef MAXON_TARGET_64BIT
// Removed
#define LIBSDIRECTORY "linux64"
// Removed
#else
// Removed
#define LIBSDIRECTORY "linux32"
// Removed
#endif
// Removed
#elif defined(_WINDOWS)
// Removed
#ifdef MAXON_TARGET_64BIT
// Removed
#define LIBSDIRECTORY "win64"
// Removed
#else
// Removed
#define LIBSDIRECTORY "win32"
// Removed
#endif
// Removed
#elif defined(__APPLE__)
// Removed
#define LIBSDIRECTORY "osx"
// Removed
#endif
enum class PYTHONFLAG
{
USECLASSEXCEPTIONS = 1 << 8,
// Changed to
// USECLASSEXCEPTIONS = 1 << 8,
TABCHECK = 1 << 10,
// Changed to
// TABCHECK = 1 << 10,
UNICODE_ = 1 << 11,
// Changed to
// UNICODE_ = 1 << 11,
QNEW = 1 << 16,
// Changed to
// QNEW = 1 << 16,
}

maxon/cpython_ref.h

MAXON_REGISTRY(Class<CPyRef>, CPyReferences27, "net.maxon.python.registry.pyreferences27");
// Changed to
MAXON_REGISTRY(Class<CPyRef>, CPyReferences37, "net.maxon.python.registry.pyreferences37");
namespace CPyReferences27
// Changed to
namespace CPyReferences37
{
MAXON_DECLARATION(Class<CPyRef>, CPy, "net.maxon.python.pyreference27.cpy");
//Changed to
MAXON_DECLARATION(Class<CPyRef>, CPy, "net.maxon.python.pyreference37.cpy");
MAXON_DECLARATION(Class<CPyTypeRef>, CPyType, "net.maxon.python.pyreference27.cpytype");
//Changed to
MAXON_DECLARATION(Class<CPyTypeRef>, CPyType, "net.maxon.python.pyreference37.cpytype");
MAXON_DECLARATION(Class<CPyFrameRef>, CPyFrame, "net.maxon.python.pyreference27.cpyframe");
//Changed to
MAXON_DECLARATION(Class<CPyFrameRef>, CPyFrame, "net.maxon.python.pyreference37.cpyframe");
MAXON_DECLARATION(Class<CPyTracebackRef>, CPyTraceback, "net.maxon.python.pyreference27.cpytraceback");
//Changed to
MAXON_DECLARATION(Class<CPyTracebackRef>, CPyTraceback, "net.maxon.python.pyreference37.cpytraceback");
MAXON_DECLARATION(Class<CPyCodeRef>, CPyCode, "net.maxon.python.pyreference27.cpycode");
//Changed to
MAXON_DECLARATION(Class<CPyCodeRef>, CPyCode, "net.maxon.python.pyreference37.cpycode");
MAXON_DECLARATION(Class<MPyClassRef>, MPyClass, "net.maxon.python.pyreference27.mpyclass");
//Changed to
MAXON_DECLARATION(Class<MPyClassRef>, MPyClass, "net.maxon.python.pyreference37.mpyclass");
MAXON_DECLARATION(Class<MPyMemberRef>, MPyMember, "net.maxon.python.pyreference27.mpymember");
//Changed to
MAXON_DECLARATION(Class<MPyMemberRef>, MPyMember, "net.maxon.python.pyreference37.mpymember");
MAXON_DECLARATION(Class<MPyFunctionRef>, MPyFunction, "net.maxon.python.pyreference27.mpyfunction");
//Changed to
MAXON_DECLARATION(Class<MPyFunctionRef>, MPyFunction, "net.maxon.python.pyreference37.mpyfunction");
MAXON_DECLARATION(Class<MPyDataTypeRef>, MPyDataType, "net.maxon.python.pyreference27.mpydatatype");
//Changed to
MAXON_DECLARATION(Class<MPyDataTypeRef>, MPyDataType, "net.maxon.python.pyreference37.mpydatatype");
MAXON_DECLARATION(Class<MPyDataRef>, MPyData, "net.maxon.python.pyreference27.mpydata");
//Changed to
MAXON_DECLARATION(Class<MPyDataRef>, MPyData, "net.maxon.python.pyreference37.mpydata");
MAXON_DECLARATION(Class<MPyCallerContextRef>, MPyCallerContext, "net.maxon.python.pyreference27.mpycallercontext");
// Changed to
MAXON_DECLARATION(Class<MPyCallerContextRef>, MPyCallerContext, "net.maxon.python.pyreference37.mpycallercontext");
}

maxon/vm.h

{
enum class DEFAULTRUNTIME
{
// Removed
SYSTEM_27,
// Removed
SYSTEM_36,
// #ifdef MAXON_TARGET_WINDOWS
// Removed
DEBUG_27_VS2008, // For Windows Only
// Removed
DEBUG_27_VS2013, // For Windows Only
// Removed
DEBUG_27_VS2015, // For Windows Only
DEBUG_36_VS2015, // For Windows Only
// Changed to
DEBUG_37_VS2015, // For Windows Only
// Removed
RELEASE_27_VS2008, // For Windows Only
// Removed
RELEASE_27_VS2015, // For Windows Only
RELEASE_36_VS2015, // For Windows Only
// Changed to
RELEASE_37_VS2015, // For Windows Only
// #else
// Removed
DEBUG_27,
// Removed
RELEASE_27,
DEBUG_36,
// Changed to
RELEASE_36,
// Changed to
// #endif
// Removed
DEFAULT_27, // auto detect of debug (and vs version on win)
DEFAULT_36, // auto detect of debug (and vs version on win)
// Changed to
DEFAULT_37, // auto detect of debug (and vs version on win)
#define MAXON_CPYTHONVM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy27"))
// Changed to
#define MAXON_CPYTHONVM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy37"))
// Removed
#define MAXON_CPYTHON27VM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy27"))
#define MAXON_CPYTHON37VM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy37"))
}

volume.framework

maxon/volumetools.h

class VolumeToolsInterface
{
static MAXON_METHOD Result<Volume> ConvertSDFToFog(const Volume& volume, Float cutoff = LIMIT<Float>::Max());
// Changed to
static MAXON_METHOD Result<Volume> ConvertSDFToFog(const Volume& volume, Float cutoff = LIMIT<Float>::MAX);
}
R23_DBVERSIONIDTYPE
R23_DBVERSIONIDTYPE
removes the old dbversion type
Definition: datadescriptiondefinition_conversion.h:6
maxon::OverloadRank0
PrivateOverloadRank0 * OverloadRank0
Definition: apibase.h:609
maxon::Move
auto Move(ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> DEST_ITERATOR
Definition: algorithms.h:446
CONST_QUALIFIED
CONST_QUALIFIED
The type is const-qualified.
Definition: apibase.h:2177
CS
CS
Definition: unicodeutils.h:30
MINVALUE_FLOAT32
static constexpr Float32 MINVALUE_FLOAT32
the minimum value a Float32 can represent
Definition: apibasemath.h:7
NONE
NONE
Definition: c4d_baseeffectordata.h:2
TreeViewFloatSliderInfo::maxValue
Float maxValue
The maximum range of the slider as drawn.
Definition: customgui_listview.h:179
maxon::CHARACTERTYPE
CHARACTERTYPE
Definition: unicodeutils.h:24
CACHED
CACHED
Definition: corenodes_instances.h:25
CC
CC
Definition: unicodeutils.h:28
maxon::OPENSTREAMFLAGS
OPENSTREAMFLAGS
Flags for Url::OpenInputStream(), Url::OpenOutputStream(), Url::OpenInOutputStream()
Definition: ioenums.h:70
ColorProfile
Definition: c4d_basebitmap.h:146
PD
PD
Definition: unicodeutils.h:15
MAXON_OPERATOR_STRUCT
#define MAXON_OPERATOR_STRUCT(T,...)
Definition: classhelpers.h:507
maxon::GetFolderDelegate
Delegate< Block< const Id >()> GetFolderDelegate
Definition: datatype_builder.h:63
maxon::PrivateGetDataType
Result< DataType > PrivateGetDataType(ArrayInterface< T > **, OverloadRank0)
Definition: array.h:1040
CONTAINER_REF
CONTAINER_REF
The data type is a reference type of a container type.
Definition: apibase.h:2202
MATH_MATRIX
#define MATH_MATRIX
Definition: lib_math.h:78
ITV_MASK
ITV_MASK
Definition: corenodes_instances.h:45
maxon::Vector2d32
Vec2< Float32, 1 > Vector2d32
Definition: vector2d.h:30
ACTIVEOBJECTMODE::LAYER
@ LAYER
Layer mode.
operator!=
Bool operator!=(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:268
MAXON_REGISTRY
#define MAXON_REGISTRY(T, Name, id)
Definition: registrybase.h:384
DESCRIPTION
DESCRIPTION
Description changed.
Definition: ge_prepass.h:2530
maxon::IsEqual
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsEqual(PREDICATE &&predicate, const T1 &a, const T2 &b)
Definition: collection.h:102
CPYMEM_DOMAIN_RAW
CPYMEM_DOMAIN_RAW
Definition: cpython.h:57
maxon::SPLINEMAPPER_KNOT_FLAGS
SPLINEMAPPER_KNOT_FLAGS
Definition: splinemapper.h:45
maxon::py::CPyMemAllocatorDomain
CPyMemAllocatorDomain
Definition: cpython.h:129
BaseList2D
Definition: c4d_baselist.h:2144
SDKBrowserIcon
Represents a browser icon.
Definition: lib_browser.h:263
R23_CONVERTLIMIT
R23_CONVERTLIMIT
convert limit Bool to enum
Definition: datadescriptiondefinition_conversion.h:3
ALIAS
ALIAS
Definition: corenodes_helpers.h:40
SIMD
SIMD
The data type is a SimdElementType. Such a type has a special memory layout where consecutive element...
Definition: apibase.h:2164
dataserialize.h
maxon::Cast
R Cast(ErrorPtr &ref)
Definition: errorbase.h:311
CN
CN
Definition: unicodeutils.h:32
Multipass
Definition: c4d_shader.h:774
BaseObject::GetRenderModeH
Int32 GetRenderModeH(void) const
SO
SO
Definition: unicodeutils.h:24
LV_CHECKBOX_ENABLED
#define LV_CHECKBOX_ENABLED
Checkbox is enabled.
Definition: customgui_listview.h:70
TreeViewFunctions
Inherit this class to supply a data and view model for TreeViewCustomGui. See ActiveObject....
Definition: customgui_listview.h:216
BaseView
Definition: c4d_basedraw.h:265
maxon::Contains
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains(const PREDICATE &predicate, const KEY &key)
Definition: collection.h:76
BITMAP_UPDATEREGION::TYPE
@ TYPE
Int32.
SUBTRACTIVE_DOMAIN
SUBTRACTIVE_DOMAIN
Definition: corenodes_helpers.h:47
TempUVHandle::GetUVIslands
maxon::Block< Int32 > GetUVIslands()
MINRANGE_FLOAT32
static constexpr Float32 MINRANGE_FLOAT32
'safe' minimum range for Float32. Guarantees that multiplication of two numbers doesn't produce an ov...
Definition: apibasemath.h:19
RESOLVED_RECURSIVE_CONTAINER
RESOLVED_RECURSIVE_CONTAINER
The data type represents a resolved recursive container type (i.e. the underlying type points to the ...
Definition: apibase.h:2205
COLOR_TITLE_BACKGROUND
@ COLOR_TITLE_BACKGROUND
Definition: c4d_colors.h:397
AMFILTERFLAGS::SHOWKEYFRAMESEL
@ SHOWKEYFRAMESEL
Hide attributes if they are not in keyframe selection.
INDUCED_SEQUENCED
INDUCED_SEQUENCED
Definition: corenodes_helpers.h:37
maxon::DescribeIO
Result< void > DescribeIO(const T &s, const DataSerializeInterface &dsi)
Definition: datatypefunctions.h:21
LayerObject
Definition: c4d_basedocument.h:245
BaseTime
Definition: c4d_basetime.h:24
DEBUG_37
DEBUG_37
Definition: vm.h:46
LENGTH
LENGTH
Definition: units.h:2
PERMANENT
PERMANENT
Definition: corenodes_instances.h:24
Int
maxon::Int Int
Definition: ge_sys_math.h:62
COLOR_SB_VISIBILITY_DOT_NONE
@ COLOR_SB_VISIBILITY_DOT_NONE
Definition: c4d_colors.h:403
Quaternion
Definition: c4d_quaternion.h:21
MAXON_MOVE_MEMBERS
#define MAXON_MOVE_MEMBERS(...)
Definition: classhelpers.h:423
ZP
ZP
Definition: unicodeutils.h:27
FIX_DOMAIN
FIX_DOMAIN
Definition: corenodes_helpers.h:51
CAMORPH_DATA_FLAGS::R
@ R
HPB rotation morphing.
STRUCT
STRUCT
The data type has an underlying TupleDataType with named members.
Definition: apibase.h:2162
maxon::g_zeroPtr
static const void *const g_zeroPtr
A global const void* value initialized to zero. Compilers will be able to do optimizations because th...
Definition: apibase.h:1131
DOMAIN_FLOW_SEQUENCED
DOMAIN_FLOW_SEQUENCED
Definition: corenodes_helpers.h:29
maxon::CONVERSION_FLAGS
CONVERSION_FLAGS
Definition: datatypebase.h:59
DA
DA
Definition: c4d_gedata.h:36
NEXT_ITV
NEXT_ITV
Definition: corenodes_instances.h:28
maxon::corenodes::WIRETYPE
WIRETYPE
Definition: corenodes_helpers.h:42
MAXON_ATTRIBUTE_FORCE_INLINE
#define MAXON_ATTRIBUTE_FORCE_INLINE
Definition: apibase.h:105
NBIT::MAX
@ MAX
Maximum NBIT.
maxon::Color64
Col3< Float64, 1 > Color64
Definition: vector.h:78
ACTIVEOBJECTMODE
ACTIVEOBJECTMODE
Definition: lib_activeobjectmanager.h:30
BaseDrawHelp
Definition: c4d_basedraw.h:39
CURRENT_ITV_GROUP
CURRENT_ITV_GROUP
Definition: corenodes_instances.h:42
LU
LU
Definition: unicodeutils.h:3
LayerData::solo
Bool solo
Definition: c4d_basedocument.h:344
maxon::SquareMatrix2d32
SqrMat2< Vector2d32 > SquareMatrix2d32
Single-precision 2×2 matrix.
Definition: matrix2d.h:393
maxon::MAXON_CONCAT
MAXON_ATTRIBUTE_FORCE_INLINE auto MAXON_CONCAT(GetMemorySize, Helper)(OverloadRank1
INDUCED_DOMAIN
INDUCED_DOMAIN
Definition: corenodes_helpers.h:50
TempUVHandle
Definition: c4d_painter.h:62
maxon::GetParentTypeSupportDelegate
Delegate< Block< ParametricType >()> GetParentTypeSupportDelegate
Definition: datatype_builder.h:62
maxon::PI05_INV
static constexpr Float64 PI05_INV
floating point constant: 1.0 / (0.5 * PI)
Definition: apibasemath.h:154
SERVERMESSAGE::INFO
@ INFO
Info.
TRIVIALLY_DESTRUCTIBLE
TRIVIALLY_DESTRUCTIBLE
Values of the data type are trivially destructible.
Definition: apibase.h:2187
NBIT::NODE_TEMP
@ NODE_TEMP
Private.
TreeViewFunctions::GetNameForEdit
virtual String GetNameForEdit(void *root, void *userdata, void *obj)
MATCH_DOMAIN
MATCH_DOMAIN
Definition: corenodes_helpers.h:49
BaseObject
Definition: c4d_baseobject.h:224
ALL
ALL
Definition: c4d_baseeffectordata.h:3
SDKBrowserPluginInterface::GetPluginID
Int32 GetPluginID(String *plugin_name=nullptr) const
Returns SDKBrowserPluginInterfaceInfo::GetPluginID(plugin_name) for the plugin.
maxon::Mat3
Definition: matrix.h:269
ELEMENT_TYPE_AS_ARG
ELEMENT_TYPE_AS_ARG
This flag is set for a parametric type which uses the element type to store the type arguments of the...
Definition: apibase.h:2192
ZERO_INITIALIZED
ZERO_INITIALIZED
Values of the data type are initialized with zeroes by their default constructor, also set for scalar...
Definition: apibase.h:2184
maxon
The maxon namespace contains all declarations of the MAXON API.
Definition: c4d_basedocument.h:15
RELEASE_37_VS2015
RELEASE_37_VS2015
Definition: vm.h:44
MAXON_IMPLICIT
#define MAXON_IMPLICIT
Definition: apibase.h:168
MAXRANGE_FLOAT32
static constexpr Float32 MAXRANGE_FLOAT32
'safe' maximum range for Float32. Guarantees that multiplication of two numbers doesn't produce an ov...
Definition: apibasemath.h:20
DescID
Definition: lib_description.h:327
maxon::SSLPROTOCOLVERSION
SSLPROTOCOLVERSION
Defines possible ssl protocol versions.
Definition: network_ip_ssl.h:17
TreeViewFloatSliderInfo::minValue
Float minValue
The minimum range of the slider as drawn.
Definition: customgui_listview.h:178
MAXON_INTERFACE_BASES
#define MAXON_INTERFACE_BASES(...)
Definition: objectbase.h:977
maxon::Tuple
Definition: tuple.h:553
DESCPROP::KEY
@ KEY
Has a key on the current frame.
MAXON_ENUM_ORDERED_LIST
enum SNAPPRIORITY MAXON_ENUM_ORDERED_LIST(SNAPPRIORITY)
INT_SIZE_OR_LESS
INT_SIZE_OR_LESS
Values of the data type fit into an Int.
Definition: apibase.h:2183
BaseDraw::PointInRange
Bool PointInRange(const Vector &p, Int32 x, Int32 y, Float range=10.0_f) const
Definition: c4d_basedraw.h:1684
UInt32
maxon::UInt32 UInt32
Definition: ge_sys_math.h:59
SC
SC
Definition: unicodeutils.h:22
DEFAULT_37
DEFAULT_37
Definition: vm.h:50
VPGETFRAGMENTS::N
@ N
Get VPFragment::n.
LO
LO
Definition: unicodeutils.h:7
maxon::GetZeroRef
const T & GetZeroRef()
Definition: apibase.h:1122
maxon::details::FreeArrayIteratorPersistentId
void FreeArrayIteratorPersistentId(PersistentIdBuffer *idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1052
FORMAT_PERCENT
@ FORMAT_PERCENT
Floating point with % sign, 1.0 = 100%.
Definition: c4d_gui.h:40
RESOURCE_DEFINE
#define RESOURCE_DEFINE(ID, VAL)
Definition: fid.h:93
LT
LT
Definition: unicodeutils.h:5
R23_CONVERTENUM
R23_CONVERTENUM
convert .enum and .command. to #enum and #command#
Definition: datadescriptiondefinition_conversion.h:4
maxon::Pix64f
Float64 Pix64f
pixel format with 64 bit floating point values.
Definition: gfx_image_imagechannel.h:25
AMFILTERFLAGS::SHOWDRIVERDRIVENXPRESSO
@ SHOWDRIVERDRIVENXPRESSO
Hide attributes if they are an expresso driver or driven.
Float
maxon::Float Float
Definition: ge_sys_math.h:64
maxon::GetChildrenCountDelegate
Delegate< Tuple< Int, Int, Bool >()> GetChildrenCountDelegate
Definition: datatype_builder.h:60
INTERSECTION_DOMAIN
INTERSECTION_DOMAIN
Definition: corenodes_helpers.h:53
COLOR_SB_VISIBILITY_DOT_ENABLED
@ COLOR_SB_VISIBILITY_DOT_ENABLED
Definition: c4d_colors.h:404
SINGLE_VALUE_ARRAY
SINGLE_VALUE_ARRAY
Definition: containerbase.h:40
PORT
PORT
Definition: corenodes_helpers.h:59
maxon::operator++
PORT_DIR & operator++(PORT_DIR &dir)
Definition: graph_basics.h:32
MINVALUE_FLOAT64
static constexpr Float64 MINVALUE_FLOAT64
the minimum value a Float64 can represent
Definition: apibasemath.h:10
SDKBrowserURL
Definition: lib_browser.h:70
maxon::GetFunctionName
constexpr const Char * GetFunctionName(const Char *funcName)
Definition: objectbase.h:2658
ARRAY
ARRAY
Array.
Definition: ge_prepass.h:3360
maxon::SquareMatrix4d
SqrMat4< Vector4d > SquareMatrix4d
Matrix with the precision of Float.
Definition: matrix4d.h:294
V_ARRAY
V_ARRAY
Definition: containerbase.h:38
UNUSED
UNUSED
Configuration value was not used by or known to the application. This is e.g. true for environment va...
Definition: configuration.h:2
MAP
MAP
< The collection is a map.
Definition: apibase.h:2139
maxon::py::PYTHONFLAG
PYTHONFLAG
Definition: cpython_raw.h:205
BASEARRAY
BASEARRAY
The data type is a BaseArray type.
Definition: apibase.h:2169
BLOCKARRAY
BLOCKARRAY
The data type is a BlockArray type.
Definition: apibase.h:2170
EditorWindow
Helper class for the editor's window.
Definition: c4d_tooldata.h:49
DRAWFLAGS
DRAWFLAGS
Definition: ge_prepass.h:2598
maxon::OUTPUT
OUTPUT
output flags for console output
Definition: debugdiagnostics.h:52
CONCAT_CONTAINER
CONCAT_CONTAINER
Definition: containerbase.h:36
SIGNED
SIGNED
This flag is set for floating point and signed integer types.
Definition: apibase.h:2194
maxon::SQRT_PI2
static constexpr Float64 SQRT_PI2
floating point constant: Sqrt(2.0 * PI)
Definition: apibasemath.h:160
maxon::GetDataDescriptionValue2
static Result< TT > GetDataDescriptionValue2(ATTRIBUTETYPE &&attribute, const ConstDataPtr &key)
Definition: datadictionary.h:378
R23_CONVERTENUM2
R23_CONVERTENUM2
convert .enum and .command. fixes ITEM#328085 [RE] Strings Translation tool deletes already translate...
Definition: datadescriptiondefinition_conversion.h:5
Matrix64
maxon::Mat3< maxon::Vector64 > Matrix64
Definition: ge_math.h:163
maxon::corenodes::GetPortType
const DataType & GetPortType()
Definition: corenodes_instances.h:18
Turbulence
Float Turbulence(const Vector &p, Float oct, Bool abs)
Definition: c4d_tools.h:1131
Float32
maxon::Float32 Float32
Definition: ge_sys_math.h:66
maxon::details::InitArrayIterator
Result< Int > InitArrayIterator(const ARRAY &array, ViewIteratorMember *members, const MemberMap *map, Int *state, PersistentIdBuffer *idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1147
EMPTY_CONTAINER
EMPTY_CONTAINER
The data type is a ContainerDataType.
Definition: apibase.h:2208
MAXON_DATATYPE
#define MAXON_DATATYPE(type, id)
Definition: datatype.h:309
maxon::Color32
Col3< Float32, 1 > Color32
Definition: vector.h:74
maxon::Data
Definition: datatypebase.h:1143
BitmapButtonCallback::ShowPopup
void(* ShowPopup)(void *data)
Callback called when the user presses the bitmap button. Can be used to bring up a popup menu.
Definition: customgui_bitmapbutton.h:108
BaseThread
Definition: c4d_thread.h:27
maxon::NullValue
T NullValue()
Definition: nullvalue.h:214
maxon::COLLECTION_KIND
COLLECTION_KIND
Definition: apibase.h:2364
TreeViewCustomGui
Definition: customgui_listview.h:1068
COLOR_SB_CARET_TEXT
@ COLOR_SB_CARET_TEXT
Definition: c4d_colors.h:394
PF
PF
Definition: unicodeutils.h:19
ADJUSTMENT
ADJUSTMENT
Definition: gfx_image.h:424
MAXON_GENERIC_BASE
#define MAXON_GENERIC_BASE(...)
Definition: interfacebase.h:1634
COMMUTATIVE
COMMUTATIVE
Definition: corenodes_instances.h:30
SCENENODES_IDS::PERSISTENT_HASH_LOW_ID
@ PERSISTENT_HASH_LOW_ID
Persistent Hash ID.
Vector64
maxon::Vec3< maxon::Float64, 1 > Vector64
Definition: ge_math.h:143
maxon::ENUM_DONT_INITIALIZE
ENUM_DONT_INITIALIZE
Definition: apibase.h:537
maxon::ColorA32
Col4< Float32, 1 > ColorA32
Definition: vector4d.h:52
Int16
maxon::Int16 Int16
Definition: ge_sys_math.h:56
TreeViewFloatSliderInfo::value
Float value
The current value for the entry.
Definition: customgui_listview.h:177
maxon::SCCCheckOutFile
Result< void > SCCCheckOutFile(const Url &url, Bool outputError)
Definition: sourcecontrol.h:306
InitFbm
void InitFbm(Float *table, Int32 max_octaves, Float lacunarity, Float h)
Definition: c4d_tools.h:1171
CONTAINS_RECURSIVE_CONTAINER
CONTAINS_RECURSIVE_CONTAINER
The data type directly or indirectly contains a recursive container type.
Definition: apibase.h:2216
AMFILTERFLAGS::SHOWOVERRIDEN
@ SHOWOVERRIDEN
Hide attributes if they are overriden.
Multipass::vp_magicBulletLooks
Vector * vp_magicBulletLooks
Channel without Magic Bullet Looks effect.
Definition: c4d_shader.h:851
CAMORPH_PSDINTERPOLATION_MODE::DEFAULT
@ DEFAULT
Default.
LM
LM
Definition: unicodeutils.h:6
STD_IS_REPLACEMENT
#define STD_IS_REPLACEMENT(name,...)
Definition: compilerdetection.h:307
GetUVSeams
const EdgeBaseSelect * GetUVSeams(const BaseObject *obj)
maxon::Bool
bool Bool
boolean type, possible values are only false/true, 8 bit
Definition: apibase.h:177
maxon::details::PrivateGetReferenceCounter
StrongReferenceCounter & PrivateGetReferenceCounter(const void *obj)
Definition: system.h:264
BaseSceneHook::Draw
void Draw(BaseDocument *doc, BaseDraw *bd, BaseDrawHelp *bh, BaseThread *bt, SCENEHOOKDRAW flags)
Private.
SUBSTANCE_OUTPUT_TYPE::UNKNOWN
@ UNKNOWN
maxon::DBVERSION
DBVERSION
used in FixDatabaseProps.
Definition: datadescriptiondefinition_conversion.h:14
PI2_INV
static constexpr Float64 PI2_INV
floating point constant: 1.0 / (2.0 * PI)
Definition: apibasemath.h:121
maxon::Vec4
A vector consisting of four components X, Y, Z and W.
Definition: vec4.h:14
VIEWPORTTYPE
VIEWPORTTYPE
Definition: ge_prepass.h:5542
TreeViewFloatSliderInfo::minNominalValue
Float minNominalValue
The minimum range of the slider should the user drag the value out of bounds to re-size the slider ra...
Definition: customgui_listview.h:180
MINRANGE_FLOAT64
static constexpr Float64 MINRANGE_FLOAT64
'safe' minimum range for Float. Guarantees that multiplication of two numbers doesn't produce an over...
Definition: apibasemath.h:22
maxon::corenodes::CORENODE_CONVERT_BASEID
constexpr MAXON_WARNING_PUSH LiteralId CORENODE_CONVERT_BASEID
Definition: corenodes_conversion.h:26
MAXVALUE_INT32_FLOAT32
static constexpr Float32 MAXVALUE_INT32_FLOAT32
maximum Float32 value that can be represented by Int32 ( 0x7FFFFF80). Higher values will results in a...
Definition: apibasemath.h:14
maxon::DEFAULTRUNTIME
DEFAULTRUNTIME
Definition: vm.h:80
maxon::ValueReceiver
Delegate< Result< Bool >(T...)> ValueReceiver
Definition: delegate.h:826
DescID::GetHashCode
maxon::HashInt GetHashCode() const
MAXON_ADD_TO_CONST_REFERENCE_CLASS
#define MAXON_ADD_TO_CONST_REFERENCE_CLASS(...)
Definition: interfacebase.h:1127
PC
PC
Definition: unicodeutils.h:14
TRIVIALLY_COPYABLE
TRIVIALLY_COPYABLE
Values of the data type are trivially copyable.
Definition: apibase.h:2188
OUTER_DOMAIN
OUTER_DOMAIN
Definition: corenodes_instances.h:34
ToString
maxon::String ToString(const Filename &val, const maxon::FormatStatement *formatStatement, maxon::Bool checkDatatype=false)
FACTOR_REFERENCE
FACTOR_REFERENCE
Definition: corenodes_instances.h:40
MAXVALUE_FLOAT32
static constexpr Float32 MAXVALUE_FLOAT32
the maximum value a Float32 can represent
Definition: apibasemath.h:8
maxon::HASHMAP_MODE
HASHMAP_MODE
HASHMAP_MODE can be used as template argument for HashMap to control its behavior.
Definition: hashmap.h:732
maxon::ColorA64
Col4< Float64, 1 > ColorA64
Definition: vector4d.h:56
maxon::GET_DATATYPE_POLICY
GET_DATATYPE_POLICY
GET_DATATYPE_POLICY controls the behavior of GetDataType for special cases.
Definition: datatypebase.h:1103
maxon::CheckedVectorToSquareMatrix
SqrMat3< Vec3< FLOAT > > CheckedVectorToSquareMatrix(const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
maxon::Pix32u
UInt32 Pix32u
pixel format with 32 bit unsigned integer values (0..0xFFFFFFFF).
Definition: gfx_image_imagechannel.h:22
maxon::py37::NativePyObject
NativePyObjectHead_Release NativePyObject
Definition: cpython37_raw.h:66
ORDERED
ORDERED
Values of the data type are ordered (DataType::Compare can be used and implements a total order).
Definition: apibase.h:2185
VIEWPORTTYPE::UV_VIEW
@ UV_VIEW
UV viewport is active.
COLOR_TITLE_TEXT
@ COLOR_TITLE_TEXT
Definition: c4d_colors.h:396
maxon::SquareMatrix
SqrMat3< Vector > SquareMatrix
3×3 matrix with the precision of Float.
Definition: matrix.h:484
TreeViewFloatSliderInfo::maxNominalValue
Float maxNominalValue
The minimum range of the slider should the user drag the value out of bounds to re-size the slider ra...
Definition: customgui_listview.h:181
GeData::GeData
GeData(void)
Creates a DA_NIL data with no value.
Definition: c4d_gedata.h:103
maxon::Pix16f
HalfFloat< Pix32f > Pix16f
pixel format with 16 bit floating point values (half float).
Definition: gfx_image_imagechannel.h:26
MAXON_OBSERVABLE
#define MAXON_OBSERVABLE(RETTYPE, NAME,...)
Defined Observables for the source processor.
Definition: observable.h:736
DEEP_CONSTNESS
DEEP_CONSTNESS
The data type obeys deep constness.
Definition: apibase.h:2182
SubDialog
This class is for creating sub-dialogs that can be attached to a SUBDIALOG control in an ordinary GeD...
Definition: c4d_gui.h:2868
maxon::Construct
auto Construct(ITERATOR first, SENTINEL sentinel, const ARGS &... args) -> ITERATOR
Definition: algorithms.h:73
TreeViewFloatSliderInfo
Percentage floating slider information, filled out by the user.
Definition: customgui_listview.h:173
maxon::BaseArray
Definition: basearray.h:366
maxon::details::AdvanceArrayIteratorPersistentId
Result< void > AdvanceArrayIteratorPersistentId(Int index, PersistentIdBuffer &idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1180
ASK_FOR_REMOVE_WRITE_PROTECTION
ASK_FOR_REMOVE_WRITE_PROTECTION
If the file that should be written is write protected the system will ask for checkout/remove flags.
Definition: ioenums.h:7
maxon::Helper
Helper(OverloadRank2, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))
Definition: apibase.h:2170
MAXON_INTERFACE_SIMPLE_VIRTUAL
#define MAXON_INTERFACE_SIMPLE_VIRTUAL(Name, REFKIND)
Definition: interfacebase.h:1480
MN
MN
Definition: unicodeutils.h:8
maxon::APPLICATIONID::DRAWPORT_UNITTESTS
static const LiteralId DRAWPORT_UNITTESTS
Definition: applicationid.h:27
MAXON_OPERATOR_EQUALITY_HASHCODE
#define MAXON_OPERATOR_EQUALITY_HASHCODE(T,...)
Definition: classhelpers.h:498
InstanceObject::GetInstancePersistentHashes
maxon::Block< const maxon::HashValue > GetInstancePersistentHashes() const
maxon::CONFIGURATIONENTRY_ORIGIN
CONFIGURATIONENTRY_ORIGIN
Source where a configuration value was defined.
Definition: configuration.h:26
TreeViewFloatSliderInfo::TreeViewFloatSliderInfo
TreeViewFloatSliderInfo()
Definition: customgui_listview.h:175
NL
NL
Definition: unicodeutils.h:12
DEFAULT
DEFAULT
Default.
Definition: lib_ca.h:86
CONTAINER_OUTPUT_ELEMENT
CONTAINER_OUTPUT_ELEMENT
Definition: corenodes_instances.h:93
SCENEHOOKDRAW
SCENEHOOKDRAW
Definition: ge_prepass.h:3064
maxon::GetRangeItemCount
Int GetRangeItemCount(const RANGETYPE &data)
Definition: rangemap.h:988
AMFILTERFLAGS
AMFILTERFLAGS
Attribute Manager filter flags.
Definition: customgui_description.h:79
PI_INV
static constexpr Float64 PI_INV
floating point constant: 1.0 / PI
Definition: apibasemath.h:115
FIELDSAMPLE_FLAG::VALUE
@ VALUE
Sample only the value at the current point (minimum must still sample the value)
Matrix32
maxon::Mat3< maxon::Vector32 > Matrix32
Definition: ge_math.h:165
operator+
const BaseTime operator+(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:244
MINVALUE_INT64_FLOAT64
static constexpr Float64 MINVALUE_INT64_FLOAT64
minimum Float64 value that can be represented by Int64 (-0x7ffffffffffffdff). Lower values will resul...
Definition: apibasemath.h:16
SDKBrowserPluginInterfaceInfo::GetIcon
virtual SDKBrowserIcon * GetIcon(const SDKBrowserURL &url, Int32 pref_wh=0)=0
InstanceObject
Definition: lib_instanceobject.h:37
TreeViewFloatSliderInfo::increment
Float increment
The increment used for vertical modification.
Definition: customgui_listview.h:182
maxon::ThreadInterface
Definition: thread.h:45
ZS
ZS
Definition: unicodeutils.h:25
SM
SM
Definition: unicodeutils.h:21
GetUVSeams2
const EdgeBaseSelect * GetUVSeams2(const BaseObject *obj, Bool checkUVSettings=false)
UChar
maxon::UChar UChar
Definition: ge_sys_math.h:55
maxon::Group
void Group
special datatype for groups.
Definition: fid.h:102
ZL
ZL
Definition: unicodeutils.h:26
MODIFIERS
MODIFIERS
Definition: corenodes_instances.h:48
BLOCK
BLOCK
The data type is a Block.
Definition: apibase.h:2166
BaseDraw
Definition: c4d_basedraw.h:747
maxon::VariadicIdsType
Array< VariadicIdsElement > VariadicIdsType
Definition: datadescription_data.h:11
SOURCE_LEVEL
SOURCE_LEVEL
The data type is a type at sourcecode level which is represented by a different architecture- and ver...
Definition: apibase.h:2180
KEY
KEY
Has a key on the current frame.
Definition: customgui_descproperty.h:60
Utf8
Utf8
Definition: cpython.h:24
details
Definition: enumflags.h:113
BaseDraw::RenderViewportWithoutPostEffects
void RenderViewportWithoutPostEffects(maxon::ImageRef &image) const
Definition: c4d_basedraw.h:1861
maxon::SquareMatrix2d
SqrMat2< Vector2d > SquareMatrix2d
2×2 matrix with the precision of Float.
Definition: matrix2d.h:399
HYPERFILEVALUE::ARRAY
@ ARRAY
Array.
iPaintView
class CINEWARE_SINGLEINHERITANCE iPaintView
Definition: lib_paint.h:127
MAXON_OBSERVABLE_STATIC
#define MAXON_OBSERVABLE_STATIC(RETTYPE, NAME,...)
Definition: observable.h:740
HYPERFILEVALUE::CONTAINER
@ CONTAINER
BaseContainer.
ABSTRACT
ABSTRACT
The data type is an abstract type (for example Generic or an interface type).
Definition: apibase.h:2199
INDEPENDENT
INDEPENDENT
Definition: corenodes_instances.h:38
GeGetActiveViewportType
VIEWPORTTYPE GeGetActiveViewportType()
INCLUDE_IN_PREDECESSORS
INCLUDE_IN_PREDECESSORS
Definition: corenodes_instances.h:39
COLOR_SB_VISIBILITY_DOT_DISABLED
@ COLOR_SB_VISIBILITY_DOT_DISABLED
Definition: c4d_colors.h:405
MAXON_DISALLOW_COPY_AND_ASSIGN
#define MAXON_DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: classhelpers.h:293
FIRSTHITPPOINTTYPE::SELECTED
@ SELECTED
Use the exact hit location on the surface as the hit point.
COLOR_TEXT_EDIT_HELP
@ COLOR_TEXT_EDIT_HELP
Definition: c4d_colors.h:401
CPYMEM_DOMAIN_MEM
CPYMEM_DOMAIN_MEM
Definition: cpython.h:58
ND
ND
Definition: unicodeutils.h:11
MaxonConvert
maxon::Url MaxonConvert(const Filename &fn, MAXONCONVERTMODE convertMode)
maxon::VALUEKIND
VALUEKIND
Definition: apibase.h:2219
UNIQUE_REFERENCE
UNIQUE_REFERENCE
The data type is a BaseRef with unique ownership, i.e., the referenced object will be freed on destru...
Definition: apibase.h:2155
maxon::EQUALITY
EQUALITY
Definition: compare.h:33
Utf32Char
maxon::Utf32Char Utf32Char
Definition: ge_sys_math.h:73
AMFILTERFLAGS::SHOWANIMATED
@ SHOWANIMATED
Hide attributes if they are not animated.
SDKBrowserPluginInterface
Definition: lib_browser.h:465
operator/
const BaseTime operator/(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:239
STRIDE
#define STRIDE
Definition: vector.h:35
HUMAN_READABLE
HUMAN_READABLE
Definition: datatype_builder.h:2
ARRAY_CONTAINER
ARRAY_CONTAINER
The data type is a ContainerDataType.
Definition: apibase.h:2211
BLOCK_NESTING
BLOCK_NESTING
Definition: corenodes_helpers.h:46
MAXON_DATATYPE_SCALAR
#define MAXON_DATATYPE_SCALAR(type, id)
Definition: datatype.h:290
OPAQUE_QUALIFIED
OPAQUE_QUALIFIED
The type is opaque-qualified.
Definition: apibase.h:2178
OPTIONAL_INPUT
OPTIONAL_INPUT
Definition: corenodes_instances.h:41
VIDEO
VIDEO
mediatype video
Definition: network_smtpmail.h:6
Utf32
Utf32
Definition: cpython.h:26
DOMAIN_FLOW_PURE_VALUE_SEQUENCED_LIFETIME
DOMAIN_FLOW_PURE_VALUE_SEQUENCED_LIFETIME
Definition: corenodes_helpers.h:35
FLAG_MASK
FLAG_MASK
Definition: corenodes_helpers.h:54
String
Definition: c4d_string.h:38
KEY_HASH_VALUE
KEY_HASH_VALUE
Definition: hashmap.h:3
maxon::GetCount
Int GetCount(const ITERABLE &iterable)
Definition: collection.h:37
TUPLE_INHERIT_MASK
TUPLE_INHERIT_MASK
Definition: apibase.h:2233
MULTIPASSCHANNEL::IMAGELAYER
@ IMAGELAYER
Image layer.
MAXON_REFERENCE_COPY_ON_WRITE
#define MAXON_REFERENCE_COPY_ON_WRITE(DUMMY)
Definition: interfacebase.h:1043
maxon::src
const T & src
Definition: apibase.h:2525
TreeViewCustomGui::GetShowLines
Bool GetShowLines() const
MAXON_METHOD
#define MAXON_METHOD
Definition: interfacebase.h:855
maxon::NetworkIpAddrPort
Definition: network_ip_addr.h:438
maxon::MEDIAFORMAT::VIDEO::UNKNOWNFPS
static const Float UNKNOWNFPS
Definition: mediasession_base.h:224
maxon::details::HasBaseHelper
Definition: apibase.h:1181
RELEASE_37
RELEASE_37
Definition: vm.h:47
LayerData
Definition: c4d_basedocument.h:311
maxon::corenodes::GetPortHashCodeHelper
constexpr UInt GetPortHashCodeHelper(PORTIDTYPE const &inId)
Definition: micronodes_ports.h:708
maxon::COLLECTION_RESIZE_FLAGS
COLLECTION_RESIZE_FLAGS
Flags for Resize(). Depending on the type of collection the flags might be ignored (except for ON_GRO...
Definition: collection.h:125
Vector2d64
maxon::Vec2< maxon::Float64, 1 > Vector2d64
Definition: ge_math.h:149
ARRAY_OUTPUT_ELEMENT
ARRAY_OUTPUT_ELEMENT
Definition: corenodes_instances.h:94
RESULT
RESULT
The data type is a Result.
Definition: apibase.h:2172
maxon::PyStringEncodings
PyStringEncodings
Definition: cpython.h:28
maxon::ThreadRefTemplate< ThreadInterface >
maxon::Vec3< maxon::Float64, 1 >
MAXON_DECLARATION
#define MAXON_DECLARATION(T, Name, id)
Definition: module.h:797
maxon::SqrMat4
Definition: matrix4d.h:12
maxon::ToString
String ToString(const String &str, const FormatStatement *formatStatement, Bool=false)
Definition: string.h:1680
STATIC_ARRAY
STATIC_ARRAY
Definition: containerbase.h:37
Vector32
maxon::Vec3< maxon::Float32, 1 > Vector32
Definition: ge_math.h:139
Noise
Float Noise(const Vector &p)
Definition: c4d_tools.h:1086
INDUCED_MASK
INDUCED_MASK
Definition: corenodes_helpers.h:55
SUBSTANCE_IMPORT_COPY::NO
@ NO
Do not copy file to project directory (absolute file path).
MINVALUE_INT32_FLOAT32
static constexpr Float32 MINVALUE_INT32_FLOAT32
minimum Float32 value that can be represented by Int32 (-0x7FFFFF80). Lower values will results in an...
Definition: apibasemath.h:13
maxon::PyChar
Char PyChar
Definition: cpython_raw.h:190
SIZEOF
#define SIZEOF(x)
Calculates the size of a datatype or element.
Definition: apibasemath.h:205
maxon::InstantiateDataTypeDelegate
Delegate< Result< DataType >(const BaseArray< Member > &members)> InstantiateDataTypeDelegate
Definition: datatype_builder.h:61
BitmapButtonCallback
Callback for BitmapButtonCustomGui, registered with BitmapButtonCustomGui::SetCallback().
Definition: customgui_bitmapbutton.h:93
SDKBrowserPluginInterfaceInfo
Interface for browser plugins.
Definition: lib_browser.h:635
SNoise
Float SNoise(const Vector &p)
Definition: c4d_tools.h:1071
maxon::NetworkIpAddr
Reference counted class of NetworkIpAddrInterface.
Definition: network_ip_addr.h:400
NAMED
NAMED
This flag is set for tuple or container types with named members.
Definition: apibase.h:2200
GENERIC_CONTAINER
GENERIC_CONTAINER
This flag may be set for container types to indicate generic members.
Definition: apibase.h:2203
maxon::IsUnicodeLetter
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsUnicodeLetter(TYPE chr)
Checks if the passed character is a unicode letter.
Definition: unicodeutils.h:161
RidgedMultifractal
Float RidgedMultifractal(Float *table, const Vector &p, Float oct, Float offset, Float gain)
Definition: c4d_tools.h:1204
ENUM
ENUM
The data type is an unnamed enum type created by DataTypeLib::GetEnumType().
Definition: apibase.h:2143
SDKBrowserContentNodeInfo
Plugin interface for content node plugins.
Definition: lib_browser.h:858
CURRENT_ITV
CURRENT_ITV
Definition: corenodes_instances.h:27
maxon::VectorToSquareMatrix
SqrMat3< Vec3< FLOAT > > VectorToSquareMatrix(const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
maxon::Classes::Get
const Class< R > & Get(const Id &cls)
Definition: objectbase.h:1903
OBJECTSTATE::EDITOR_HIERARCHICAL
@ EDITOR_HIERARCHICAL
Hierarchical editor mode (MODE_ON, MODE_OFF)
PI
PI
Definition: unicodeutils.h:18
UInt16
maxon::UInt16 UInt16
Definition: ge_sys_math.h:57
maxon::Destruct
auto Destruct(ITERATOR first, SENTINEL sentinel) -> ITERATOR
Definition: algorithms.h:110
NBIT
NBIT
Definition: ge_prepass.h:676
maxon::SQRT2_INV
static constexpr Float64 SQRT2_INV
floating point constant: 1.0 / Sqrt(2.0)
Definition: apibasemath.h:163
FONT_ITALIC
@ FONT_ITALIC
Italics font.
Definition: gui.h:29
MODELINGCOMMANDFLAGS
MODELINGCOMMANDFLAGS
Definition: ge_prepass.h:4050
SDKBrowser
The main browser library class.
Definition: lib_browser.h:1717
maxon::LOG2
static constexpr Float64 LOG2
floating point constant: Log(2.0)
Definition: apibasemath.h:169
maxon::SquareMatrix4d64
SqrMat4< Vector4d64 > SquareMatrix4d64
Double-Precision Matrix.
Definition: matrix4d.h:291
DONT_WRAP
DONT_WRAP
Definition: corenodes_instances.h:26
SINGLETON_CONTAINER
SINGLETON_CONTAINER
The data type is a ContainerDataType.
Definition: apibase.h:2209
MODE
MODE
Definition: network_ip_ssl.h:6
TRG_MARK
TRG_MARK
Definition: corenodes_helpers.h:45
maxon::Pix32s
Int32 Pix32s
pixel format with 32 bit signed integer values (-0x7FFFFFFF..0x7FFFFFFF).
Definition: gfx_image_imagechannel.h:23
LIMIT
Definition: apibasemath.h:33
CriticalStop
#define CriticalStop(...)
Definition: debugdiagnostics.h:234
TYPE
TYPE
Int32.
Definition: c4d_basebitmap.h:6
maxon::HASHMAP_ENTRY_LAYOUT
HASHMAP_ENTRY_LAYOUT
Definition: hashmap.h:13
CONDITIONAL_DOMAIN
CONDITIONAL_DOMAIN
Definition: corenodes_helpers.h:52
BaseSceneHook
Definition: c4d_basedocument.h:43
DRAWPASS::BOX
@ BOX
Box pass.
NOTOK
#define NOTOK
Definition: ge_sys_math.h:265
maxon::OverloadRank1
PrivateOverloadRank1 * OverloadRank1
See OverloadRank0.
Definition: apibase.h:612
DEBUG_37_VS2015
DEBUG_37_VS2015
Definition: vm.h:43
maxon::Vec2< maxon::Float64, 1 >
maxon::corenodes::ACCESS_INDEX
ACCESS_INDEX
Definition: corenodes_helpers.h:28
DONT_INITIALIZE
static const maxon::ENUM_DONT_INITIALIZE DONT_INITIALIZE
Definition: ge_math.h:135
maxon::AssertCast
RESULT AssertCast(SRC &&ref)
Definition: objectbase.h:1539
maxon::alignment
Int alignment
Definition: apibase.h:660
TRIVIALLY_EQUATABLE
TRIVIALLY_EQUATABLE
Values of the data type are trivially equatable (see IsTriviallyEquatable).
Definition: apibase.h:2189
Fbm
Float Fbm(Float *table, const Vector &p, Float oct)
Definition: c4d_tools.h:1181
PaintView::SetShowMeshWireframe
Bool SetShowMeshWireframe(Bool showMesh)
ITV_GROUP_MASK
ITV_GROUP_MASK
Definition: corenodes_instances.h:46
Max
X Max(X a, X b)
Calculates the maximum of two values and return it.
Definition: apibasemath.h:215
SCENENODES_IDS::MSGUPDATE_LEGACYOBJ_ID
@ MSGUPDATE_LEGACYOBJ_ID
Legacy Objects Update Message ID.
maxon::corenodes::details::CreateNode
Result< typename std::decay< typename GetSignature< decltype(&N::Init)>::Parameters::template At< 0 >::type >::type > CreateNode(OverloadRank0, const Id &nodeId, ARGS &&... args)
Definition: corenodes.h:786
maxon::SQRT2
static constexpr Float64 SQRT2
floating point constant: Sqrt(2.0)
Definition: apibasemath.h:157
maxon::details::MoveArrayIteratorPersistentId
Result< void > MoveArrayIteratorPersistentId(Int index, PersistentIdBuffer *idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1068
SYNCHRONIZED
SYNCHRONIZED
Use atomic access to implement a lock-free hash map.
Definition: hashmap.h:3
GeData
Definition: c4d_gedata.h:82
VIEWPORTTYPE::NONE
@ NONE
No viewport is active.
LINESTYLE::DASHED_BIG
@ DASHED_BIG
MATH_SQUAREMATRIX
#define MATH_SQUAREMATRIX
Definition: lib_math.h:79
DescID::_private
std::aligned_storage< sizeof(maxon::BaseArray< DescLevel >), alignof(maxon::BaseArray< DescLevel >)>::type _private
Definition: lib_description.h:329
MDDIRTY::NONE
@ NONE
maxon::ResultMem
ResultMemT< Bool > ResultMem
Definition: apibaseid.h:45
maxon::rla::MAXRenderInfo
Definition: mediasession_image_export_rla.h:66
Utf16
Utf16
Definition: cpython.h:25
Int32
maxon::Int32 Int32
Definition: ge_sys_math.h:58
COLOR_MANAGER_BG_TREEVIEW
@ COLOR_MANAGER_BG_TREEVIEW
Definition: c4d_colors.h:399
MAXRANGE_FLOAT
static constexpr Float MAXRANGE_FLOAT
'safe' maximum range for Float64. Guarantees that multiplication of two numbers doesn't produce an ov...
Definition: apibasemath.h:29
MDDIRTY::ALL
@ ALL
BaseDraw::GetDrawportContext
void GetDrawportContext(maxon::DrawportContextRef &context) const
Definition: c4d_basedraw.h:1846
FUNCTION
FUNCTION
The type is a FunctionDataType (i.e., a GenericFunction bound to input and output types).
Definition: apibase.h:2175
maxon::WriteDocument
Result< void > WriteDocument(const Url &url, OPENSTREAMFLAGS flags, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
Definition: io.h:67
VIEWPORTTYPE::MAIN_VIEW
@ MAIN_VIEW
Main 3D viewport is active.
ME
ME
Definition: unicodeutils.h:10
maxon::GetDataTypeNameDelegate
Delegate< Result< Tuple< String, String > >(DATATYPEBUILDERNAME category, const DataType &dt, const GetChildrenTypesCallback &getChildrenTypes, const ParametricTypeInterface *parentTypeId, const ParametricTypeInterface **skipParentType)> GetDataTypeNameDelegate
Definition: datatype_builder.h:59
SK
SK
Definition: unicodeutils.h:23
maxon::ADDOBSERVER_DEFAULTPRIORITY
static constexpr Int ADDOBSERVER_DEFAULTPRIORITY
Definition: observable.h:415
LL
LL
Definition: unicodeutils.h:4
RECURSIVE_CONTAINER
RECURSIVE_CONTAINER
The data type represents a recursive container type.
Definition: apibase.h:2204
Min
X Min(X a, X b)
Calculates the minimum of two values and return it.
Definition: apibasemath.h:212
STRIDED_BLOCK
STRIDED_BLOCK
The data type is a strided Block.
Definition: apibase.h:2167
maxon::PersistentIdBuffer
BufferedBaseArray< Int64, 10 > PersistentIdBuffer
Definition: containerbase.h:26
DEFAULT_INPUT
DEFAULT_INPUT
Definition: corenodes_helpers.h:67
MAXON_ATTRIBUTE_CLASS
#define MAXON_ATTRIBUTE_CLASS(TYPE, NAME, RID,...)
Definition: fid.h:165
maxon::Col3< Float, 1 >
maxon::SquareMatrix2d64
SqrMat2< Vector2d64 > SquareMatrix2d64
Double-precision 2×2 matrix.
Definition: matrix2d.h:396
DESCPROP::HIDDEN
@ HIDDEN
Hidden description property.
TLS
TLS
< use newest TLS version.
Definition: network_ip_ssl.h:6
maxon::SquareMatrix32
SqrMat3< Vector32 > SquareMatrix32
Single-precision 3×3 matrix.
Definition: matrix.h:478
maxon::HashInt
UInt HashInt
Definition: apibase.h:322
MAXVALUE_FLOAT
static constexpr Float MAXVALUE_FLOAT
the maximum value a Float can represent
Definition: apibasemath.h:26
MC
MC
Definition: unicodeutils.h:9
DEFAULTVALUE
@ DEFAULTVALUE
Dummy value for the default value GeData constructor.
Definition: c4d_gedata.h:65
MACHINEFEATURESTYPE::CURRENT
@ CURRENT
Get Machine features for the currently active OpenGL type.
STATIC_ARRAY_CONTAINER
STATIC_ARRAY_CONTAINER
The data type is a ContainerDataType.
Definition: apibase.h:2210
ACTIVEOBJECTMODE::NODEV2
@ NODEV2
New Node mode.
BaseSceneHook::InitDisplayControl
Bool InitDisplayControl(BaseDocument *doc, BaseDraw *bd, const AtomArray *active)
Private.
C4DLibrary
Definition: c4d_library.h:27
NEXT_ITV_GROUP
NEXT_ITV_GROUP
Definition: corenodes_instances.h:43
std
Definition: apibase.h:499
maxon::DATATYPEBUILDERNAME
DATATYPEBUILDERNAME
Definition: datatype_builder.h:16
AddMarker
BaseList2D * AddMarker(BaseDocument *doc, BaseList2D *pPred, BaseTime time, String name, maxon::Color color=maxon::Color(), BaseTime length=BaseTime(), LayerObject *obj=nullptr)
MINRANGE_FLOAT
static constexpr Float MINRANGE_FLOAT
'safe' minimum range for Float64. Guarantees that multiplication of two numbers doesn't produce an ov...
Definition: apibasemath.h:28
GENERIC_INSTANTIATION
GENERIC_INSTANTIATION
The data type is an instantiation of a generic base type for given arguments.
Definition: apibase.h:2196
ON_GROW_RESERVE_CAPACITY
ON_GROW_RESERVE_CAPACITY
Allocate some extra capacity (based on ComputeArraySize()).
Definition: collection.h:114
maxon::FormatStatement
Class to store formatting statements.
Definition: string.h:1960
SDKReferenceObjectPtr
Definition: sdkreferenceobjectptr.h:26
ViewportSelect
Definition: c4d_basedraw.h:1892
SDKBrowserPluginInterfaceInfo::plugin
SDKBrowserPluginRef plugin
Definition: lib_browser.h:640
LINKBOX_NO_PICKER
@ LINKBOX_NO_PICKER
Bool No picker mode.
Definition: customgui_linkbox.h:31
ELEMENT_DOMAIN
ELEMENT_DOMAIN
Definition: corenodes_helpers.h:48
CONTAINER_MASK
CONTAINER_MASK
The data type is a ContainerDataType.
Definition: apibase.h:2213
BaseObject::GetEditorModeH
Int32 GetEditorModeH(void) const
MAXON_WARN_UNUSED_CLASS
#define MAXON_WARN_UNUSED_CLASS
Definition: compilerdetection.h:323
MAXON_ENUM_LIST
#define MAXON_ENUM_LIST(E,...)
Definition: enumflags.h:104
MODELINGCOMMANDFLAGS::IMPORTER
@ IMPORTER
Can be used by importer plugins to avoid additional checks for polygon meshes (e.g conversion of pose...
CPYMEM_DOMAIN_OBJ
CPYMEM_DOMAIN_OBJ
Definition: cpython.h:60
MAXON_SOURCE_LOCATION_DECLARATION
#define MAXON_SOURCE_LOCATION_DECLARATION
Definition: memoryallocationbase.h:73
maxon::ConvertPixel
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel(Pix8u &dst, const Pix8u src)
Definition: gfx_image_pixelformat_template.h:139
PS
PS
Definition: unicodeutils.h:16
VIEWPORT_PICK_FLAGS
VIEWPORT_PICK_FLAGS
Definition: ge_prepass.h:4524
BaseBitmap
Definition: c4d_basebitmap.h:410
maxon::SquareMatrix4d32
SqrMat4< Vector4d32 > SquareMatrix4d32
Single-Precision Matrix.
Definition: matrix4d.h:288
PE
PE
Definition: unicodeutils.h:17
PI05
static constexpr Float64 PI05
floating point constant: 0.5 * PI
Definition: apibasemath.h:124
MAXRANGE_FLOAT64
static constexpr Float64 MAXRANGE_FLOAT64
'safe' maximum range for Float. Guarantees that multiplication of two numbers doesn't produce an over...
Definition: apibasemath.h:23
maxon::FbmTableRef
OpaqueRef FbmTableRef
Definition: noise.h:17
maxon::ProcessEnumListDelegate
Delegate< Result< void >(const Id &epId, const DataDictionary &guiEntry, const AssetRepositoryRef &repository, const Data *filterData, const ValueReceiver< Tuple< Id, Data, String > && > &addValue)> ProcessEnumListDelegate
Definition: datadescriptiondatabase.h:95
operator*
const BaseTime operator*(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:234
maxon::SQRT3
static constexpr Float64 SQRT3
floating point constant: Sqrt(3.0)
Definition: apibasemath.h:166
Vector4d64
maxon::Vector4d64 Vector4d64
Definition: vector4.h:18
PO
PO
Definition: unicodeutils.h:20
MAXON_FUNCTION
#define MAXON_FUNCTION
Definition: interfacebase.h:873
OBJECTSTATE::RENDER_HIERARCHICAL
@ RENDER_HIERARCHICAL
Hierarchical render mode (MODE_ON, MODE_OFF)
Int64
maxon::Int64 Int64
Definition: ge_sys_math.h:60
CO
CO
Definition: unicodeutils.h:31
DA_DATA
@ DA_DATA
maxon::Data, @Since R23
Definition: c4d_gedata.h:55
PORTS
PORTS
Include ports.
Definition: corenodes.h:405
maxon::SCTypeConversion
HashMap< CString, SCConversionFunction > SCTypeConversion
Definition: sourcecontrol.h:18
TreeViewFloatSliderInfo::unit
Int32 unit
The sliders unit.
Definition: customgui_listview.h:185
DELEGATE
DELEGATE
The type is a DelegateDataType.
Definition: apibase.h:2174
CF
CF
Definition: unicodeutils.h:29
maxon::GetDefaultFromFidIfAvailable
TT GetDefaultFromFidIfAvailable(KEY &&key, OverloadRank0)
Definition: datadictionary.h:409
maxon::details::InitArrayIteratorPersistentId
Result< void > InitArrayIteratorPersistentId(PersistentIdBuffer *idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1130
STATE_MODIFIER
STATE_MODIFIER
Definition: corenodes_instances.h:22
VIEWPORT_PICK_FLAGS::NO_DEPTH_CORRECTION
@ NO_DEPTH_CORRECTION
To support old tools, the matrix is usually corrected so that the depth can be in the [-1,...
SDKBrowserContentNode
Browser content node. A wrapper for calling SDKBrowserContentNodeInfo functions.
Definition: lib_browser.h:1127
Bool
maxon::Bool Bool
Definition: ge_sys_math.h:53
MAXON_ATTRIBUTE
#define MAXON_ATTRIBUTE(TYPE, NAME, RID,...)
Definition: fid.h:146
CODE_CPP
CODE_CPP
Definition: datatype_builder.h:3
STATE_MAPPER
STATE_MAPPER
Definition: corenodes_instances.h:31
UInt
maxon::UInt UInt
Definition: ge_sys_math.h:63
LayerData::LayerData
LayerData()
Default constructor.
Definition: c4d_basedocument.h:362
Vector4d32
maxon::Vector4d32 Vector4d32
Definition: vector4.h:17
MAXVALUE_FLOAT64
static constexpr Float64 MAXVALUE_FLOAT64
the maximum value a Float64 can represent
Definition: apibasemath.h:11
PaintView::GetShowMeshWireframe
Bool GetShowMeshWireframe(Bool &showMesh)
maxon::details::PrivateFreeWithDestructor
void PrivateFreeWithDestructor(const T *obj)
Definition: system.h:269
LIFETIME
LIFETIME
Definition: corenodes_helpers.h:25
MAXON_ENUM_FLAGS_CLASS
#define MAXON_ENUM_FLAGS_CLASS(E,...)
Definition: enumflags.h:168
maxon::Reset
void Reset(T &object)
Definition: apibase.h:2592
maxon::corenodes::GetScalarConversionFlags
MAXON_WARNING_POP CONVERSION_FLAGS GetScalarConversionFlags()
Definition: corenodes_conversion.h:58
SCENENODES_IDS
SCENENODES_IDS
Definition: ge_prepass.h:5555
CINEWARE_SINGLEINHERITANCE
#define CINEWARE_SINGLEINHERITANCE
Definition: ge_sys_math.h:30
observable.h
AUDIO
AUDIO
mediatype audio
Definition: network_smtpmail.h:5
KEEP_LETTER_CASE
KEEP_LETTER_CASE
Definition: corenodes_instances.h:37
S22
S22
Definition: datadescriptiondefinition_conversion.h:2
TreeViewCustomGui::SetShowLines
void SetShowLines(Bool show)
maxon::VectorToMatrix
Mat3< Vec3< FLOAT > > VectorToMatrix(const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
LAZY
LAZY
Definition: corenodes_helpers.h:44
AtomArray
Definition: c4d_baselist.h:1587
maxon::SquareMatrix64
SqrMat3< Vector64 > SquareMatrix64
Double-precision 3×3 matrix.
Definition: matrix.h:481
BitmapButtonCallback::data
void * data
Custom data.
Definition: customgui_bitmapbutton.h:103
ClampValue
X ClampValue(X value, X lowerLimit, X upperLimit)
Clips a value against a lower and upper limit. The new value is returned.
Definition: apibasemath.h:221
maxon::DataDescriptionEntry
DataDictionary DataDescriptionEntry
Definition: datadescriptiondefinition.h:28
TreeViewFloatSliderInfo::state
Int32 state
Set to the current state of the slider.
Definition: customgui_listview.h:184
XFORM_CONTAINER
XFORM_CONTAINER
Definition: containerbase.h:35
operator==
Bool operator==(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:254
OBJECTSTATE
OBJECTSTATE
Definition: ge_prepass.h:4263
EdgeBaseSelect
Definition: c4d_baseselect.h:316
KEY_VALUE
KEY_VALUE
Definition: hashmap.h:2
maxon::UseFilterData
Bool UseFilterData(const Data *filterData, const Data &compare)
Definition: datadescriptiondatabase.h:110
NEVER_NULLPTR
NEVER_NULLPTR
This flag is set for pointer or reference types which never hold a nullptr value.
Definition: apibase.h:2193
Char
maxon::Char Char
Definition: ge_sys_math.h:54
BaseDocument
Definition: c4d_basedocument.h:490
SUSPEND
SUSPEND
Definition: corenodes_instances.h:36
VALUE_KEY
VALUE_KEY
Definition: hashmap.h:4
MATH_VECTOR
#define MATH_VECTOR
Definition: lib_math.h:76
maxon::StrongRef
BaseRef< T, StrongRefHandler > StrongRef
Definition: baseref.h:918
GLOBALLY_REFERENCED
GLOBALLY_REFERENCED
The data type is globally referenced and AddReference() and RemoveReference() should not access its r...
Definition: apibase.h:2198
PORT_MODIFIERS
PORT_MODIFIERS
Definition: corenodes_instances.h:47
MIXTYPE::MIN
@ MIN
BITS
BITS
Change to object bits, e.g. selection status. (Needs to be called before the change....
Definition: ge_prepass.h:2537
maxon::CONFIGURATIONENTRY_STATE
CONFIGURATIONENTRY_STATE
State of a configuration value.
Definition: configuration.h:35
TRIVIALLY_CONSTRUCTIBLE
TRIVIALLY_CONSTRUCTIBLE
Values of the data type are trivially constructible.
Definition: apibase.h:2186
maxon::SCCAddFile
Result< void > SCCAddFile(const Url &url, Bool outputError)
Definition: sourcecontrol.h:326
GeClipMap
Definition: lib_clipmap.h:146
UInt64
maxon::UInt64 UInt64
Definition: ge_sys_math.h:61
LocalFileTime
Represents a date time.
Definition: c4d_file.h:773
BaseContainer
Definition: c4d_basecontainer.h:46
TreeViewFloatSliderInfo::floatFormat
Int32 floatFormat
The format one of the following FORMAT_PERCENT, FORMAT_DEGREE, FORMAT_REAL, FORMAT_METER.
Definition: customgui_listview.h:183
maxon::details::TupleStorage
Definition: tuple.h:228
Float64
maxon::Float64 Float64
Definition: ge_sys_math.h:65
MAXON_OFFSETOF_NON_STANDARD_LAYOUT
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT
Definition: compilerdetection.h:355
SDKBrowserPluginInterfaceInfo::GetPluginID
virtual Int32 GetPluginID(String *plugin_name=nullptr)=0
NAMED_TUPLE
NAMED_TUPLE
The data type is a TupleDataType with named members created by ParametricTypes::Tuple.
Definition: apibase.h:2215
OBJECT_REF
OBJECT_REF
This flag is set for a reference or pointer to a virtual object.
Definition: apibase.h:2190
GeData::GetData
const maxon::Data & GetData(void) const
Definition: c4d_gedata.h:499
maxon::Pix32f
Float32 Pix32f
pixel format with 32 bit floating point values.
Definition: gfx_image_imagechannel.h:24
PI2
static constexpr Float64 PI2
floating point constant: 2.0 * PI
Definition: apibasemath.h:118
GeData::SetData
void SetData(const maxon::Data &v)
Definition: c4d_gedata.h:627
maxon::operator~
DESCRIBEFLAGS operator~(DESCRIBEFLAGS a)
Definition: dataserialize.h:168
MAXVALUE_INT64_FLOAT64
static constexpr Float64 MAXVALUE_INT64_FLOAT64
maximum Float64 value that can be represented by Int64 ( 0x7ffffffffffffdff). Higher values will resu...
Definition: apibasemath.h:17
MINVALUE_FLOAT
static constexpr Float MINVALUE_FLOAT
the minimum value a Float can represent
Definition: apibasemath.h:25
Utf16Char
maxon::Utf16Char Utf16Char
Definition: ge_sys_math.h:80
SCENENODES_IDS::SCENEHOOK_ID
@ SCENEHOOK_ID
SceneHook ID.
PyDecode
PyDecode
Definition: cpython.h:28
maxon::IOFORMAT
IOFORMAT
Definition: io.h:11
maxon::details::ValidateArrayIterator
Result< Int > ValidateArrayIterator(const ARRAY &array, Int index, ViewIteratorMember *members, const MemberMap *map, Int *state, PersistentIdBuffer *idBuffer, const PersistentIdGeneratorInterface *ig)
Definition: array.h:1085
BaseDraw::GetViewportImage
void GetViewportImage(maxon::ImageRef &viewportImage) const
Definition: c4d_basedraw.h:1855
MARK
MARK
Definition: corenodes_helpers.h:41
DEFAULT_OUTPUT
DEFAULT_OUTPUT
Definition: corenodes_helpers.h:68
PaintView
Represents a Texture View.
Definition: lib_paint.h:71
maxon::Block
Definition: apibase.h:300