API Changes in R23.110
cinema.framework
c4d_customgui/customgui_bitmapbutton.h
c4d_customgui/customgui_listview.h
{
}
{
}
{
}
struct InternalFunctionTable
{
}
c4d_libs/lib_paint.h
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
ABCEXPORT_FORMAT = 1024,
ABCEXPORT_FORMAT_HDF5_LEGACY = 0,
ABCEXPORT_FORMAT_OGAWA = 1,
c4d_basedocument.h
c4d_basedraw.h
class DrawportContextRef;
{
}
c4d_painter.h
ge_prepass.h
operatingsystem.h
class DrawportContextRef;
void (*GetDrawportContext)(
const BaseDraw* bd, maxon::DrawportContextRef& context);
core.framework
math/col.h
template <typename T, Int STRIDE = 1> struct Col3
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
math/col4.h
template <typename T, Int STRIDE = 1> struct Col4
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
math/vec.h
template <typename T, Int STRIDE = 1> struct Vec3
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
math/vec2.h
template <typename T, Int STRIDE = 1> struct Vec2
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
math/vec4.h
template <typename T, Int STRIDE = 1> struct Vec4
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
utilities/apibaseid.h
class LiteralId
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
utilities/defaultdoc.h
class DefaultDoc
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
utilities/sseconversion.h added.
array.h
template <typename ARRAY> class ArrayImpl
{
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 =
nullptr)
const;
}
collection.h
template <typename COLLECTION, typename SUPER> class BaseCollection : public SUPER
{
inline String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
containerbase.h
class GenericContainerInterface
{
}
contiguousrangemap.h
template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class ContiguousRangeMap
{
typename SFINAEHelper<String, K>::type
ToString(
const FormatStatement* fmt)
const
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
{
}
datadescription_data.h
MAXON_ATTRIBUTE(Id, CLASSIFICATION,
"net.maxon.description.data.info.classification",
datadescriptiondatabase.h
class DataDescriptionDatabaseInterface
{
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
{
}
dataserialize.h
struct IDENT_VOID
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
datatype_builder.h
struct DataTypeComponent
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
datatypebase.h
class DataTypeImpl
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class DataTypeImpl::Instantiated : public DataTypeImpl
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class Data
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class class ConstDataPtr
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
datatypebase.h
class InternedId
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
struct Member
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
datetime.h
class LocalDateTime
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class UniversalDateTime
{
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 =
nullptr)
const;
}
hashmap.h
class Entry : public HashMapEntryBase<K, V, Entry, ENTRY_HANDLER>
{
typename SFINAEHelper<String, V>::type
ToString(
const FormatStatement* format)
const
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
typename SFINAEHelper<String, V>::type
ToString(
const FormatStatement* formatStatement =
nullptr) const
}
job.h
class JobInterface : protected JobInterfaceBase
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class JobStatusRef :
public StrongRef<JobStatusInterface>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class JobRef :
public StrongRef<JobInterface>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
jobgroup.h
class JobGroupInterface
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class JobGroupRef :
public StrongRef<JobGroupInterface>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
template <typename T> class StaticJobGroupInterface : public JobGroupInterface
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
template <
typename T>
class StaticJobGroupRef :
public StrongRef<StaticJobGroupInterface<T>>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
machine.h
map.h
template <typename K, typename V> class MapInterface : public MapBase0<MapInterface<K, V>, K, V, EmptyClass, DefaultCompare>
{
}
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 =
nullptr)
const;
}
matrix.h
template <typename V> struct SqrMat3
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
template <typename V> struct Mat3
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
matrix2d.h
template <typename V> struct SqrMat2
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
template <typename V> struct Mat2
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
matrix4d.h
template <typename V> struct SqrMat4
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
multiindex.h
template <typename INT_TYPE> class MultiIndex
{
}
objectbase.h
class InterfaceReference
{
}
class ComponentDescriptor
{
}
class ClassInterface
{
}
class ObjectInterface : protected ObjectSuper
{
}
optional.h
template <typename T>
class Opt
{
typename SFINAEHelper<String, T>::type
ToString(
const FormatStatement* format)
const
typename SFINAEHelper<String, T>::type
ToString(
const FormatStatement* format =
nullptr) const
}
parametertype.h
range.h
template <typename T> class Range
{
typename SFINAEHelper<String, T>::type
ToString(
const FormatStatement* format)
const
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
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
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
{
}
class EntryRef
{
}
reflectionbase.h
set.h
template <typename TYPE> class SetInterface : public SetBase0<SetInterface<TYPE>, TYPE, EmptyClass, DefaultCompare>
{
}
template <typename SET> class SetImpl
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
streamconversion.h
struct ConversionTestSet
{
}
string.h
class StringInterface : public StringTemplate<StringInterface, String, Utf32Char>
{
inline String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
class CStringInterface : public StringTemplate<CStringInterface, CString, Char>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
stringresource.h
class LanguageInterface
{
}
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
typename SFINAEHelper<String, T>::type
ToString(
const FormatStatement* format =
nullptr) const
}
thread.h
class ThreadInterface : public JobInterface
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
template <
typename INTERFACE>
class ThreadRefTemplate :
public StrongRef<INTERFACE>
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
timevalue.h
class TimeValue
{
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>
{
}
tuple.h
{
typename SFINAEHelper<
String, T...>::type
ToString(
const FormatStatement* format)
const
typename SFINAEHelper<
String, T...>::type
ToString(
const FormatStatement* format =
nullptr) const
}
template <> class Tuple<>
{
}
units.h
class DimensionInterface
{
}
class UnitInterface
{
}
url.h
uuid.h
corenodes.framework
corenodes.h
struct PortInfo
{
}
class CoreNodeBaseInterface
{
}
corenodes_conversion.h
class ConversionSequence
{
}
corenodes_helpers.h
corenodes_helpers.h
class IdBuilder
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
corenodes_instances.h
class CoreNodeInstanceBaseInterface
{
}
crypt.framework
cryptography_key.h
class CryptoKeyInterface
{
}
cryptography_ssl.h
class SSLInterface
{
SSL_library_init
}
geom.framework
celldata.h
struct CellEdge
{
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;
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 =
nullptr) const
}
image.framework
gfx_basictypes.h
template <typename T> struct DrawDimension
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
template <typename T> struct DrawRect
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
gfx_basictypes_3d.h
template <typename T> struct DrawPoint3d
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
template <typename T> struct DrawDimension3d
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
template <typename T> struct DrawVolume
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
gfx_image_bits.h
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
gfx_image_colorprofile.h
half.h
template <typename FLOAT32TYPE> class HalfFloat
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
math.framework
big_integer.h
class BigIntegerInterface
{
}
complex.h
template <typename T> class Complex
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
matrix_nxm.h
template <typename TYPE> class MatrixNxM
{
String ToString(
const FormatStatement* formatStatement =
nullptr)
const;
}
quaternion.h
{
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
{
}
mesh_misc.framework
mesh_attribute_utilities.h
template <typename T> class PolyData
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
misc.framework
timestamp.h
network.framework
network_ip_addr.h
class NetworkIpAddrInterface
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
class NetworkIpAddrPortInterface : public NetworkIpAddrInterface
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
{
String ToString(
const FormatStatement* formatStatement =
nullptr) const
}
network_ip_ssl.h
python.framework
vm.h
namespace VirtualMachines
{
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
c4d_customgui/customgui_filename_breadcrumb.h
#define BREADCRUMB_SLASH_CODE 10007 ///< ::Bool The string "_&s&_" is replaced with character "/"
c4d_customgui/customgui_linkbox.h
c4d_customgui/customgui_listview.h
#define TREEVIEW_CUSTOM_BG_COLOR 'cubg'
{
virtual Bool IsSelectable(
void *root,
void *userdata,
void *obj);
}
c4d_libs/lib_activeobjectmanager.h
c4d_libs/lib_browser.h
{
}
{
}
{
}
{
}
{
static Int32 PreviewDialogMisc(
SubDialog *dlg,
void *&private_data,
Int32 cmd,
Int32 value0 = 0,
Int32 value1 = 0,
void *value2 = 0,
void *value3 = 0);
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
{
}
struct DescriptionLib
{
}
c4d_libs/lib_instanceobject.h
{
}
struct InstanceObjectLibrary
{
}
c4d_libs/lib_net.h
{
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
c4d_libs/lib_viewport.h
c4d_misc/utilities/apibasemath.h
{
};
{
};
{
};
{
public:
};
{
public:
};
{
public:
};
{
public:
};
{
public:
};
{
public:
};
{
public:
};
c4d_basedraw.h
c4d_baseobject.h
c4d_colors.h
c4d_gedata.h
c4d_general.h
c4d_includes.h
#include "description/oheadphone.h"
#include "description/oloudspeaker.h"
#include "description/omicrophone.h"
c4d_library.h
#define LIBOFFSET(s, m) (Int32)((UInt)(&(((s*)0)->m)))
#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
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
#define Omicrophone 5138
#define Oloudspeaker 5139
#define Oheadphone 5151
enum class LINESTILE
{
}
{
}
#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
#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
{
}
{
}
{
NO_REDUCTION = (1 << 2)
}
{
}
gui.h
matrix4.h
using Matrix4d = maxon::SqMat4<Vector4d>;
operatingsystem.h
class ObserverObjectRef;
void (*GetViewportImage )(
const BaseDraw* bd, maxon::ImageRef& viewportImage);
void (*RenderViewportWithoutPostEffects )(
const BaseDraw* bd, maxon::ImageRef& image);
core.framework
maxon/math/col.h
Col3() : r(0), g(0), b(0) { }
constexpr Col3() : r(0), g(0), b(0) { }
explicit Col3(ValueTypeParam in) : r(in), g(in), b(in) { }
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) { }
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) { }
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) { }
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) { }
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) { }
template <Int S2> constexpr Col3(const Col3<T, S2>& v) : r(v.r), g(v.g), b(v.b) { }
maxon/math/col4.h
Col4() : r(0), g(0), b(0), a(T(1)) { }
constexpr Col4() : r(0), g(0), b(0), a(T(1)) { }
explicit Col4(ValueTypeParam in) : r(in), g(in), b(in), a(T(1)) { }
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) { }
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) { }
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) { }
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) { }
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) { }
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) { }
template <typename V> Col4& operator *=(const SqMat4<V>& m)
template <typename V> Col4& operator *=(const SqrMat4<V>& m)
maxon/math/vec.h
Vec3() : x(0), y(0), z(0) { }
constexpr Vec3() : x(0), y(0), z(0) { }
explicit Vec3(ValueTypeParam in) : x(in), y(in), z(in) { }
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) { }
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) { }
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) { }
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) { }
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) { }
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) { }
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) { }
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) { }
maxon/math/vec2.h
Vec2() : x(0), y(0) { }
constexpr Vec2() : x(0), y(0) { }
explicit Vec2(ValueTypeParam in) : x(in), y(in) { }
explicit constexpr Vec2(ValueTypeParam in) : x(in), y(in) { }
explicit Vec2(ValueTypeParam ix, ValueTypeParam iy) : x(ix), y(iy) { }
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) { }
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) { }
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) { }
template <typename T2, Int S2> explicit constexpr Vec2(const Vec3<T2, S2>& v) : x((T)v.x), y((T)v.y) { }
maxon/math/vec4.h
Vec4() : x(0), y(0), z(0), w(0) { }
constexpr Vec4() : x(0), y(0), z(0), w(0) { }
explicit Vec4(ValueTypeParam in) : x(in), y(in), z(in), w(in) { }
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) { }
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) { }
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) { }
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) { }
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) { }
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) { }
template <typename V> Vec4& operator *=(const SqMat4<V>& m)
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))
template <
UInt N> explicit constexpr LiteralId(const
Char (&str)[
N]) : _value(str), _hash(GetHashCode(str))
constexpr
UInt GetHashCode() const
constexpr
HashInt GetHashCode() const
template <
UInt N> constexpr LiteralId(bool dummy, const
Char (&str)[
N]) : _value(str), _hash(GetHashCode<
N>(str))
template <
UInt N> constexpr LiteralId(bool dummy, const
Char (&str)[
N]) : _value(str), _hash(GetHashCode(str))
}
maxon/utilities/apibasemath.h
{
public:
};
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
template <
Int X,
Int... Y> struct Sum<X, Y...>
{
static constexpr
Int value
static constexpr
Int value
static const T value
static constexpr T value
static const T value
static constexpr T value
}
maxon/utilities/classhelpers.h
#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__)
#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__); }
#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
static UInt GetHashCode(
const Char* key)
maxon/utilities/compilerdetection.h
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT(T, M) ((size_t)(&((T*) 0)->M))
#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))
#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
}
maxon/utilities/defaultdoc.h
UInt GetHashCode()
const;
maxon/utilities/hash.h
struct DefaultHash
{
static constexpr
HashInt EMPTY_HASH = 0
void CombineUnordered(
HashInt value)
}
struct FNV1aHash
{
#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
}
maxon/utilities/memoryallocationbase.h
maxon/apibase.h
#define MAXON_API_ABI_VERSION 21014
#define MAXON_API_ABI_VERSION 23008
constexpr
inline UInt PrivateGetHashCode(
const char* str,
Int len)
static const void*
const g_zeroPtr =
nullptr;
class UnitType
{
UInt GetHashCode()
const {
return 0; }
HashInt GetHashCode()
const {
return 0; }
}
class GenericArithmetic
{
UInt GetHashCode()
const {
return 0; }
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
{
}
template <typename D, typename B> struct HasErasedBase
{
}
struct HashValue
{
HashValue() = default;
};
template <
UInt64 MODULE_ID_HASH = PrivateGetHashCode(MAXON_MODULE_ID,
SIZEOF(MAXON_MODULE_ID)-1)>
struct ModuleInfoWrapper
template <
UInt64 MODULE_ID_HASH = CStringCompare::GetHashCode(MAXON_MODULE_ID)>
struct ModuleInfoWrapper
{
}
maxon/applicationid.h
namespace APPLICATIONID
{
static const LiteralId PYTHON3{"net.maxon.application.python3"};
}
maxon/array.h
class PersistentIdGeneratorInterface
{
public:
}
template <typename TYPE> class StaticArrayInterface
template <typename
TYPE> class StaticArrayInterface :
public GenericContainerInterface
MAXON_GENERIC_BASE(NamedTuple<TYPE>)
template <typename TYPE> class StaticArrayInterface :
public GenericContainerInterface
MAXON_GENERIC_BASE(NamedTuple<TYPE>)
{
MAXON_METHOD Result<Int> GetWritableBlock(
Int index, SimdBlock<TYPE>& block);
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;
template <typename COLLECTION_TYPE> class IteratorTemplate
{
explicit IteratorTemplate(CollectionType& a) : _array(&a)
explicit IteratorTemplate(CollectionType& a,
Int start = 0) : _array(&a)
explicit IteratorTemplate(CollectionType& a,
Int start) : _array(&a)
IteratorTemplate() : _indexPtr(nullptr)
}
using StaticArrayInterfaceMarker = void;
}
template <typename T> struct StrongCOWRefHandler::MakeWritableHelper<T, typename T::StaticArrayInterfaceMarker>
template <typename TYPE> class VArrayInterface : public StaticArrayInterface<TYPE>
template <typename TYPE> class ArrayInterface : public ArrayBase0<ArrayInterface<TYPE>, TYPE, VArrayInterface<TYPE>, DefaultCompare>
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>
{
using Super::CopyFrom;
Int GetBlock(
Int index, Block<TYPE, false>& block)
Int GetBlock(
Int index, Block<typename Super::NonConstValueType>& block);
Int GetBlock(
Int index, StridedBlock<const TYPE>& block)
const
Int GetBlock(
Int index, StridedBlock<TYPE>& block)
template <
typename A>
MAXON_FUNCTION ResultRef<TYPE> Append(A&& value)
template <typename C> typename ArrayInterface::template IteratorTemplate<C> Erase(const typename ArrayInterface::template IteratorTemplate<C>& it)
MAXON_METHOD Result<
void> CopyFrom(const ArrayInterface& other);
MAXON_METHOD void SetPersistentIdGenerator(const PersistentIdGenerator& generator);
template <typename T> ArrayInterface<T>&
AssertCast()
template <typename T2> ArrayInterface<T2>&
AssertCast()
template <typename T> const ArrayInterface<T>&
AssertCast() const
template <typename T2> const ArrayInterface<T2>&
AssertCast() const
}
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
void FreeIterator(ViewIteratorMember* members, const MemberMap* map,
Char* state,
PersistentIdBuffer* idBuffer) const
const PersistentIdGenerator& GetPersistentIdGenerator() const
void SetPersistentIdGenerator(const PersistentIdGenerator& generator)
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
Int GetBlock(
Int index, Block<const ValueType>& block) const
Int GetBlock(
Int index, Block<NonConstValueType>& block)
Result<void> CopyFrom(const VArrayInterface<ValueType>& other)
Result<void> CopyFrom(const ArrayInterface<ValueType>& other)
Result<Interface*> MakeWritable(
Bool cloneElements) const
Result<GenericContainerInterface*> MakeWritable(
Bool cloneElements) const
Result<GenericContainerInterface*> Clone(
Bool cloneElements) const
HashValue GetHashValue() const
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); }
static HashInt GetHashCode(
const ENTRY& a) {
return COMPARE::GetHashCode(a); }
}
maxon/basebitset.h
template <typename ALLOCATOR = DefaultAllocator> class BaseBitSet
{
}
maxon/baseref.h
template <typename T, typename HANDLER> class BaseRef
{
const T& operator [](
Int)
const =
delete;
static const BaseRef& NullValueRef()
}
maxon/block.h
template <typename COLLECTION, Bool STRIDED> class BaseIterator
{
template <typename SUPER> class ResultFunctions : public SUPER
{
Result<BaseIterator::ValueType&> operator *()
}
}
maxon/branch.h
maxon/bytesvalue.h
maxon/collection.h
template <typename COLLECTION, typename VALUETYPE, typename SUPER, typename HASH> class ArrayBase0 : public Collection<COLLECTION, VALUETYPE, SUPER>
{
}
template <typename COLLECTION, typename VALUETYPE, typename SUPER, typename HASH> class SetBase0 : public Collection<COLLECTION, VALUETYPE, SUPER>
{
}
template <typename COLLECTION, typename KEYTYPE, typename VALUETYPE, typename SUPER, typename HASH> class MapBase0 : public BaseCollection<COLLECTION, SUPER>
{
}
maxon/configurationdatabase.h
maxon/containerbase.h
class GenericContainerInterface
{
enum class INTERFACES
{
MAXON_METHOD const ContainerDataType<>& GetContainerType()
const;
MAXON_METHOD Result<GenericContainerInterface*> MakeWritable(
Bool cloneElements =
true)
const;
MAXON_METHOD Result<GenericContainerInterface*> Clone(
Bool cloneElements =
true)
const;
};
maxon/contiguousrangemap.h
template <typename K, typename V, typename MAP = BurstTrieMapSelector<>> class ContiguousRangeMap
{
}
maxon/datadescription.h
class DataDescriptionInterface
{
}
maxon/datadescription_data.h
{
namespace BASE
{
MAXON_ATTRIBUTE(Id, LIMITVALUE,
"net.maxon.description.data.base.limitvalue",
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, INCLUDERENAME,
"net.maxon.description.data.base.includerename");
MAXON_ATTRIBUTE(Array<Id>, INCLUDERENAME,
"net.maxon.description.data.base.includerename");
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, INCLUDEFILTER,
"net.maxon.description.data.base.includefilter");
MAXON_ATTRIBUTE(Array<Id>, INCLUDEFILTER,
"net.maxon.description.data.base.includefilter");
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");
MAXON_ATTRIBUTE(Array<Id>, VARIADICCOMMANDS,
"net.maxon.description.data.base.variadiccommands");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Tuple<maxon::Id, maxon::InternedId>), INCLUDEDFROM,
"net.maxon.description.data.base.includedfrom");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Tuple<Id, InternedId>), INCLUDEDFROM,
"net.maxon.description.data.base.includedfrom");
}
{
}
}
maxon/datadescription_ui.h
{
namespace UI
{
namespace BASE
{
MAXON_ATTRIBUTE(Id, DEFAULTCLASSIFICATION,
"net.maxon.description.ui.base.defaultclassification",
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, BASELINK_ACCEPT,
"net.maxon.description.ui.base.baselink.accept");
MAXON_ATTRIBUTE(Array<Id>, BASELINK_ACCEPT,
"net.maxon.description.ui.base.baselink.accept");
MAXON_ATTRIBUTE(MAXON_MACROARG_TYPE(Array<Tuple<InternedId, InternedId>>), PRESETMEMBERS,
"net.maxon.description.ui.base.presetmembers");
}
}
}
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);
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,
using ProcessEnumListDelegate = Delegate<Result<void>(
const Id& epId,
const DataDictionary& guiEntry,
const AssetRepositoryRef& repository,
const Data* filterData,
maxon/datadescriptiondefinition_conversion.h
maxon/datadescriptiondefinitiondatabase.h
class DataDescriptionDefinitionDatabaseInterface
{
}
maxon/datadictionary.h
class DataDictionaryInterface
{
MAXON_FUNCTION Result<typename std::conditional<IsFidClass<KEY>::value,
typename IsFidClass<KEY>::type, T>::type>
Get(
KEY&& key)
const
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
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value,
typename IsFidClass<KEY>::type, T>::type
Get(
KEY&& key, T&& defaultValue)
const
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)
template <typename KEY>
typename IsFidClass<KEY>::type DataDictionaryInterface::GetOrDefault(
KEY&& key)
const
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
{
MAXON_FUNCTION Result<typename std::conditional<IsFidClass<KEY>::value,
typename IsFidClass<KEY>::type, T>::type>
Get(
KEY&& key)
const
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
MAXON_FUNCTION typename std::conditional<IsFidClass<KEY>::value,
typename IsFidClass<KEY>::type, T>::type
Get(
KEY&& key, T&& defaultValue)
const
template <typename KEY>
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
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
{
}
#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
#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, ...)
#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM(enumtype, cppname, id, size, flags, names, ...) \
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>
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>
template <typename T, Bool GENERIC_FOR_UNKNOWN_TYPE = false> struct MemberType : public MemberTypeBase<T>
template <typename T> struct MemberType<T&> : public MemberTypeBase<T>
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>
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)
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
{
DataType _type;
Id _typeId;
Id _parametricTypeId;
const ParametricTypeInterface* _additionalRefType = nullptr;
BaseArray<DataTypeComponent> _children;
};
{
static MAXON_METHOD Result<Tuple<String, Bool>> RecurseDataType(
DATATYPEBUILDERNAME category,
const Member& dt,
const ParametricTypeInterface* parentTypeId,
Int& globalIdentifier, BaseArray<DataTypeComponent>& components);
};
class DataTypeBuilderEntry
{
public:
Result<void> CopyFrom(
const DataTypeBuilderEntry&
src)
};
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
{
}
class DataTypeImpl
{
template <typename T, typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, const T* dummy1, const C* dummy2,
VALUEKIND kind = ValueKindHelper<T, GetDirectlyReferencedType<T>::value>::KIND,
const ParametricTypeInterface* pt =
nullptr)
template <typename T, typename C> DataTypeImpl(const Id& type, const DataTypeImpl* underlying, const DataTypeImpl* element, const T* dummy1, const C* dummy2,
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)
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 MoveConstruct(
void* dest,
void*
src) const
void MoveConstruct(
void* dest,
void*
src,
Int count) const
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
void MoveFrom(
void* dest,
Int dstride,
void*
src,
Int sstride,
Int count) const
Result<
void> CopyFrom(
void* dest, const
void*
src,
Int count) const
Result<
void> CopyFrom(
void* dest, const
void*
src) const
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
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)...)
template <typename... ARGS> explicit Primary(const
Char* cppName, const ModuleInfo* module, ARGS&&... args)
const
Char* _cppName = nullptr;
const ModuleInfo* _module = nullptr;
}
class DataType
{
}
class Data
{
friend class DataDictionaryInterface;
friend class DataDictionaryObjectInterface;
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);
template <typename DEST> Result<
void> SetImpl(Data&& data,
OverloadRank1);
}
class ConstDataPtr
{
}
class MoveDataPtr
{
static void Construct(
const DataTypeImpl* type,
void* dest,
Int count);
static void Construct(
const DataTypeImpl* type,
void* dest,
Int dstride,
Int count);
static void Destruct(
const DataTypeImpl* type,
const void* dest,
Int count);
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);
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);
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);
static Result<void> CopyFrom(
const DataTypeImpl* type,
void* dest,
Int dstride,
const void*
src,
Int sstride,
Int count);
static Result<Bool> UpdateFrom(
const DataTypeImpl* type,
void* dest,
const void*
src);
static UInt GetHashCode(
const DataTypeImpl* type,
const void* a);
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)
static void Construct(
const DataTypeImpl*,
void* dest,
Int dstride,
Int count)
static void Destruct(
const DataTypeImpl*,
const void* dest,
Int count)
static void Destruct(
const DataTypeImpl*,
const void* dest,
Int dstride,
Int count)
static void MoveConstruct(
const DataTypeImpl*,
void* dest,
void*
src,
Int count)
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)
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)
static Result<void> CopyFrom(
const DataTypeImpl*,
void* dest,
Int dstride,
const void*
src,
Int sstride,
Int count)
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); }
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)
static HashInt GetHashCode(
const DataTypeImpl* type,
const void* a)
}
maxon/datatypefunctions.h
class InternedId
{
}
struct Member
{
Member() = default;
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
{
}
class DataTypeLib
{
static MAXON_METHOD Result<const MemberMap*> PrivateGetMemberMap(
const DataTypeImpl* containerType,
const DataTypeImpl* runtimeType);
static MAXON_METHOD Result<const MemberMap*> GetMemberMap(
const DataTypeImpl* containerType,
const DataTypeImpl* runtimeType);
}
maxon/datetime.h
class LocalDateTime
{
}
class UniversalDateTime
{
}
maxon/errorbase.h
#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>
{
ResultRef<Generic> Append(const DataType& elementType);
UInt GetHashCode(
const DataType& elementType)
const;
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
{
}
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER,
HASHMAP_ENTRY_LAYOUT::
KEY_VALUE>
{
}
{
}
template <typename K, typename V, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, V, ENTRY, ENTRY_HANDLER,
HASHMAP_ENTRY_LAYOUT::
VALUE_KEY>
{
}
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER,
HASHMAP_ENTRY_LAYOUT::
KEY_VALUE>
{
}
{
}
template <typename K, typename ENTRY, typename ENTRY_HANDLER> class HashMapEntryBase<K, UnitType, ENTRY, ENTRY_HANDLER,
HASHMAP_ENTRY_LAYOUT::
VALUE_KEY>
{
}
: 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)
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>
{
}
maxon/hierarchyobject.h
{
MAXON_OBSERVABLE(Result<void>, DeprecatedObservableHierarchyInsert, (
const HierarchyObjectRef<>& sender,
const HierarchyObjectRef<>&
object), ObservableCombinerRunAllComponent);
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)
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
{
}
maxon/ioconnection.h
class IoConnectionInterface
{
}
maxon/ioenums.h
maxon/jobqueue.h
class JobQueueInterface
{
}
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
};
maxon/lib_math.h
#define MATH_SQUAREMATRIX SqrMat3<Vec3<FLOAT>>
template <typename FLOAT>
template <typename FLOAT>
template <typename FLOAT>
#define MATH_SQUAREMATRIX2 SqrMat2<Vec2<FLOAT>>
maxon/machineinfo.h
namespace MACHINEINFO
{
MAXON_ATTRIBUTE(BaseArray<maxon::Id>, LANGUAGES,
"net.maxon.machineinfo.languages");
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/matrix.h
template <typename V> struct SqMat3
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))
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) { }
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) { }
template <typename V2> explicit constexpr SqrMat3(const SqrMat3<V2>& m) : v1(m.v1), v2(m.v2), v3(m.v3) { }
template <typename V2> explicit SqMat3(const SqMat2<V2>& m) :
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
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)
friend SqrMat3 operator *(ValueTypeParam s, const SqrMat3& m)
SqMat3 operator *(ValueTypeParam s) const
SqrMat3 operator *(ValueTypeParam s) const
SqMat3 operator /(ValueTypeParam s) const
SqrMat3 operator /(ValueTypeParam s) const
SqMat3 operator +(const SqMat3& m2) const
SqrMat3 operator +(const SqrMat3& m2) const
SqMat3 operator -(const SqMat3& m2) const
SqrMat3 operator -(const SqrMat3& m2) const
BoolType operator ==(const SqMat3& other) const
BoolType operator ==(const SqrMat3& other) const
BoolType operator !=(const SqMat3& other) const
BoolType operator !=(const SqrMat3& other) const
SqMat3 operator ~() const
SqrMat3 operator ~() const
SqMat3 GetNormalized() const
SqrMat3 GetNormalized() const
SqMat3 GetTransposed() const
SqrMat3 GetTransposed() const
SqMat3 GetTensorMatrix() const
SqrMat3 GetTensorMatrix() const
SqMat3& operator *=(const V& v)
SqrMat3& operator *=(const V& v)
SqMat3& operator *=(ValueTypeParam r)
SqrMat3& operator *=(ValueTypeParam r)
SqMat3<V> sqmat;
SqrMat3<V> sqmat;
Mat3() : off(), sqmat() { }
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) { }
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) { }
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) { }
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) { }
template <typename V2> explicit constexpr Mat3(const Mat3<V2>& m) : off(m.off), sqmat(m.sqmat) { }
template <typename V2> explicit Mat3(const Mat2<V2>& m) : off(m.off), sqmat(m.sqmat) { }
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
template <
typename V2> Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type>
operator *(
const SqrMat3<V2>& m2)
const
}
template <typename V, typename V2> inline Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat3<V>& m, const Mat3<V2>& m2)
template <typename V, typename V2> inline Mat3<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat3<V>& m, const Mat3<V2>& m2)
template <typename T> struct IsZeroInitialized<SqMat3<T>> : public IsZeroInitialized<T> { };
template <typename T> struct IsZeroInitialized<SqrMat3<T>> : public IsZeroInitialized<T> { };
maxon/matrix2d.h
template <typename V> struct SqMat2
template <typename V> struct SqrMat2
{
SqMat2() : v1(ValueType(1), ValueType(0)), v2(ValueType(0), ValueType(1))
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) { }
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) { }
template <typename V2> explicit constexpr SqrMat2(const SqrMat2<V2>& m) : v1(m.v1), v2(m.v2) { }
template <
typename V2> SqMat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type>
operator *(
const SqMat2<V2>& m2)
const
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)
friend SqrMat2
operator *(ValueTypeParam s,
const SqrMat2& m)
SqMat2 operator
SqrMat2 operator
SqrMat2 operator ~() const
SqMat2 GetNormalized() const
SqrMat2 GetNormalized() const
SqMat2& operator *=(const V& v)
SqrMat2& operator *=(const V& v)
SqMat2& operator *=(ValueTypeParam r)
SqrMat2& operator *=(ValueTypeParam r)
SqMat2<V> sqmat;
SqrMat2<V> sqmat;
Mat2(const V& off_in, const SqMat2<V>& mat_in) : off(off_in), sqmat(mat_in) { }
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) { }
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
template <
typename V2> Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type>
operator *(
const SqrMat2<V2>& m2)
const
}
template <typename V, typename V2> inline Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqMat2<V>& m, const Mat2<V2>& m2)
template <typename V, typename V2> inline Mat2<typename MultiplicativePromotion<V, typename V2::ValueType>::type> operator *(const SqrMat2<V>& m, const Mat2<V2>& m2)
template <typename T> struct IsZeroInitialized<SqMat2<T>> : public IsZeroInitialized<T> { };
template <typename T> struct IsZeroInitialized<SqrMat2<T>> : public IsZeroInitialized<T> { };
maxon/matrix4d.h
template <typename V> struct SqMat4
template <typename V> struct SqrMat4
{
SqMat4() : v1(ValueType(1), ValueType(0), ValueType(0), ValueType(0)), v2(ValueType(0), ValueType(1), ValueType(0), ValueType(0)),
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) { }
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) { }
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)) { }
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)) { }
template <
typename V2> SqMat4<typename MultiplicativePromotion<V, typename V2::ValueType>::type>
operator *(
const SqMat4<V2>& m2)
const
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)
friend SqrMat4
operator *(ValueTypeParam s,
const SqrMat4& m)
SqMat4 operator
SqrMat4 operator
SqrMat4 operator ~() const
SqMat4 GetNormalized() const
SqrMat4 GetNormalized() const
SqMat4 GetTransposed() const
SqrMat4 GetTransposed() const
SqMat4& operator *=(const V& v)
SqrMat4& operator *=(const V& v)
SqMat4& operator *=(ValueTypeParam r)
SqrMat4& operator *=(ValueTypeParam r)
}
template <typename T> struct IsZeroInitialized<SqMat4<T>> : public IsZeroInitialized<T> { };
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");
MAXON_ATTRIBUTE(BaseArray<String>, USEDINMODULE,
"net.maxon.moduleversioninfo.usedinmodule");
}
maxon/objectbase.h
class InterfaceDefinition
{
InterfaceDefinition(const InterfaceReference& ref, TranslationUnit* unit, EntityBase::FLAGS flags);
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> HandleMessage(
const InternedId& message,
const void* argument);
}
template <typename R, typename SRC, typename RESULT = typename CastHelper<R, SRC>::AssertCastType>
inline RESULT AssertCast(SRC&& ref)
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)
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)
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)
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... };
template <typename... INTERFACES> const InterfaceReference* const InterfacesBlock<INTERFACES...>::value[sizeof...(INTERFACES)] = { INTERFACES::PrivateGetInterface()... };
#define MAXON_FUNCTIONNAME maxon::GetFunctionName(__FUNCTION__)
#define MAXON_FUNCTIONNAME maxon::Id(maxon::GetFunctionName(__FUNCTION__))
maxon/observable.h
class ObservableBaseInterface
{
MAXON_METHOD Result<void> AddObserver(ObserverObjectInterface* observer,
const FunctionBaseRef& observerFunction);
}
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
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
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
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
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
{
}
template <typename T>
class Opt<const T&>
{
const T& GetValueOr(T&& defaultValue) const = delete;
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 [];
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()) { }
constexpr Range() : _minValue(
LIMIT<ScalarType>::
MAX), _maxValue(
LIMIT<ScalarType>::
MIN) { }
explicit Range(const T& v) : _minValue(v), _maxValue(v) { }
explicit constexpr Range(const T& v) : _minValue(v), _maxValue(v) { }
Range(const T& rangeMin, const T& rangeMax) : _minValue(rangeMin), _maxValue(rangeMax) { }
constexpr Range(const T& rangeMin, const T& rangeMax) : _minValue(rangeMin), _maxValue(rangeMax) { }
}
maxon/rangemap.h
template <typename K> struct RangeSetPair
{
}
template <typename K, typename V, typename
MAP = BurstTrieMapSelector<>> class RangeMap
{
}
template <typename T, typename
MAP = BurstTrieMapSelector<>> class RangeSet : private RangeMap<T, UnitType,
MAP>
{
using Super::GetHashCode;
}
template <typename RANGETYPE>
maxon/set.h
template <typename TYPE> class SetInterface : public SetBase0<SetInterface<TYPE>, TYPE, EmptyClass, DefaultCompare>
{
}
maxon/sse_vector4i32.h
maxon/streamconversion.h
namespace STREAMCONVERSIONTEST
{
MAXON_ATTRIBUTE(BaseArray<ConversionTestSet>, CONVERSIONTESTSET,
"net.maxon.streamconversiontest.conversiontestset");
MAXON_ATTRIBUTE(Array<ConversionTestSet>, CONVERSIONTESTSET,
"net.maxon.streamconversiontest.conversiontestset");
MAXON_ATTRIBUTE(Array<ConversionTestSet>, CONVERSIONTESTSET,
"net.maxon.streamconversiontest.conversiontestset");
MAXON_ATTRIBUTE(Array<UChar>, SRCDATA,
"net.maxon.streamconversiontest.srcdata");
MAXON_ATTRIBUTE(BaseArray<UChar>, COMPAREDATA,
"net.maxon.streamconversiontest.comparedata");
MAXON_ATTRIBUTE(Array<UChar>, COMPAREDATA,
"net.maxon.streamconversiontest.comparedata");
}
maxon/string.h
template <typename INTERFACETYPE, typename REFTYPE, typename CHARTYPE> class StringTemplate
{
}
maxon/system.h
maxon/thread.h
#ifdef USE_API_MAXON
#endif
maxon/timevalue.h
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>
{
template <
typename I>
static Int GetOffset(I* x) {
return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>()>::GetOffset(x); }
template <
typename I>
static Int GetOffset(I* x) {
return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>(), GetSizeAndAlignment<T3>()>::GetOffset(x); }
template <
typename I>
static Int GetOffset(I* x) {
return TupleStorageLayout<0, 0, 1, GetSizeAndAlignment<T1>(), GetSizeAndAlignment<T2>(), GetSizeAndAlignment<T3>(), GetSizeAndAlignment<T4>()>::GetOffset(x); }
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); }
}
template <
typename HASH>
inline UInt TupleGetHashCode()
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...>
{
template <typename HASH>
UInt GetHashCode() const
template <typename HASH>
HashInt GetHashCode() const
}
template <> class Tuple<>
{
template <typename HASH>
UInt GetHashCode() const
template <typename HASH>
HashInt GetHashCode() const
}
class IgnoredPlaceholder
{
template <typename T>
void operator =(const T&) const { }
const IgnoredPlaceholder& operator =(const T&) const
}
maxon/unicodeutils.h
{
}
class UnicodeUtils
{
}
maxon/url.h
maxon/uuid.h
maxon/vector.h
template <typename T> struct SqMat4;
template <typename T> struct SqrMat4;
namespace ParametricTypes
{
}
maxon/viewiterator.h
struct ViewIteratorMember
{
template <Bool ENABLE_SIMD = true> void Advance()
template <
Bool ENABLE_SIMD>
void Advance()
template <
Bool ENABLE_SIMD = true>
void Advance(
Int advanceCount)
template <
Bool ENABLE_SIMD>
void Advance(
Int advanceCount)
}
maxon/weakref.h
template <typename REFERENCE> class WeakRef : public WeakRefBase
{
}
maxon/win_com.h
corenodes.framework
maxon/corenodes.h
class CoreNodeBaseInterface
{
}
class CoreNodeGroupInterface : public CoreNodeBaseInterface
{
template <typename NODECLASS> ResultOk<void> PrivateAutoCreatePorts()
template <typename NODECLASS> ResultOk<void> PrivateAutoCreatePorts(const Generic*, const void*)
}
{
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)
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
class ConversionSequence
{
ConversionSequence() = default;
ConversionSequence(
const CoreNode& c1,
CONVERSION_FLAGS flags) : _flags(flags), _count(1)
ConversionSequence(const CoreNode& c1, const CoreNode& c2,
CONVERSION_FLAGS flags) : _flags(flags), _count(2)
CoreNode& operator [](
Int index);
~ConversionSequence();
}
maxon/corenodes_helpers.h
{
}
class InPortId : public PortId
{
}
class OutPortId : public PortId
{
}
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
{
{
PARAMETER_MASK = 0x800,
PARAMETERS = PARAMETER_MASK + 1,
FACTOR_REFERENCE_MASK = 0x400000,
}
enum class FLAGS
{
}
}
template <typename T, Bool OUTPUT = false> class VariadicPort;
template <typename T, Bool OUTPUT = false, Bool AS_INPUT = false> class VariadicPort;
class MicroNodeInterface : public CoreNodeInstanceBaseInterface
{
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>())
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)
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)
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)
}
class CoreNodeInstanceInterface : public CoreNodeInstanceBaseInterface
{
}
maxon/corenodes_lib.h
class CoreNodesLib
{
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);
static MAXON_METHOD Result<const ConversionSequence*> GetConversion(
const DataType& to,
const DataType& from,
Bool allowIterations =
false);
}
maxon/micronodes.h
class VariableMicroNode final : public VariableBase
{
}
class BasicMicroNode : public MicroNode
{
}
class BatchMicroNode : public MicroNode
{
}
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)
{
struct SourceCodePortId
{
}
template <typename PORTIDTYPE>
template <Int LENGTH>
}
}
maxon/micronodes_runtime.h
class MicroNodeRuntime
{
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())
explicit BatchVarAccess(const VarAccess& access) : _context(access._context), _index(access._frame->GetIndex()), _blockEnd(access._frame->GetBlockEnd())
}
template <> void
Destruct<corenodes::FrameData>(corenodes::FrameData* data);
maxon/variadic_port.h
template <typename T, Bool OUTPUT> class VariadicPort
{
static Result<VariadicPort> Create(MicroNodeGroupInterface* node,
const CString& prefix,
Int count,
Int base)
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>())
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)
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
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
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
corenodes::
details::PortOps<ValueType, corenodes::
details::PortArrayAccess<typename
PORTS::Ports::Access>,
void> operator *() const
}
}
class Access
{
Access() = default;
}
template <typename MNI> Result<void> ConnectMicroNode(MicroNodePtr<MNI> node, Access MNI::* a,
WIRETYPE wtype =
WIRETYPE::
ALL)
template <typename MNI> Result<void> ConnectMicroNode(MicroNodePtr<MNI> node, Access MNI::* a,
WIRETYPE wtype = DEFAULT_WIRE)
}
crypt.framework
maxon/cryptography_hash.h
image.framework
maxon/gfx_basictypes.h
template <typename T> struct DrawRect
{
}
maxon/gfx_image.h
namespace IMAGEPROPERTIES
{
{
{
MAXON_ATTRIBUTE(BaseArray<Char>, PSD_DATA,
"net.maxon.image.layer.psd_data");
}
}
}
maxon/gfx_image_bits.h
maxon/gfx_image_colorprofile.h
class ColorProfileInterface
{
}
class ColorProfileConvertInterface
{
}
maxon/gfx_image_exif.h
namespace EXIFDATA
{
namespace PROPERTIES
{
}
namespace GPS
{
}
}
maxon/gfx_image_pixelformat_template.h
maxon/half.h
{
static constexpr
Float32 Min() {
return 6.10e-5f; }
static constexpr
Float32 Max() {
return 6.55e+4f; }
}
maxon/layerset.h
class LayerSetInterface
{
}
maxon/mediasession_base.h
namespace MEDIASESSION
{
namespace EXPORT
{
MAXON_ATTRIBUTE(BaseArray<maxon::Char>, CUSTOMDATA,
"net.maxon.mediasession.export.customdata");
MAXON_ATTRIBUTE(Array<Char>, CUSTOMDATA,
"net.maxon.mediasession.export.customdata");
}
}
namespace MEDIAFORMAT
{
{
{
MAXON_ATTRIBUTE(BaseArray<Char>, PSD_DATA,
"net.maxon.mediaformat.layer.psd_data");
MAXON_ATTRIBUTE(Array<Char>, PSD_DATA,
"net.maxon.mediaformat.layer.psd_data");
}
}
{
}
{
MAXON_ATTRIBUTE(BaseArray<DataDictionary>, MARKERARRAY,
"net.maxon.mediaformat.audio.markerarray");
MAXON_ATTRIBUTE(Array<DataDictionary>, MARKERARRAY,
"net.maxon.mediaformat.audio.markerarray");
}
}
maxon/mediasession_export_rla.h
namespace MEDIASESSION
{
namespace RLA
{
namespace EXPORT
{
MAXON_ATTRIBUTE(rla::MAXRenderInfo, MAXRENDERINFO,
"net.maxon.mediasession.rla.export.maxrenderinfo");
MAXON_ATTRIBUTE(BaseArray<maxon::Char>, NAMETAB,
"net.maxon.mediasession.rla.export.nametab");
MAXON_ATTRIBUTE(Array<Char>, NAMETAB,
"net.maxon.mediasession.rla.export.nametab");
}
}
}
math.framework
maxon/apibasemath_extension.h
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
maxon/big_integer.h
class BigIntegerInterface
{
}
maxon/gradient.h
class GradientInterface
{
}
class GradientRenderDataInterface
{
}
maxon/noise.h
class NoiseInterface
{
MAXON_METHOD const BaseArray<UInt16>* GetPermutationTable()
const;
MAXON_METHOD Result<void> GetGradientTable(
Bool gradient3D, BaseArray<Vector4d32>& gradient)
const;
MAXON_METHOD const BaseArray<Vector4d32>* GetRandomTable()
const;
};
namespace NOISEPROPERTY
{
}
{
MAXON_METHOD Result<void> Init(
UInt32 seed,
Int permutationTablePower,
const DataDictionary& additionalParameters);
};
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, 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
{
using MatrixType = SqMat3<Vec3<ValueType>>;
using MatrixType = SqrMat3<Vec3<ValueType>>;
}
maxon/splinemapper.h
#define SPLINE_KNOT_GET_ID(flags) ((flags >> 16) & 0x0000ffff)
#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))
#define SPLINEMAPPER_KNOT_SET_ID(flags, flag_id) (flags = SPLINEMAPPER_KNOT_FLAGS((Int(flags) & 65535) | ((flag_id & 0x0000ffff) << 16)))
{
}
struct SplineMapperKnot
{
}
class SplineMapperInterface
{
}
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
{
}
misc.framework
maxon/gmlwriter.h
struct GmlNode
{
GmlNode() = default;
explicit GmlNode(
const void* n =
nullptr,
Int i = -1) : node(n), index(i) { }
explicit GmlNode(
const void* n,
Int i = -1) : node(n), index(i) { }
const void* node;
const void* node = nullptr;
}
maxon/io.h
maxon/sourcecontrol.h
class ProgressMonitorRef;
class SourceControlChangeEntry
{
UInt GetHashCode()
const;
MAXON_METHOD Result<void> SyncFile(
const Url& path,
Int changeList = -1, ProgressMonitorRef monitor = ProgressMonitorRef());
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());
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,
const ProgressMonitorRef& monitor = GetZeroRef<ProgressMonitorRef>(),
const SCTypeConversion& typeConversion =
SCTypeConversion(),
const String& input =
String());
}
network.framework
maxon/network_ip.h
class NetworkAdapterInterface
{
}
python.framework
cpython.h
{
struct PythonDll
{
StringDecodingRef _defaultStringDecoder;
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
{
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 CPyRef CPyString_FromStringAndSize(
const Block<const Char>& block);
MAXON_METHOD CPyRef CPyUnicode_FromStringAndSize(
const Block<const Char>& block);
MAXON_METHOD Result<String> CPyString_AsString(
const CPyRef& str);
MAXON_METHOD Result<String> CPyUnicode_AsString(
const CPyRef& str);
}
{
MAXON_METHOD Result<void> GetFunctions27(BaseArray<NativePyCFunctionTable>& functions);
MAXON_METHOD Result<void> GetFunctions37(BaseArray<NativePyCFunctionTable>& functions);
}
template <typename T>
template <typename T>
template <typename T>
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyLong_From(std::enable_if_t<std::is_same<T, Int32>::value,
Int32> o)
template <typename T>
template <typename T>
MAXON_FUNCTION CPyRef CPythonLibraryInterface::CPyLong_From(std::enable_if_t<std::is_same<T, Int64>::value,
Int64> o)
}
namespace CPythonLibs
{
}
#define Python27Output(formatString, ...)
#define Python37Output(formatString, ...)
maxon/cpython_raw.h
{
USECLASSEXCEPTIONS = 1 << 8,
TABCHECK = 1 << 10,
UNICODE_ = 1 << 11,
QNEW = 1 << 16,
}
maxon/cpython27_raw.h changed to maxon/cpython37_raw.h
maxon/cpython37_raw.h
namespace maxon::py27
struct TpFlags
{
static const Int64 INT_SUBCLASS = (1L << 23);
}
{
};
struct NativePyCodeObject
{
void* co_extra;
}
class NativePyErr_StackItem
{
NativePyErr_StackItem* previous_item = nullptr;
}
struct NativePyThreadState
{
struct _ts *prev = nullptr;
Int32 recursion_depth = 0;
Char recursion_critical = 0;
Int32 stackcheck_counter = 0;
NativePyErr_StackItem _exc_state;
NativePyErr_StackItem exc_info;
Int32 gilstate_counter = 0;
void(*on_delete)(void *);
void *on_delete_data;
Int32 coroutine_origin_tracking_depth = 0;
Int32 in_coroutine_wrapper = 0;
}
struct NativePyFrameObject
{
Char f_trace_opcodes = 0;
NativePyThreadState *f_tstate;
}
struct NativePyTypeObject
{
void* tp_finalize = nullptr;
}
maxon/cpython_raw.h
#if defined(MAXON_TARGET_LINUX)
#ifdef MAXON_TARGET_64BIT
#define LIBSDIRECTORY "linux64"
#else
#define LIBSDIRECTORY "linux32"
#endif
#elif defined(_WINDOWS)
#ifdef MAXON_TARGET_64BIT
#define LIBSDIRECTORY "win64"
#else
#define LIBSDIRECTORY "win32"
#endif
#elif defined(__APPLE__)
#define LIBSDIRECTORY "osx"
#endif
{
USECLASSEXCEPTIONS = 1 << 8,
TABCHECK = 1 << 10,
UNICODE_ = 1 << 11,
QNEW = 1 << 16,
}
maxon/cpython_ref.h
MAXON_REGISTRY(Class<CPyRef>, CPyReferences27,
"net.maxon.python.registry.pyreferences27");
MAXON_REGISTRY(Class<CPyRef>, CPyReferences37,
"net.maxon.python.registry.pyreferences37");
namespace CPyReferences27
namespace CPyReferences37
{
MAXON_DECLARATION(Class<CPyTypeRef>, CPyType,
"net.maxon.python.pyreference27.cpytype");
MAXON_DECLARATION(Class<CPyTypeRef>, CPyType,
"net.maxon.python.pyreference37.cpytype");
MAXON_DECLARATION(Class<CPyFrameRef>, CPyFrame,
"net.maxon.python.pyreference27.cpyframe");
MAXON_DECLARATION(Class<CPyFrameRef>, CPyFrame,
"net.maxon.python.pyreference37.cpyframe");
MAXON_DECLARATION(Class<CPyTracebackRef>, CPyTraceback,
"net.maxon.python.pyreference27.cpytraceback");
MAXON_DECLARATION(Class<CPyTracebackRef>, CPyTraceback,
"net.maxon.python.pyreference37.cpytraceback");
MAXON_DECLARATION(Class<CPyCodeRef>, CPyCode,
"net.maxon.python.pyreference27.cpycode");
MAXON_DECLARATION(Class<CPyCodeRef>, CPyCode,
"net.maxon.python.pyreference37.cpycode");
MAXON_DECLARATION(Class<MPyClassRef>, MPyClass,
"net.maxon.python.pyreference27.mpyclass");
MAXON_DECLARATION(Class<MPyClassRef>, MPyClass,
"net.maxon.python.pyreference37.mpyclass");
MAXON_DECLARATION(Class<MPyMemberRef>, MPyMember,
"net.maxon.python.pyreference27.mpymember");
MAXON_DECLARATION(Class<MPyMemberRef>, MPyMember,
"net.maxon.python.pyreference37.mpymember");
MAXON_DECLARATION(Class<MPyFunctionRef>, MPyFunction,
"net.maxon.python.pyreference27.mpyfunction");
MAXON_DECLARATION(Class<MPyFunctionRef>, MPyFunction,
"net.maxon.python.pyreference37.mpyfunction");
MAXON_DECLARATION(Class<MPyDataTypeRef>, MPyDataType,
"net.maxon.python.pyreference27.mpydatatype");
MAXON_DECLARATION(Class<MPyDataTypeRef>, MPyDataType,
"net.maxon.python.pyreference37.mpydatatype");
MAXON_DECLARATION(Class<MPyDataRef>, MPyData,
"net.maxon.python.pyreference27.mpydata");
MAXON_DECLARATION(Class<MPyDataRef>, MPyData,
"net.maxon.python.pyreference37.mpydata");
MAXON_DECLARATION(Class<MPyCallerContextRef>, MPyCallerContext,
"net.maxon.python.pyreference27.mpycallercontext");
MAXON_DECLARATION(Class<MPyCallerContextRef>, MPyCallerContext,
"net.maxon.python.pyreference37.mpycallercontext");
}
maxon/vm.h
{
{
SYSTEM_27,
SYSTEM_36,
DEBUG_27_VS2008,
DEBUG_27_VS2013,
DEBUG_27_VS2015,
DEBUG_36_VS2015,
RELEASE_27_VS2008,
RELEASE_27_VS2015,
RELEASE_36_VS2015,
DEBUG_27,
RELEASE_27,
DEBUG_36,
RELEASE_36,
DEFAULT_27,
DEFAULT_36,
#define MAXON_CPYTHONVM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy27"))
#define MAXON_CPYTHONVM() maxon::PythonVms::Get(maxon::Id("net.maxon.python.virtualmachine.c4dpy37"))
#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
{
}