API Change List in R15

Table of Contents

• API Changes in R15
  • c4d_basebitmap.h
  • c4d_basechannel.h
  • c4d_basecontainer.h
  • c4d_basedocument.h
  • c4d_basedraw.h
  • c4d_baselist.h
  • c4d_basetag.h
  • c4d_coffee.h
  • c4d_customdatatype.h
  • c4d_file.h
  • c4d_gedata.h
  • c4d_general.h
  • c4d_graphview.h
  • c4d_gui.h
  • c4d_library.h
  • c4d_memory.h
  • c4d_network.h
  • c4d_nodedata.h
  • c4d_omp.h
  • c4d_painter.h
  • c4d_particles.h
  • c4d_plugin.h
  • c4d_quaternion.h
  • c4d_raytrace.h
  • c4d_shader.h
  • c4d_shaderdata.h
  • c4d_string.h
  • c4d_thread.h
  • c4d_tools.h
  • c4d_uuid.h
  • c4d_videopostdata.h
  • customgui_kerning.h
  • customgui_listview.h
  • customgui_splinecontrol.h
  • ge_autoptr.h
  • ge_lmatrix.h
  • ge_lvector.h
  • ge_matrix.h
  • ge_prepass.h
  • ge_vector.h
  • gui.h
  • lib_batchrender.h
  • lib_big_integer.h
  • lib_ca.h
  • lib_clipmap.h
  • lib_description.h
  • lib_hair.h
  • lib_iconcollection.h
  • lib_intersect.h
  • lib_net.h
  • lib_pictureviewer.h
  • lib_prefs.h
  • lib_py.h
  • lib_sculpt.h
  • lib_sculptbrush.h
  • lib_secure_random.h
  • matrix4.h
  • operatingsystem.h
  • vector4.h
• API Changes in R15.057
  • c4d_basematerial.h
  • c4d_falloffdata.h
  • c4d_help.h
  • c4d_painter.h
  • c4d_shader.h
  • ge_prepass.h
  • lib_batchrender.h
  • lib_ca.h
  • lib_net.h

Changes legend:

• | changed
• + added
• - removed
• > moved
• ! deprecated
• // commented
• /// remark

API Changes in R15

c4d_basebitmap.h

+ BASEBITMAP_DATA_GUIPIXELRATIO
 
 
enum BITMAP_UPDATEREGION
{
+   BITMAP_UPDATEREGION_COLOR,
+   BITMAP_UPDATEREGION_PREPARE
};
 
 
class MultipassBitmap : public BaseBitmap
{
+   void SetUserID(Int32 id);
+   void SetUserSubID(Int32 subid);
+   void SetSave(Bool save);
+   void SetName(const String& name);
+   void SetColorMode(COLORMODE mode);
+   void SetComponent(Int32 c);
+   void SetDpi(Int32 dpi);
 
+   void SetBlendMode(Int32 mode);
};
 
 
+ class AutoBitmap;
> moved from c4d_nodedata.h
 
 
+ IconData InitResourceIcon(Int32 resource_id);

c4d_basechannel.h

class BaseShader : public BaseList2D
{
+   BaseShader* GetSubsurfaceShader(Float& bestmpl);
};

c4d_basecontainer.h

class BaseContainer
{
|   LONG GetLong(LONG id, LONG preset = 0) const;
|   renamed to
|   Int32 GetInt32(Int32 id, Int32 preset = 0) const;
 
|   ULONG GetULong(LONG id, ULONG preset = 0) const;
|   renamed to
|   UInt32 GetUInt32(Int32 id, UInt32 preset = 0) const;
 
|   LLONG GetLLong(LONG id, LLONG preset = 0) const;
|   renamed to
|   Int64 GetInt64(Int32 id, Int64 preset = 0) const;
 
|   LULONG GetLULong(LONG id, LULONG preset = 0) const;
|   renamed to
|   UInt64 GetUInt64(Int32 id, UInt64 preset = 0) const;
 
|   Real GetReal(LONG id, Real preset = 0.0) const;
|   renamed to
|   Float GetFloat(Int32 id, Float preset = 0.0) const;
 
 
+   void* GetMemoryAndRelease(Int32 id, Int& count, void* preset = nullptr);
+   void* GetMemory(Int32 id, Int& count, void* preset = nullptr) const;
 
 
+   C4DUuid GetUuid(Int32 id, const C4DUuid& preset = C4DUuid(DC)) const;
 
 
|   void SetLong(LONG id, LONG l);
|   renamed to
|   void SetInt32(Int32 id, Int32 l);
 
|   void SetULong>(LONG id, ULONG l);
|   renamed to
|   void SetUInt32(Int32 id, UInt32 l);
 
|   void SetLLong(LONG id, LLONG l);
|   renamed to
|   void SetInt64(Int32 id, Int64 l);
 
|   void SetLULong(LONG id, LULONG l);
|   renamed to
|   void SetUInt64(Int32 id, UInt64 l);
 
|   void SetReal(LONG id, Real r);
|   renamed to
|   void SetFloat(Int32 id, Float r);
 
+   void SetMemory(Int32 id, void* mem, Int count);
 
+   void SetUuid(Int32 id, const C4DUuid& u);
};

c4d_basedocument.h

class BaseDocument : public BaseList2D
{
+   BaseBitmap* GetDocPreviewBitmap();
};
 
 
| BaseDocument *LoadDocument(const Filename& name, SCENEFILTER loadflags, BaseThread* thread);
| changed to
| BaseDocument* LoadDocument(const Filename& name, SCENEFILTER loadflags, BaseThread* thread, String* errorString = nullptr);
| added parameter errorString
 
| Bool MergeDocument(BaseDocument* doc, const Filename& name, SCENEFILTER loadflags, BaseThread* thread);
| changed to
| Bool MergeDocument(BaseDocument* doc, const Filename& name, SCENEFILTER loadflags, BaseThread* thread, String* errorString = nullptr);
| added parameter errorString
 
| RENDERRESULT RenderDocument(BaseDocument* doc, const BaseContainer& rdata, ProgressHook* pr, void* private_data, BaseBitmap* bmp, RENDERFLAGS renderflags, BaseThread* th);
| changed to
| RENDERRESULT RenderDocument(BaseDocument* doc, const BaseContainer& rdata, ProgressHook* prog, void* private_data, BaseBitmap* bmp, RENDERFLAGS renderflags, BaseThread* th, WriteProgressHook* wprog = nullptr, void* data = nullptr);
| added parameters wprog and data
 
 
+ Bool SaveProject(BaseDocument* doc, SAVEPROJECT flags, Filename targetPath, maxon::BaseArray<AssetEntry>* assets = nullptr, maxon::BaseArray<AssetEntry>* missingAssets = nullptr);
 
+ Bool GetAllAssets(BaseDocument* doc, Bool allowDialogs, maxon::BaseArray<AssetEntry>& assets, Filename& lastPath);

c4d_basedraw.h

class BaseView : public BaseList2D
{
|   const Real GetPlanarRotation() const;
|   changed to
|   Float GetPlanarRotation() const;
|   method is const but does not return a const value anymore
}
 
+ DRAW_PARAMETER_OGL_PRIMITIVERESTARTINDEX

c4d_baselist.h

struct ToolAskMsgData
{
+   Bool use_singleclick;
};
 
 
struct DescriptionImExportInit
{
+   GeModalDialog* dlg;
};
 
 
+ MSG_ALLOWXPRESSODROP
 
 
struct DocumentInfoMakeProj
{
+   Bool allowCopy;
+   Bool allowGUI;
};
 
 
+ class AssetEntry;
 
+ struct AssetData;
> moved from c4d_shader.h

c4d_basetag.h

class UVWTag : public VariableTag
{
|   const UVWHandle GetDataAddressR(void);
|   changed to
|   ConstUVWHandle GetDataAddressR(void);
|   return value changed from const UVWHandle to ConstUVWHandle
 
|   static void Get(const UVWHandle dataptr, Int32 i, UVWStruct &res);
|   changed to
|   static void Get(ConstUVWHandle dataptr, Int32 i, UVWStruct& res);
|   parameter dataptrt type changed from const UVWHandle to ConstUVWHandle
 
|   static void Copy(UVWHandle destptr, Int32 dst, const UVWHandle srcptr, Int32 src);
|   changed to
|   static void Copy(UVWHandle destptr, Int32 dst, ConstUVWHandle srcptr, Int32 src)
|   parameter srcptr type changed from const UVWHandle to ConstUVWHandle
};
 
 
class NormalTag : public VariableTag
{
|   const NormalHandle GetDataAddressR(void);
|   changed to
|   ConstNormalHandle GetDataAddressR(void);
|   return value changed from const NormalHandle to ConstNormalHandle
 
|   static void Get(const NormalHandle dataptr, Int32 i, NormalStruct &res);
|   changed to
|   static void Get(ConstNormalHandle dataptr, Int32 i, NormalStruct& res);
|   parameter dataptr type changed from const NormalHandle to ConstNormalHandle
 
|   static void Copy(NormalHandle destptr, Int32 dst, const NormalHandle srcptr, Int32 src);
|   changed to
|   static void Copy(NormalHandle destptr, Int32 dst, ConstNormalHandle srcptr, Int32 src);
|   parameter srcptr type changed from const NormalHandle to ConstNormalHandle
};

c4d_coffee.h

| Bool CoffeeEditor_Open(BaseList2D* obj, CoffeeEditorCallback* callback);
| renamed and changed to
| Bool CodeEditor_Open(BaseList2D* obj, CodeEditorCallback* callback, const BaseContainer& bc = BaseContainer());
| added parameter bc
 
 
class VALUE
{
|   LONG GetLong(LONG* err = NULL) const;
|   renamed to
|   Int32 GetInt32(Int32* err = nullptr) const;
 
|   Real GetReal(LONG* err = NULL) const;
|   renamed to
|   Float GetFloat(Int32* err = NULL) const;
 
|   void SetLong(LONG i);
|   renamed to
|   void SetInt32(Int32 i);
 
|   void SetReal(Real f);
|   renamed to
|   void SetFloat(Float f);
};

c4d_customdatatype.h

+ CUSTOMDATATYPE_INFO_NO_GUI_COPY
/// private

c4d_file.h

class Filename
{
+   Bool IsBrowserUrl() const;
};
 
 
+ typedef Filename RelativeFilename;
 
 
class BaseFile
{
+   LOCATION GetLocation() const;
 
|   Bool ReadWord(SWORD* v);
|   renamed to
|   Bool ReadInt16(Int16* v);
 
|   Bool ReadUWord(UWORD* v);
|   renamed to
|   Bool ReadUInt16(UInt16* v);
 
|   Bool ReadLong(LONG* v);
|   renamed to
|   Bool ReadInt32(Int32* v);
 
|   Bool ReadULong(ULONG* v);
|   renamed to
|   Bool ReadUInt32(UInt32* v);
 
|   Bool ReadSReal(SReal* v);
|   renamed to
|   Bool ReadFloat32(Float32 *v);
 
|   Bool ReadLReal(LReal *v);
|   renamed to
|   Bool ReadFloat64(Float64 *v);
 
|   Bool ReadLLong(LLONG* v);
|   renamed to
|   Bool ReadInt64(Int64* v);
 
|   Bool ReadLULong(LULONG* v);
|   renamed to
|   Bool ReadUInt64(UInt64* v);
 
|   Bool ReadSVector(SVector* v);
|   renamed to
|   Bool ReadVector32(Vector32* v);
 
|   Bool ReadLVector(LVector* v);
|   renamed to
|   Bool ReadVector64(Vector64* v);
 
|   Bool ReadSMatrix(SMatrix* v);
|   renamed to
|   Bool ReadMatrix32(Matrix32* v);
 
|   Bool ReadLMatrix(LMatrix* v);
|   renamed to
|   Bool ReadMatrix64(Matrix64* v);
 
 
 
|   Bool WriteWord(SWORD v);
|   renamed to
|   Bool WriteInt16(Int16 v);
 
|   Bool WriteUWord(UWORD v);
|   renamed to
|   Bool WriteUInt16(UInt16 v);
 
|   Bool WriteLong>(LONG v);
|   renamed to
|   Bool WriteInt32(Int32 v);
 
|   Bool WriteULong(ULONG v);
|   renamed to
|   Bool WriteUInt32(UInt32 v);
 
|   Bool WriteSReal(SReal v);
|   renamed to
|   Bool WriteFloat32(Float32 v);
 
|   Bool WriteLReal(LReal v);
|   renamed to
|   Bool WriteFloat64(Float64 v);
 
|   Bool WriteLLong(LLONG v);
|   renamed to
|   Bool WriteInt64(Int64 v);
 
|   Bool WriteLULong(LULONG v);
|   renamed to
|   Bool WriteUInt64(UInt64 v);
 
|   Bool WriteSVector(const SVector& v);
|   renamed to
|   Bool WriteVector32(const Vector32& v);
 
|   Bool WriteLVector(const LVector& v);
|   renamed to
|   Bool WriteVector64(const Vector64& v);
 
|   Bool WriteSMatrix(const SMatrix& v);
|   renamed to
|   Bool WriteMatrix32(const Matrix32& v);
 
|   Bool WriteLMatrix(const LMatrix& v);
|   renamed to
|   Bool WriteMatrix64(const Matrix64& v);
};
 
 
class HyperFile
{
|   Bool WriteWord(SWORD v);
|   renamed to
|   Bool WriteInt16(Int16 v);
 
|   Bool WriteUWord(UWORD v);
|   renamed to
|   Bool WriteUInt16(UInt16 v);
 
|   Bool WriteLong(LONG v);
|   renamed to
|   Bool WriteInt32(Int32 v);
 
|   Bool WriteULong(ULONG v);
|   renamed to
|   Bool WriteUInt32(UInt32 v);
 
|   Bool WriteLLong(LLONG v);
|   renamed to
|   Bool WriteInt64(Int64 v);
 
|   Bool WriteLULong(LULONG v);
|   renamed to
|   Bool WriteUInt64(UInt64 v);
 
|   Bool WriteReal(Real v);
|   renamed to
|   Bool WriteFloat(Float v);
 
|   Bool WriteSReal(SReal v);
|   renamed to
|   Bool WriteFloat32(Float32 v);
 
|   Bool WriteLReal(LReal v);
|   renamed to
|   Bool WriteFloat64(Float64 v);
 
|   Bool WriteSVector(const SVector& v);
|   renamed to
|   Bool WriteVector32(const Vector32& v);
 
|   Bool WriteLVector(const LVector& v);
|   renamed to
|   Bool WriteVector64(const Vector64& v);
 
|   Bool WriteSMatrix(const SMatrix& v);
|   renamed to
|   Bool WriteMatrix32(const Matrix32& v);
 
|   Bool WriteLMatrix(const LMatrix& v);
|   renamed to
|   Bool WriteMatrix64(const Matrix64& v);
 
 
+   Bool WriteUuid(const C4DUuid& v);
 
 
 
|   Bool ReadWord(SWORD* v);
|   renamed to
|   Bool ReadInt16(Int16* v);
 
|   Bool ReadUWord(UWORD* v);
|   renamed to
|   Bool ReadUInt16(UInt16* v);
 
|   Bool ReadLong(LONG* v);
|   renamed to
|   Bool ReadInt32(Int32* v);
 
|   Bool ReadULong(ULONG* v);
|   renamed to
|   Bool ReadUInt32(UInt32* v);
 
|   Bool ReadLLong(LLONG* v);
|   renamed to
|   Bool ReadInt64(Int64* v);
 
|   Bool ReadLULong(LULONG* v);
|   renamed to
|   Bool ReadUInt64(UInt64* v);
 
|   Bool ReadReal(Real* v);
|   renamed to
|   Bool ReadFloat(Float* v);
 
|   Bool ReadSReal(SReal* v);
|   renamed to
|   Bool ReadFloat32(Float32* v);
 
|   Bool ReadLReal(LReal* v);
|   renamed to
|   Bool ReadFloat64(Float64* v);
 
|   Bool ReadSVector(SVector* v);
|   renamed to
|   Bool ReadVector32(Vector32* v);
 
|   Bool ReadLVector(LVector* v);
|   renamed to
|   Bool ReadVector64(Vector64* v);
 
|   Bool ReadSMatrix(SMatrix* v);
|   renamed to
|   Bool ReadMatrix32(Matrix32* v);
 
|   Bool ReadLMatrix(LMatrix* v);
|   renamed to
|   Bool ReadMatrix64(Matrix64* v);
 
 
+   Bool ReadUuid(C4DUuid* v);
 
+   LOCATION GetLocation(void) const;
 
+   void SetFileVersion(Int32 val);
};

c4d_gedata.h

| enum DA;
| GeData types enum has been renamed to DA (was anonymous)
 
 
class GeData
{
+   GeData(const C4DUuid& n)
+   added constructor for C4DUuid
 
+   GeData(void* mem, Int count)
 
|   LONG GetLong(void) const;
|   renamed to
|   Int32 GetInt32(void) const;
 
|   Int64 GetLLong(void) const;
|   renamed to
|   Int64 GetInt64(void) const;
 
|   Float GetReal(void) const;
|   renamed to
|   Float GetFloat(void) const;
 
 
+   const C4DUuid& GetUuid(void) const;
 
 
+   void* GetMemoryAndRelease(Int& count);
+   void* GetMemory(Int& count);
 
 
|   void SetReal(Real v);
|   renamed to
|   void SetFloat(Float v);
 
|   void SetLong(Int32 v);
|   renamed to
|   void SetInt32(Int32 v);
 
|   void SetLLong(const LLONG& v);
|   renamed to
|   void SetInt64(const Int64& v);
 
 
+   void SetUuid(const C4DUuid& v);
 
 
+   void SetMemory(void* data, Int count);
};

c4d_general.h

+ inline Bool IsServer();
+ inline Bool IsClient();
 
 
+ UInt32 GeGetCinemaInfo(CINEMAINFO info);
 
 
+ void StatusNetClear(void);
+ void StatusSetNetLoad(STATUSNETSTATE status);
+ void StatusSetNetBar(Int32 p, const GeData& dat);
+ void StatusSetNetText(const String& str);
 
 
+ void SaveWorldPreferences();
 
 
+ Filename GeFilterSetSuffix(const Filename& name, Int32 id);
 
 
- GeAssert()
- GeBreak()
- GeBoom()
 
 
+ String GetMacModel(const String& machinemodel)
 
 
 
< IpConnection* GeIpOpenListener(ULONG ipAddr, LONG port, BaseThread* thread, LONG timeout, Bool dontwait, LONG* ferr);
< moved and changed to c4d_network.h
 
< IpConnection* GeIpOpenOutgoing(const CHAR* hostname, BaseThread* thread, LONG initial_timeout, LONG timeout, Bool dontwait, LONG* ferr);
< moved and changed to c4d_network.h
 
< IpConnection* GeIpWaitForIncoming(IpConnection* listener, BaseThread* connection, VLONG* error);
< moved and changed to c4d_network.h
 
< void GeIpCloseConnection(IpConnection*& ipc);
< moved to c4d_network.h
 
< void GeIpKillConnection(IpConnection*& ipc);
< moved to c4d_network.h
 
< VLONG GeIpBytesInInputBuffer(IpConnection* ipc);
< moved to c4d_network.h
 
< VLONG GeIpReadBytes(IpConnection* ipc, void* buf, VLONG size);
< moved to c4d_network.h
 
< VLONG GeIpSendBytes(IpConnection* ipc, const void* buf, VLONG size);
< moved to c4d_network.h
 
- void GeIpGetHostAddr(IpConnection* ipc, CHAR* buf, LONG bufsize);
- void GeIpGetRemoteAddr(IpConnection* ipc, CHAR* buf, LONG bufsize);
 
 
+ void SetExitCode(Int32 exitCode);

c4d_graphview.h

class GvPort
{
|   Bool GetReal(Real* f, GvRun* r);
|   renamed to
|   Bool GetFloat(Float* f, GvRun* r);
 
|   Bool SetReal(Real f, GvRun* r);
|   renamed to
|   Bool SetFloat(Float f, GvRun* r);
};
 
 
class GvWorld
{
|   Real GetReal(const String& title, Real default_value);
|   renamed to
|   Float GetFloat(const String& title, Float default_value);
};

c4d_gui.h

enum
{
|   FORMAT_REAL
|   renamed to
|   FORMAT_FLOAT
 
|   FORMAT_LONG
|   renamed to
|   FORMAT_INT
};
 
 
class GeUserArea
{
+   Float GetPixelRatio() const;
};
 
 
+ GUI_MAXRANGE
+ GUI_MINRANGE
 
 
class GeDialog
{
|   Bool SetLong(const GadgetPtr& id, LONG value, LONG min = MINLONGl, LONG max = MAXLONGl, LONG step = 1, LONG tristate = 0, LONG min2 = MINLONGl, LONG max2 = MAXLONGl);
|   renamed to
|   Bool SetInt32(const GadgetPtr& id, Int32 value, Int32 min = LIMIT<Int32>::MIN, Int32 max = LIMIT<Int32>::MAX, Int32 step = 1, Int32 tristate = 0, Int32 min2 = LIMIT<Int32>::MIN, Int32 max2 = LIMIT<Int32>::MAX);
 
|   Bool SetReal(const GadgetPtr& id, Real value, Real min = MINREALr, Real max = MAXREALr, Real step = 1.0, LONG format = FORMAT_REAL, Float min2 = 0.0, Float max2 = 0.0, Bool quadscale = false, LONG tristate = 0);
|   renamed to
|   Bool SetFloat(const GadgetPtr& id, Float value, Float min = MINVALUE_FLOAT, Float max = GUI_MAXRANGE, Float step = 1.0, Int32 format = FORMAT_FLOAT, Float min2 = 0.0, Float max2 = 0.0, Bool quadscale = false, Int32 tristate = 0);
 
|   Bool GetLong(const GadgetPtr& id, LONG& value) const;
|   renamed to
|   Bool GetInt32(const GadgetPtr& id, Int32& value) const;
 
|   Bool GetReal(const GadgetPtr& id, Real& value) const;
|   renamed to
|   Bool GetFloat(const GadgetPtr& id, Float& value) const;
 
 
|   Bool SetLong(const GadgetPtr& id, const BaseContainer *bc, LONG bcid, LONG min = MINLONGl, LONG max = MAXLONGl, LONG step = 1, LONG min2 = MINLONGl, LONG max2 = MAXLONGl);
|   renamed to
|   Bool SetInt32(const GadgetPtr& id, const BaseContainer* bc, Int32 bcid, Int32 min = LIMIT<Int32>::MIN, Int32 max = LIMIT<Int32>::MAX, Int32 step = 1, Int32 min2 = LIMIT<Int32>::MIN, Int32 max2 = LIMIT<Int32>::MAX);
 
|   Bool SetReal(const GadgetPtr& id, const BaseContainer* bc, LONG bcid, Real min = MINREALr, Real max = MAXREALr, Real step = 1.0, LONG format = FORMAT_REAL, Real min2 = 0.0, Real max2 = 0.0, Bool quadscale = FALSE);
|   renamed to
|   Bool SetFloat(const GadgetPtr& id, const BaseContainer* bc, Int32 bcid, Float min = MINVALUE_FLOAT, Float max = GUI_MAXRANGE, Float step = 1.0, Int32 format = FORMAT_FLOAT, Float min2 = 0.0, Float max2 = 0.0, Bool quadscale = false);
 
|   Bool GetLong(const GadgetPtr& id, BaseContainer* bc, LONG bcid) const;
|   renamed to
|   Bool GetInt32(const GadgetPtr& id, BaseContainer* bc, Int32 bcid) const;
 
|   Bool GetReal(const GadgetPtr& id, BaseContainer* bc, LONG bcid) const;
|   renamed to
|   Bool GetFloat(const GadgetPtr& id, BaseContainer* bc, Int32 bcid) const;
 
|   Bool SetLong(const GadgetPtr& id, const TriState<LONG>& tri, LONG min = MINLONGl, LONG max = MAXLONGl, LONG step = 1, LONG min2 = MINLONGl, LONG max2 = MAXLONGl);
|   renamed to
|   Bool SetInt32(const GadgetPtr& id, const TriState<Int32>& tri, Int32 min = LIMIT<Int32>::MIN, Int32 max = LIMIT<Int32>::MAX, Int32 step = 1, Int32 min2 = LIMIT<Int32>::MIN, Int32 max2 = LIMIT<Int32>::MAX);
 
|   Bool SetReal(const GadgetPtr& id, const TriState<Real>& tri, Real min = MINREALr, Real max = MAXREALr, Real step = 1.0, LONG format = FORMAT_REAL, Real min2 = 0.0,Real max2 = 0.0, Bool quadscale = FALSE);
|   renamed to
|   Bool SetFloat(const GadgetPtr& id, const TriState<Float>& tri, Float min = MINVALUE_FLOAT, Float max = GUI_MAXRANGE, Float step = 1.0, Int32 format = FORMAT_FLOAT, Float min2 = 0.0, Float max2 = 0.0, Bool quadscale = false);
 
 
+   Float GetPixelRatio() const;
};

c4d_library.h

+ Bool IsLibraryInstalled(Int32 id);

c4d_memory.h

- GeReallocTypeNC()
- GeAllocType()
- GeAllocTypeNC()
 
+ void MemCopy(void* d, const void* s, Int size)
 
- gNew
 
| bNew
| renamed to
| bNewDeprecatedUseArraysInstead
| bNew is deprecated
 
 
| class MemoryPool;
| renamed to
| class DeprecatedMemoryPool;
| MemoryPool is deprecated

c4d_network.h

+ added header
 
 
+ union GeSockAddrIn;
 
 
+ class IpAddr;
+ class IpAddrPort : public IpAddr;
 
 
+ class NetworkInterface;
 
+ class ZeroConfService;
+ class IpConnection;
 
 
+ Bool WakeOnLan(const maxon::BaseArray<UChar>& macAddress, const IpAddr& broadcast);
+ Bool GetMacAddress(maxon::BaseArray<UChar>& macAddress);
+ NetworkInterface* GetBestNetworkInterface(PROTOCOL protocol = PROTOCOL_IPV4);
+ Bool GetAllNetworkInterfaces(maxon::BaseArray<NetworkInterface*>& networkInterfaces);
+ String GetHostname();
+ String GetHostname(const IpAddr& ipAddr);
+ Int GetInterfaceIndex(const String& interfaceName);
+ RESOLVERESULT ResolveHostname(const String& address, PROTOCOL ptype, maxon::BaseArray<IpAddr>& addrs, Bool firstMatch = true, Bool forceResolve = false);
+ Bool GetIpAddress(const String& address, IpAddr& a, Bool resolve = false, Bool forceResolve = false);
+ Bool GetIpAddress(const String& address, IpAddrPort& a, Bool resolve = false, Bool forceResolve = false);
+ Bool SplitAddress(String address, String* scheme, String* host, Int* port);
 
 
> IpConnection* GeIpOpenOutgoing(const IpAddrPort& adr, BaseThread* thread = nullptr, Int initialTimeout = 30, Int timeout = 10, Bool useNagleAlgorithm = true, Int* error = nullptr);
> IpConnection* GeIpOpenOutgoing(const String& adr, BaseThread* thread = nullptr, Int initialTimeout = 30, Int timeout = 10, Bool useNagleAlgorithm = true, Int* error = nullptr);
> moved and changed from c4d_general.h
> IpConnection* GeIpOpenListener(ULONG ipAddr, LONG port, BaseThread* thread, LONG timeout, Bool dontwait, LONG* ferr);
 
> Int GeIpBytesInInputBuffer(IpConnection* ipc);
> moved from c4d_general.h
> VLONG GeIpBytesInInputBuffer(IpConnection* ipc);
 
> Int GeIpReadBytes(IpConnection* ipc, void* buf, Int size);
> moved from c4d_general.h
> VLONG GeIpReadBytes(IpConnection* ipc, void* buf, VLONG size);
 
> Int GeIpSendBytes(IpConnection* ipc, const void* buf, Int size);
> moved from c4d_general.h
> VLONG GeIpSendBytes(IpConnection* ipc, const void* buf, VLONG size);
 
> IpConnection* GeIpOpenListener(const IpAddrPort& adr, BaseThread* thread, Int timeout, Bool dontwait, Int* error);
> IpConnection* GeIpOpenListener(const String& adr, BaseThread* thread, Int timeout, Bool useNagleAlgorithm, Int* error);
> moved and changed from c4d_general.h
> IpConnection* GeIpOpenListener(ULONG ipAddr, LONG port, BaseThread* thread, LONG timeout, Bool dontwait, LONG* ferr);
 
> IpConnection* GeIpWaitForIncoming(IpConnection* listener, BaseThread* connection, Int* error);
> moved from c4d_general.h
> IpConnection* GeIpWaitForIncoming(IpConnection* listener, BaseThread* connection, VLONG* error);
 
> void GeIpKillConnection(IpConnection*& ipc);
> moved from c4d_general.h
> void GeIpKillConnection(IpConnection*& ipc);
 
> void GeIpCloseConnection(IpConnection*& ipc);
> moved from c4d_general.h
> void GeIpCloseConnection(IpConnection*& ipc);
 
 
 
+ Bool GetBonjourVersion(Int& versionNumber, Int& revisionNumber, Bool& isRunning);
 
+ ZeroConfBrowser* StartZeroConfBrowser(const String& serviceType, ZeroConfBrowserCallback browseCallback, ZeroConfBrowserResolvedCallback resolveCallback, void* context);
+ void StopZeroConfBrowser(ZeroConfBrowser* browser);
 
+ ZeroConfService* RegisterZeroConfService(String serviceName, const String& serviceType, Int lInterface, Int port, const String& domainName = String());
+ void DeregisterZeroConfService(ZeroConfService* service);

c4d_nodedata.h

+ class AutoBitmap;
> moved to c4d_basebitmap.h

c4d_omp.h

- removed header

c4d_painter.h

class PaintMaterial : public PaintBitmap
{
+   static Bool SaveDocument(BaseDocument* doc, Bool& cancel);
+   static Bool AskNeedToSave(BaseDocument* doc);
};

c4d_particles.h

class TP_PGroupArray : public maxon::BaseArray<TP_PGroup*>
{
|   TP_PGroupArray(C4D_MISC_MOVE_TYPE(TP_PGroupArray) src);
|   changed to
|   TP_PGroupArray(TP_PGroupArray&& src);
};

c4d_plugin.h

+ C4DPL_CHANGEDSECURITYTOKEN
+ C4DPL_SHUTDOWNTHREADS
+ C4DPL_LAYOUTCHANGED
+ C4DPL_NETWORK_CHANGE
+ C4DPL_SYSTEM_SLEEP
+ C4DPL_SYSTEM_WAKE
 
 
+ C4DPL_NetRenderResult
+ struct C4DPL_NetRenderResult;
/// private

c4d_quaternion.h

| Vector64 LMatrixToHPB(const LMatrix &m);
| renamed to
| Vector64 Matrix64ToHPB(const Matrix64& m);

c4d_raytrace.h

struct RayLight
{
|   Bool areanoiselock;
|   renamed to
|   Bool areanoiselock_ex;
};
 
 
struct RayParameter
{
+   Float gi_radiance_intensity;
+   Float gi_radiance_saturation;
 
+   Bool gi_lightmapping_enabled;
+   Bool gi_lightmapping_direct;
+   Bool gi_lightmapping_prepass;
+   Int32 gi_lightmapping_mode;
 
+   Bool net_caches_sss;
+   Bool net_caches_ao;
+   Bool net_caches_gi;
+   Bool net_caches_rm;
+   Bool net_caches_lm;
};
 
 
| struct SurfaceData;
| old struct definition deprecated and renamed to
| struct SurfaceDataEx;
 
 
struct SurfaceData
{
+   Vector comp_color;
+   Vector comp_specular;
+   Vector comp_luminance;
};
 
 
struct RayHemisphere
{
+   Bool ao_trans;
};

c4d_shader.h

struct BaseVolumeData
{
+   Float mb_offset;
 
+   Vector comp_color;
+   Vector comp_specular;
+   Vector comp_luminance;
};
 
 
> enum ASSETDATA_FLAG;
> moved to ge_prepass.h
 
> struct AssetData;
> moved to ge_prepass.h

c4d_shaderdata.h

class ShaderData : public NodeData
{
+   virtual BaseShader* GetSubsurfaceShader(BaseShader* sh, Float& bestmpl);
};

c4d_string.h

class String
{
|   String(LONG count, UWORD fillch);
|   changed to
|   String(Int count, UInt16 fillch);
 
 
|   LONG Compare(const String &cs) const;
|   changed return type from LONG to Int
|   Int Compare(const String& cs) const;
 
|   LONG LexCompare(const String &cs) const;
|   changed return type from LONG to Int
|   Int LexCompare(const String& cs) const;
 
|   LONG RelCompare(const String &cs) const;
|   changed return type from LONG to Int
|   Int RelCompare(const String& cs) const;
 
|   LONG ComparePart(const String &Str, LONG cnt, LONG pos) const;
|   changed return, parameters cnt and pos type from LONG to Int
|   Int ComparePart(const String& Str, Int cnt, Int pos) const;
 
|   LONG LexComparePart(const String &Str, LONG cnt, LONG pos) const;
|   changed return, parameters cnt and pos type from LONG to Int
|   Int LexComparePart(const String& Str, Int cnt, Int pos) const;
 
 
|   Bool FindFirst(const String& cs, LONG* pos, LONG start = 0) const;
|   changed parameter start type from LONG to Int
|   Bool FindFirst(const String& cs, Int32* pos, Int start = 0) const;
 
|   Bool FindLast(const String &cs, LONG* pos, LONG start = -1) const;
|   changed parameter start type from LONG to Int
|   Bool FindLast(const String& cs, Int32* pos, Int start = -1) const
 
|   Bool FindFirst(UWORD ch, LONG* pos, LONG start = 0) const;
|   changed parameter start type from LONG to Int
|   Bool FindFirst(UInt16 ch, Int32* pos, Int start = 0) const;
 
|   Bool FindLast(UWORD ch, LONG* pos, LONG start = -1) const;
|   changed parameter start type from LONG to Int
|   Bool FindLast(UInt16 ch, Int32* pos, Int start = -1) const
 
|   Bool FindFirstUpper(const String& findupper, LONG* pos, LONG start) const;
|   changed parameter start type from LONG to Int
|   Bool FindFirstUpper(const String& findupper, Int32* pos, Int start) const;
 
|   Bool FindLastUpper(const String& findupper, LONG* pos, LONG start) const;
|   changed parameter start type from LONG to Int
|   Bool FindLastUpper(const String& findupper, Int32* pos, Int start) const;
 
|   void Delete(LONG pos, LONG count);
|   changed parameters pos and count type from LONG to Int
|   void Delete(Int pos, Int count);
 
|   void Insert(LONG pos, UWORD ch);
|   changed parameter pos type from LONG to Int
|   void Insert(Int pos, UInt16 ch);
 
|   void Insert(LONG pos, const String &cs, LONG start = -1, LONG end = -1);
|   changed parameters pos, start and end type from LONG to Int
|   void Insert(Int pos, const String& cs, Int start = -1, Int end = -1);
 
|   String SubStr(LONG start, LONG count) const;
|   changed parameters start and count type from LONG to Int
|   String SubStr(Int start, Int count) const;
 
|   String Left(LONG count) const;
|   changed parameter count type from LONG to Int
|   String Left(Int count) const
 
|   String Right(LONG count) const;
|   changed parameter count type from LONG to Int
|   String Right(Int count) const;
 
 
|   Real ToReal(LONG* error = NULL, LONG unit = 0, LONG angletype = 0, LONG base = 10) const;
|   renamed and changed parameters unit, angletype and base type from LONG to Int
|   Float ParseToFloat(Int32* error = nullptr, Int unit = 0, Int angletype = 0, Int base = 10) const;
 
|   LONG ToLong(LONG* error = NULL) const;
|   renamed to
|   Int32 ParseToInt32(Int32* error = nullptr) const;
 
 
+   static String MemoryToString(Int64 mem);
+   static String HexToString(UInt32 v, Bool prefix0x = true);
+   static String HexToString(UInt64 v, Bool prefix0x = true);
+   static String IntToString(Int32 l);
+   static String IntToString(Int64 l);
+   static String UIntToString(UInt32 l);
+   static String UIntToString(UInt64 l);
 
|   friend String RealToString(Real v, LONG vk = -1, LONG nk = -1, Bool e = FALSE, UWORD xchar = '0');
|   renamed and changed to
|   static String FloatToString(Float32 v, Int32 vvk = -1, Int32 nnk = -1, Bool e = false, UInt16 xchar = '0');
|   static String FloatToString(Float64 v, Int32 vvk = -1, Int32 nnk = -1, Bool e = false, UInt16 xchar = '0');
 
+   static String VectorToString(const Vector32& v, Int32 nnk = -1);
+   static String VectorToString(const Vector64& v, Int32 nnk = -1);
 
 
+   Int32 ToInt32(Bool* error = nullptr) const;
+   Int64 ToInt64(Bool* error = nullptr) const;
+   UInt32 ToUInt32(Bool* error = nullptr) const;
+   UInt64 ToUInt64(Bool* error = nullptr) const;
 
+   Int ToInt(Bool* error = nullptr) const;
+   UInt ToUInt(Bool* error = nullptr) const;
 
 
|   LONG GetCString(Char *scstr, LONG max, STRINGENCODING type = STRINGENCODING_XBIT) const
|   changed parameter max type from LONG to Int
|   Int32 GetCString>(Char* scstr, Int max, STRINGENCODING type = STRINGENCODING_XBIT) const
 
|   void SetCString(const Char *cstr, LONG count = -1, STRINGENCODING type = STRINGENCODING_XBIT)
|   changed parameter count type from LONG to Int
|   void SetCString(const Char* cstr, Int count = -1, STRINGENCODING type = STRINGENCODING_XBIT)
 
|   LONG SetCStringR(const Char *cstr, LONG count = -1, STRINGENCODING type = STRINGENCODING_XBIT)
|   changed parameter count type from LONG to Int
|   Int32 SetCStringR(const Char* cstr, Int count = -1, STRINGENCODING type = STRINGENCODING_XBIT)
 
|   void GetUcBlock(UWORD* Ubc, LONG Max) const;
|   changed parameter Max name and type to maxSize and Int
|   void GetUcBlock(UInt16* Ubc, Int maxSize) const;
 
|   void GetUcBlockNull(UWORD* Ubc, LONG Max) const;
|   changed parameter Max name and type to maxSize and Int
|   void GetUcBlockNull(UInt16* Ubc, Int maxSize) const;
 
|   void SetUcBlock(const UInt16* Ubc, Int32 Count);
|   changed parameter Count name and type to count and Int
|   void SetUcBlock(const UInt16* Ubc, Int count);
};
 
 
- inline String LongToString(LONG l);
- inline String LLongToString(LLONG l);
- inline String RealToString(Real v, LONG vvk, LONG nnk, Bool e, UWORD xchar);
 
- String PtrToString(const void *hex);
- String MemoryToString(LLONG mem);
 
- TString()

c4d_thread.h

class C4DThread
{
|   void Wait(Bool checkevents);
|   changed to
|   void Wait(Bool checkevents = false);
|   set parameter checkevents to false default value
};
 
class GeSignal
{
|   Bool Init(SIGNALMODE mode);
|   changed to
|   Bool Init(SIGNALMODE mode = SIGNALMODE_DEFAULT);
|   set parameter mode to SIGNALMODE_DEFAULT default value
};

c4d_tools.h

> inline SVector Mix(const SVector& v1, const SVector& v2, SReal t);
> inline LVector Mix(const LVector& v1, const LVector& v2, LReal t);
> inline SReal Mix(SReal v1, SReal v2, SReal t);
> inline LReal Mix(LReal v1, LReal v2, LReal t);
> moved to maxon and renamed to maxon::Blend
 
- inline SReal Step(SReal a, SReal x);
 
| inline LReal Step(LReal a, LReal x);
| deprecated and renamed to
| inline Float64 StepEx(Float64 a, Float64 x);
 
> inline SReal Clamp(SReal a, SReal b, SReal x);
> inline LReal Clamp(LReal a, LReal b, LReal x);
> moved to maxon, renamed to maxon::ClampValue and switched parameter order
 
- inline SReal CutColor(const SReal& v);
- inline LReal CutColor(const LReal& v);
 
- inline Bool VectorEqual(const SReal& v1, const SReal& v2, SReal epsilon = SCO 0.01);
- inline Bool VectorEqual(const LReal& v1, const LReal& v2, LReal epsilon = 0.01);
 
- inline Float32 VectorSum(const SReal& v);
- inline Float64 VectorSum(const LReal& v);
 
- inline Float32 VectorGray(const SReal& v);
- inline Float64 VectorGray(const LReal& v);
 
- inline Float32 VectorAngle(const SReal& v1, const SReal& v2);
- inline Float64 VectorAngle(const LReal& v1, const LReal& v2);
 
- inline Float32 VectorMin(const SReal& v);
- inline Float64 VectorMin(const LReal& v);
 
- inline Float32 VectorMax(const SReal& v);
- inline Float64 VectorMax(const LReal& v);
 
 
struct VolumeData : public BaseVolumeData
{
+   Int32* GetUniqueID(RayObject* op, Int32& length);
 
+   Bool CentralDisplacePointUVGetBarycentric(RayObject *op, Int32& local_id, Int32& uu, Int32& vv, RayPolyWeight& bary, Bool& displaceQuad);
+   void CorrectLocalID(const RayObject* op, Int32& local_id);
 
+   Vector CalcBackTransformPoint();
 
+   Bool CalcIndirectPath(const Vector& point, const Vector& normal, const Vector& ray_in, const Vector& ray_out, Float& pdf_qmc, Float& pdf_area, Float& pdf_portal, Float& pdf_sky);
+   Bool CalcIndirectPath(VolumeData* sd, const Vector& dir, void* source, void* target);
 
+   Vector CalcRadiancePoly(RayRadianceObject* obj, SurfaceIntersection* si, Int32 poly, Int32 u, Int32 v, Bool back);
 
+   Float GetPhysicalCameraIntensity();
 
+   void SetPhysicalRayTime(Float time)
};

c4d_uuid.h

+ added header
 
+ class C4DUuid;

c4d_videopostdata.h

struct BaseVideoPostStruct
{
+   NetRenderDocumentContext* net;
+   Bool net_server;
};
 
 
+ VPBUFFER_BLENDCH
 
 
+ PLUGINFLAG_VIDEOPOST_ISRENDERER_NET
 
 
struct GlobalIlluminationInformation
{
+   Float radiance_intensity;
+   Float radiance_saturation;
+   Bool lightmapping_enabled;
+   Bool lightmapping_direct;
+   Int32 lightmapping_mode;
};
 
 
class VideoPostData : public NodeData
{
+   virtual Bool NetFrameInit(BaseVideoPost* node, BaseDocument* doc, RenderJob* job, Int32 assignedClients, const NetRenderData* renderData, MultipassBitmap* frameBmp, BaseThread* bt, Int32& realdepth);
+   virtual void NetFrameFree(BaseVideoPost* node);
+   virtual Bool NetFrameMessage(BaseVideoPost* node, const C4DUuid& remoteUuid, const NetRenderBuffer& data, NetRenderBuffer* result);
 
+   virtual Bool NetCreateBuffer(BaseVideoPost* node, VideoPostStruct* vps, Int32 x, Int32 y, Int32 sizex, Int32 sizey, Int32& id, Int32& subid);
};

customgui_kerning.h

+ added header
 
 
+ CUSTOMDATATYPE_KERNING
+ customgui_kerning.h
 
+ TEXTSPLINE_RESULTS
+ MSG_DESCRIPTION_KERNINGDATACHANGED
+ MSG_KERNING_GETGUIHELPER
 
+ TEXTSPLINE_RESULT_X
+ TEXTSPLINE_RESULT_Y
+ TEXTSPLINE_RESULT_Y_BASE
+ TEXTSPLINE_RESULT_HEIGHT_BASE
+ TEXTSPLINE_RESULT_WIDTH
+ TEXTSPLINE_RESULT_HEIGHT
 
 
+ struct customgui_kerning.h;
+ struct KerningTriState;
 
 
+ class KerningData : public CustomDataType;
 
+ class KerningCustomGui : public BaseCustomGui<CUSTOMGUI_KERNING>;
 
+ class KerningVpGuiHelper;
 
+ struct KerningGetGuiHelperMsg;
 
 
+ Kerning BlendKerning(const Kerning& k1, const Kerning& k2, Float mix);
+ Bool HandleKerningMessages(GeListNode* node, Int32 msgId, Int32 kerningDescID, Int32 textDescID, void* msgData, KerningVpGuiHelper* guihelper);

customgui_listview.h

enum
{
+   ID_TREEVIEW_CONTEXT_DISABLE
};
 
class TreeViewFunctions
{
+   virtual ~TreeViewFunctions();
};

customgui_splinecontrol.h

class SplineData : public CustomDataType
{
+   Bool SetKnot(Int32 l, const CustomSplineKnot& knot);
};

ge_autoptr.h

+ template <class TYPE> class AutoPtrArray;

ge_lmatrix.h

struct LMatrix
renamed to
struct Matrix64
{
|   LMatrix(const LVector& off_in, const LVector& v1_in, const LVector& v2_in, const LVector& v3_in);
|   changed to explicit constructor
|   explicit Matrix64(const Vector64& off_in, const Vector64& v1_in, const Vector64& v2_in, const Vector64& v3_in);
 
|   Matrix64(_DONTCONSTRUCT v);
|   changed to explicit constructor
|   explicit Matrix64(_DONTCONSTRUCT v);
 
+   explicit Matrix64(const Matrix32& m);
 
 
-   friend const LMatrix operator ! (const LMatrix& m);
-   SVector Mul(const SVector& v) const;
-   LVector Mul(const LVector& v) const;
-   SVector MulV(const SVector& v) const;
-   LVector MulV(const LVector& v) const;
-   friend const LVector operator ^ (const LVector& v, const LMatrix& m);
-   friend const LVector operator * (const LVector& v, const LMatrix& m);
-   friend const LVector operator * (const LMatrix& m, const LVector& v);
-   inline const SMatrix ToSM() const;
-   inline const LMatrix& ToLM() const;
-   inline const LMatrix& ToRM() const;
 
 
|   friend const LMatrix operator * (const LReal s, const LMatrix &m);
|   changed to
|   friend operator * (Float64 s, const Matrix64& m);
 
+   Matrix64 operator * (const Matrix64& m2) const;
+   Vector64 operator * (const Vector64& v) const;
+   Matrix64 operator * (Float64 s) const;
 
+   Vector64 TransformVector(const Vector64& v) const;
 
|   friend const LMatrix operator ! (const LMatrix &m)
|   changed to
|   friend const Matrix64 operator ~ (const Matrix64& m)
 
 
-   inline const Matrix32 ToSM() const;
-   inline const Matrix64 ToLM() const;
 
-   inline const Matrix32 ToRM() const;
-   inline const Matrix64 ToRM() const;
};
 
 
- inline const LVector & LVector::operator *= (const LMatrix &m);
- inline const LVector & LVector::operator ^= (const LMatrix &m);
 
- inline const LMatrix SMatrix::ToLM() const;
- inline const LMatrix SMatrix::ToRM() const;

ge_lvector.h

struct LVector
renamed to
struct Vector64
{
|   LVector(LReal ix, LReal iy, LReal iz)
|   changed to
|   explicit Vector64(Float64 ix, Float64 iy, Float64 iz)
|   constructor is explicit
 
|   LVector(_DONTCONSTRUCT v);
|   changed to
|   explicit Vector64(_DONTCONSTRUCT v)
|   constructor is explicit
 
+   explicit Vector64(const Vector32& v);
 
|   Vector64(Float64 in);
|   changed to
|   explicit Vector64(Float64 in);
|   constructor is explicit
 
 
-   LVector Dot(const SVector& v2) const;
-   LVector Dot(const LVector& v2) const;
-   LVector Cross(const LVector& v2) const;
-   inline const SVector ToSV() const;
-   inline const LVector& ToLV() const;
-   inline const LVector& ToRV() const;
-   friend Float64 operator * (const LVector& v1, const LVector& v2);
-   friend const LVector operator % (const LVector& v1, const LVector& v2);
-   inline const LVector& operator *= (const LMatrix& m);
-   inline const LVector& operator ^= (const LMatrix& m);
-   const LVector& operator ^= (const LVector& v);
-   friend const LVector operator ^ (const LVector& v1, const LVector& v2);
 
 
+   Bool IsZero() const;
+   Bool IsNotZero() const;
+   void SetZero();
 
+   Bool IsEqual(const Vector64& v2, const Float64& epsilon = 0.01) const;
+   Float64 GetAverage() const;
+   Float64 GetSum() const;
+   Float64 GetMin() const;
+   Float64 GetMax() const;
+   Vector64 Clamp01() const;
 
+   friend Float64 GetAngle(const Vector64& v1, const Vector64& v2);
 
 
|   LReal Dot(const SVector &v2) const;
|   LReal Dot(const LVector &v2) const;
|   changed to
|   friend Float64 Dot(const Vector64& v1, const Vector64& v2);
 
|   LVector Cross(const LVector &v2) const;
|   changed to
|   friend Vector64  Cross(const Vector64& v1, const Vector64& v2)
 
 
|   LReal GetLengthSquared(void) const;
|   renamed to
|   Float64  GetSquaredLength(void) const;
 
 
|   const LVector& operator ^= (const LVector &v);
|   vector componentwise multiplication changed to
|   const Vector64& operator *= (const Vector64& v);
 
|   friend const LVector operator ^ (const LVector &v1, const LVector &v2);
|   vector componentwise multiplication changed to
|   friend const Vector64 operator * (const Vector64& v1, const Vector64& v2);
 
 
|   LReal& operator [] (LONG l);
|   setter changed to
|   Float64& operator,operator[] (Int l);
 
|   const LReal& operator [] (LONG l) const;
|   getter changed to
|   const Float64& operator,operator[] (Int l) const;
};
 
 
- inline const LVector SVector::ToLV() const;
- inline const LVector SVector::ToRV() const;

ge_matrix.h

struct SMatrix
renamed to
struct Matrix32
{
|   SMatrix(const SVector& off_in, const SVector& v1_in, const SVector& v2_in, const SVector& v3_in);
|   changed to explicit constructor
|   explicit Matrix32(const Vector32& off_in, const Vector32& v1_in, const Vector32& v2_in, const Vector32& v3_in)
 
|   SMatrix(_DONTCONSTRUCT v);
|   changed to explicit constructor
|   explicit Matrix32(_DONTCONSTRUCT v);
 
+   explicit Matrix32(const Matrix64& v);
 
-   friend const SMatrix operator ! (const SMatrix& m);
-   SVector Mul(const SVector& v) const;
-   LVector Mul(const LVector& v) const;
-   SVector MulV(const SVector& v) const;
-   LVector MulV(const LVector& v) const;
-   friend const SVector operator ^ (const SVector& v, const SMatrix& m);
-   friend const SVector operator * (const SVector& v, const SMatrix& m);
-   inline const LMatrix ToLM() const;
-   inline const SMatrix& ToSM() const { return *this; }
-   inline const LMatrix ToRM() const;
 
 
-   friend const SMatrix operator * (const SMatrix &m1, const SMatrix &m2);
-   friend const SVector operator * (const SMatrix &m, const SVector &v);
 
|   friend const SMatrix operator * (const SReal s, const SMatrix &m);
|   changed to
|   friend Matrix32 operator * (Float32 s, const Matrix32& m);
 
 
+   Matrix32 operator * (const Matrix32& m2) const;
+   Vector32 operator * (const Vector32& v) const;
+   Matrix32 operator * (Float32 s) const;
 
 
+   Vector32 TransformVector(const Vector32& v) const;
 
 
|   friend const Matrix32 operator ! (const Matrix32 &m);
|   changed to
|   friend const Matrix32 operator ~ (const Matrix32& m);
};
 
 
- inline const SVector & SVector::operator *= (const SMatrix &m);

ge_prepass.h

+ enum RENDERJOBLIST;
 
+ enum MESSAGERESULT;
 
+ enum MACHINELIST;
 
+ enum VERIFICATIONBIT;
 
+ enum RENDERJOBCREATOR;
 
+ enum STATUSNETSTATE;
 
 
 
+ C4DUUID_SIZE_Define
 
 
+ FILTER_B3DNET
 
 
+ FILTER_DPX
 
+ DPX_PLANAR
 
 
> enum ASSETDATA_FLAG;
> moved from c4d_shader.h
 
 
enum RENDERRESULT
{
-   RENDERRESULT_MULTIGLREQUEST,
 
+   RENDERRESULT_NOMACHINE,
+   RENDERRESULT_PROJECTNOTFOUND,
+   RENDERRESULT_ERRORLOADINGPROJECT,
+   RENDERRESULT_NOOUTPUTSPECIFIED
};
 
 
+ enum CREATEJOBRESULT;
 
 
+ Marchigrass
 
+ Xreference
 
+ Tcrane
+ Tarchigrass
 
 
+ ID_MACHINE
+ ID_MACHINEGROUP
 
 
enum
{
+   WPREF_NET_NAME,
+   WPREF_NET_SHARE,
+   WPREF_NET_THREADCUSTOM,
+   WPREF_NET_RENDERTHREADS,
+   WPREF_NET_SECURITYTOKEN,
+   WPREF_NET_ALLOWRESTARTOFC4D,
+   WPREF_NET_SERVER_PORTNUMBER,
+   WPREF_NET_SERVER_REPOSITORYPATH,
+   WPREF_NET_USEBONJOUR,
+   WPREF_NET_USEENCRYPTION,
+   WPREF_NET_HANDLEWARNINGASERROR,
+   WPREF_NET_ABORTRENDERINGONCLIENTERROR,
+   WPREF_NET_PEERTOPEERASSETDISTRIBUTION,
+   WPREF_NET_REQUESTONDEMAND,
+   WPREF_NET_EXCLUDECLIENTONRENDERINGERROR,
+   WPREF_NET_RENDERINGTIMEOUT,
+   WPREF_NET_ENABLETEAMRENDER,
 
+   WPREF_NET_SHOWBUCKETMACHINECOLOR,
+   WPREF_NET_SHOWNAME,
+   WPREF_NET_SHOWICON,
+   WPREF_NET_SHOWINFO,
+   WPREF_NET_SHOWCHECKBOX,
+   WPREF_NET_SHOWADDRESS,
+   WPREF_NET_MACHINEICONSIZE
};
 
 
// VIEWCOLOR_AXIS_BAND
+ VIEWCOLOR_SPLINEHULL
+ VIEWCOLOR_TOOLHANDLE
+ VIEWCOLOR_ACTIVETOOLHANDLE
 
 
enum CHECKVALUEFORMAT
{
|   CHECKVALUEFORMAT_LONG
|   renamed to
|   CHECKVALUEFORMAT_INT
};
 
 
+ enum SAVEPROJECT;
 
 
enum THREADMODE
{
-   THREADMODE_BIND_TO_THREAD,
-   THREADMODE_RESERVED
}
 
 
enum FILEOPEN
{
+   FILEOPEN_SHAREDWRITE
};
 
 
+ enum LOCATION;
 
 
enum HYPERFILEVALUE
{
|   HYPERFILEVALUE_WORD
|   renamed to
|   HYPERFILEVALUE_INT16
 
|   HYPERFILEVALUE_UWORD
|   renamed to
|   HYPERFILEVALUE_UINT16
 
|   HYPERFILEVALUE_LONG
|   renamed to
|   HYPERFILEVALUE_INT32
 
|   HYPERFILEVALUE_ULONG
|   renamed to
|   HYPERFILEVALUE_UINT32
 
|   HYPERFILEVALUE_LLONG
|   renamed to
|   HYPERFILEVALUE_INT64
 
|   HYPERFILEVALUE_LULONG
|   renamed to
|   HYPERFILEVALUE_UINT64
 
|   HYPERFILEVALUE_REAL
|   renamed to
|   HYPERFILEVALUE_FLOAT
 
|   HYPERFILEVALUE_SREAL
|   renamed to
|   HYPERFILEVALUE_FLOAT32
 
|   HYPERFILEVALUE_LREAL
|   renamed to
|   HYPERFILEVALUE_FLOAT64
 
...
 
|   HYPERFILEVALUE_SVECTOR
|   renamed to
|   HYPERFILEVALUE_VECTOR32
 
|   HYPERFILEVALUE_SMATRIX
|   renamed to
|   HYPERFILEVALUE_MATRIX32
 
|   HYPERFILEVALUE_LVECTOR
|   renamed to
|   HYPERFILEVALUE_VECTOR64
 
|   HYPERFILEVALUE_LMATRIX
|   renamed to
|   HYPERFILEVALUE_MATRIX64
 
 
|   HYPERFILEVALUE_UWORD_ARRAY_EX
|   renamed to
|   HYPERFILEVALUE_UINT16_ARRAY_EX
 
 
+   HYPERFILEVALUE_UUID
};
 
 
 
enum RENDERFLAGS
{
+   RENDERFLAGS_BATCHRENDER
+   RENDERFLAGS_NET
};
 
 
+ enum WRITEMODE;
 
 
+ enum NETRENDERFLAGS;
 
 
enum CHECKISRUNNING
{
+   CHECKISRUNNING_EVENTSYSTEM>
};
 
 
enum IDENTIFYFILE
{
+    IDENTIFYFILE_PYTHON
};
 
 
enum VIDEOPOSTINFO
{
+   VIDEOPOSTINFO_NETFRAME
+   VIDEOPOSTINFO_NETRUNONSERVER
+   VIDEOPOSTINFO_NETCREATEBUFFER
};
 
+ VPAOShadingChain
 
 
| COFFEEEDITOR_SETMODE
| renamed to
| CODEEDITOR_SETMODE
 
| COFFEEEDITOR_GETSTRING
| renamed to
| CODEEDITOR_GETSTRING
 
| COFFEEEDITOR_SETSTRING
| renamed to
| CODEEDITOR_SETSTRING
 
| COFFEEEDITOR_COMPILE
| renamed to
| CODEEDITOR_COMPILE
 
| COFFEEEDITOR_GETERROR_RES
| renamed to
| CODEEDITOR_GETERROR_RES
 
| COFFEEEDITOR_GETERROR_STRING
| renamed to
| CODEEDITOR_GETERROR_STRING
 
| COFFEEEDITOR_GETERROR_LINE
| renamed to
| CODEEDITOR_GETERROR_LINE
 
| COFFEEEDITOR_GETERROR_POS
| renamed to
| CODEEDITOR_GETERROR_POS
 
| COFFEEEDITOR_EXECUTE
| renamed to
| CODEEDITOR_EXECUTE
 
 
+ CODEEDITOR_DISABLEUNDO
 
 
enum
{
|   LV_RES_LONG
|   renamed to
|   LV_RES_INT
};
 
 
enum DISPLAYFILTER
{
+   DISPLAYFILTER_GRADIENT
}
 
 
 
+ enum CINEMAINFO;
 
 
+ enum PROTOCOL;
+ enum PROXYTYPE;
+ enum RESOLVERESULT;
+ enum SERVERJOBLIST;
+ enum JOBCOMMAND;
+ enum RENDERTARGET;
+ enum JOBSTATE;
 
+ enum ZEROCONFMACHINESTATE;
+ enum ZEROCONFACTION;
+ enum ZEROCONFERROR;
 
+ enum EVENTJOBMESSAGE;
 
 
+ RENDERSETTING_STATICTAB_NET

ge_vector.h

struct SVector
renamed to
struct Vector32
{
|   SVector(SReal ix, SReal iy, SReal iz);
|   changed to
|   explicit Vector32(Float32 ix, Float32 iy, Float32 iz);
|   constructor is explicit
 
|   SVector(_DONTCONSTRUCT v);
|   changed to
|   explicit Vector32(_DONTCONSTRUCT v);
|   constructor is explicit
 
+   explicit Vector32(const Vector64& v);
 
|   SVector(SReal in);
|   changed to
|   explicit Vector32(Float32 in);
|   constructor is explicit
 
 
-   SReal Dot(const SVector& v2) const;
-   SVector Cross(const SVector& v2) const;
-   inline const LVector ToLV() const;
-   inline const SVector& ToSV() const;
-   inline const LVector ToRV() const;
-   friend SReal operator * (const SVector& v1, const SVector& v2);
-   friend const SVector operator % (const SVector& v1, const SVector& v2);
-   inline const SVector& operator *= (const SMatrix& m);
-   inline const SVector& operator ^= (const SMatrix& m);
-   const SVector& operator ^= (const SVector& v);
-   friend const SVector operator ^ (const SVector& v1, const SVector& v2);
 
 
+   Bool IsZero() const;
+   Bool IsNotZero() const;
+   void SetZero();
 
+   Bool IsEqual(const Vector32& v2, const Float32& epsilon = 0.01f) const;
 
+   Float32 GetAverage() const;
 
+   Float32 GetSum() const;
 
+   Float32 GetMin() const;
+   Float32 GetMax() const;
 
+   Vector32 Clamp01() const;
 
+   friend Float32 GetAngle(const Vector32& v1, const Vector32& v2);
 
|   SReal Dot(const SVector &v2) const;
|   changed to
|   friend Float32 Dot(const Vector32& v1, const Vector32& v2);
 
|   SVector Cross(const SVector &v2) const;
|   changed to
|   friend Vector32  Cross(const Vector32& v1, const Vector32& v2);
 
 
|   SReal GetLengthSquared(void) const;
|   renamed to
|   Float32  GetSquaredLength(void) const;
 
 
|   const SVector & operator ^= (const SVector &v);
|   vectors componentwise multiplication changed to
|   const Vector32& operator *= (const Vector32& v);
 
|   friend const Vector32 operator ^ (const Vector32 &v1, const Vector32 &v2);
|   vectors componentwise multiplication changed to
|   friend const Vector32 operator * (const Vector32& v1, const Vector32& v2);
 
 
|   SReal& operator [] (LONG l);
|   setter changed to
|   Float32& operator [] (Int l);
 
|   const Float32& operator [] (Int32 l) const;
|   getter changed to
|   const Float32& operator [] (Int l) const
};

gui.h

enum
{
+   BFM_STATUSBAR_NETTINT_COLOR,
+   BFM_STATUSBAR_NETPROGRESSON,
+   BFM_STATUSBAR_NETTXT,
+   BFM_STATUSBAR_NETPROGRESS,
+   BFM_STATUSBAR_NETPROGRESSSPIN,
};

lib_batchrender.h

enum
{
+   RM_WARNING
};
 
 
class BatchRender
{
+   Bool SetNetError(Int32 n, const String& machineName, const String& errorString, Bool isWarning);
 
+   void GetJsonJobs(PyList* list);
+   BaseBitmap* GetFrameBitmap(const C4DUuid& nodeUuid, const C4DUuid& frameUuid);
};

lib_big_integer.h

+ added header
 
 
+ BIG_INTEGER_LIB;
 
+ class BigInteger;

lib_ca.h

class CAMorph
{
+   BaseList2D *GetTarget(BaseDocument *doc);
};
 
 
class CAPoseMorphTag : public BaseTag
{
+   void SetActiveMorphIndex(Int32 index);
};

lib_clipmap.h

class GeClipMap
{
+   IMAGERESULT Init(const IconData& iconData);
+   added initialization with an IconData
};

lib_description.h

enum
{
|   DESC_UNIT_REAL
|   renamed to
|   DESC_UNIT_FLOAT
 
|   DESC_UNIT_LONG
|   renamed to
|   DESC_UNIT_INT
};

lib_hair.h

+ enum HAIR_MSG_DATA_FLAG;
+ enum HAIR_MSG_DATA_TYPE;
 
 
class HairPluginMessageData
{
+   HAIR_MSG_DATA_TYPE type;
+   BaseList2D *bl;
};

lib_iconcollection.h

> ICONFLAG_COPY
> ICONFLAG_OVERWRITE
> moved to
+ enum ICONFLAG
{
+   ICONFLAG_0,
+   ICONFLAG_2X
};
 
 
| Bool RegisterIcon(LONG lIconID, BaseBitmap *pBmp, LONG x = 0, LONG y = 0, LONG w = -1, LONG h = -1, LONG lFlags = 0);
| changed parameter lFlags type from LONG to ICONFLAG
| Bool RegisterIcon(Int32 lIconID, BaseBitmap *pBmp, Int32 x = 0, Int32 y = 0, Int32 w = -1, Int32 h = -1, ICONFLAG lFlags = ICONFLAG_0);
 
| Bool RegisterIcon(LONG lIconID, Filename fn, LONG x = 0, LONG y = 0, LONG w = -1, LONG h = -1, LONG lFlags = 0);
| changed parameter lFlags type from LONG to ICONFLAG
| Bool RegisterIcon(Int32 lIconID, Filename fn, Int32 x = 0, Int32 y = 0, Int32 w = -1, Int32 h = -1, ICONFLAG lFlags = ICONFLAG_0);

lib_intersect.h

+ added header
 
 
+ LIBRARY_INTERSECT;
 
+ enum INTERSECTTYPE;
 
+ struct IntersectHitData;
 
+ class IIntersect;

lib_net.h

+ added header
 
 
+ MSG_UPDATEDMACHINE
+ MSG_ADDEDMACHINE
+ MSG_REMOVEDMACHINE
 
+ NET_SERVICESTATECHANGE
 
 
+ MSG_NETRENDER_GETSTATE
+ MSG_NETRENDER_SECURITYTOKENCHANGED
+ MSG_NETRENDER_INFORMABOUTUNVERIFICATION
+ MSG_NETRENDER_RESTART
+ MSG_NETRENDER_PING
 
+ MSG_NETRENDER_BUCKET_INFO
+ MSG_NETRENDER_BUCKET_INDEX
+ MSG_NETRENDER_BUCKET_STARTED
+ MSG_NETRENDER_BUCKET_FINISHED
+ MSG_NETRENDER_CACHE_GET_CACHE
+ MSG_NETRENDER_CACHE_GET_TASK
+ MSG_NETRENDER_CACHE_SEND_TASK
+ MSG_NETRENDER_CACHE_PROGRESS
+ MSG_NETRENDER_CACHE_PREPASS
 
+ MSG_NETRENDER_ANIMATION_RANGE
+   CONTAINER_JOBUUID
+   CONTAINER_RANGE_AVAILABLE
+   CONTAINER_RANGE_FROM
+   CONTAINER_RANGE_TO
 
+ MSG_NETRENDER_WENTONLINE
+   MSG_NETRENDER_WENTONLINE_NEWPORT
+   MSG_NETRENDER_WENTONLINE_RESULT_VERIFIESME
+   MSG_NETRENDER_WENTONLINE_RESULT_SHARED
 
+ MSG_NETRENDER_REDISTRIBUTED
+ MSG_NETRENDER_REDISTRIBUTED_JOBUUID
 
+ MSG_NETRENDER_SENDSTATE
+   MSG_NETRENDER_SENDSTATE_STATE
+   MSG_NETRENDER_SENDSTATE_COUNTER
+   MSG_NETRENDER_SENDSTATE_SERVERUUID
 
+ MSG_NETRENDER_MACHINENAMECHANGED
+   MSG_NETRENDER_MACHINENAMECHANGED_NAME
 
+ MSG_NETRENDER_SENDERROR
+   MSG_NETRENDER_SENDERROR_UUID
+   MSG_NETRENDER_SENDERROR_MESSAGE
+   MSG_NETRENDER_SENDERROR_ISWARNING
+   MSG_NETRENDER_SENDERROR_FRAMENUMBER
 
+ MSG_NETRENDER_RESTART
 
+ MSG_NETRENDER_PING
 
+ ID_GLOBALMACHINELIST
 
+ MSG_NETRENDER_PORTCHANGED
+   MSG_NETRENDER_PORTCHANGED_PORT
 
 
+ ID_GLOBALMACHINELIST
 
 
+ class Task;
 
+ struct NetRenderData;
 
 
+ Bool IsNetRenderInstalled();
 
 
+ struct NetRenderBuffer;
+ struct NetRenderDocumentContext;
 
+ class MachineGroup : public BaseList2D;
+ class Machine : public BaseList2D;
+ class Client : public BaseList2D;
+ class Server : public BaseList2D;
 
+ class RenderJob : public BaseList2D;
 
+ class NetService;
 
+ class Asset : public BaseList2D;
 
+ class UserPool;
 
 
+ NetRenderService* GetGlobalNetRenderService();
 
+ String GetMachineDescription(NetRenderService* service, Machine* m);
+ String VerificationBitToString(VERIFICATIONBIT state);
+ String JobCommandToString(JOBCOMMAND jobCommand);
+ String GetDebugStringOfMachine(Machine* m);
 
+ Bool NetSpecialEventAdd(NetRenderService* service, const C4DUuid& remoteUuid, const BaseContainer& msg, Bool targetMightBeMarkedAsOffline = false);
+ Bool NetGeSyncMessage(NetRenderService* service, const C4DUuid& remoteUuid, const BaseContainer& msg, BaseContainer& result, BaseThread* bt = nullptr, Bool forceConnect = false);
+ Bool NetSendData(NetRenderService* service, const C4DUuid& remoteUuid, NetRenderBuffer *data, NetRenderBuffer *result, BaseThread* bt = nullptr);
 
+ Bool NetRenderCacheGet(NetRenderDocumentContext* context, Bool isServer, Int32 cacheID, void* &data, Int32 &size);
+ Bool NetRenderCacheGetTask(NetRenderDocumentContext* context, Bool isServer, Int32 cacheID, Int32 &taskID, Int32 &taskSubdivisions);
+ Bool NetRenderCacheSendTask(NetRenderDocumentContext* context, Bool isServer, Int32 cacheID, Int32 taskID, void *data, Int32 size, Bool progress);
+ Bool NetRenderCacheProgress(NetRenderDocumentContext* context, Int32 cacheID, Int32 lastIndex, void* &data, Int32 &size, BaseThread* thread);
+ Bool NetRenderCachePrepass(NetRenderDocumentContext* context, Int32 cacheID, Bool &completed);
+ Bool NetRenderGetFileFromServer(NetRenderService* context, const Filename& assetName, const Filename& destination, BaseThread* bt = nullptr);

lib_pictureviewer.h

+ struct PvForceShowStatusBar;
 
+ MSG_PICTUREVIEWER_FORCESHOWSTATUSBAR
 
+ struct FinalizeTmpData;
 
class PictureViewer
{
+   Bool OverwriteBitmap(GeListNode *node, BaseBitmap* bmp, STEREOTYPE stereotype, Int32 lLastStream);
 
+   void SetIsNet(GeListNode *pNode, Bool isNet);
};

lib_prefs.h

+ PREFS_PRI_NET

lib_py.h

+ C4DPL_PYENDPLUGINS
 
class PythonLibrary
{
|   Bool SetLONG(PythonBase *base, const String &name, const LONG value);
|   renamed to
|   Bool SetInt32(PythonBase *base, const String &name, const Int32 value);
 
|   Bool SetLLONG(PythonBase *base, const String &name, const LLONG value);
|   renamed to
|   Bool SetInt64(PythonBase *base, const String &name, const Int64 value);
 
|   Bool SetReal(PythonBase *base, const String &name, const Rea; value);
|   renamed to
|   Bool SetFloat(PythonBase *base, const String &name, const Float value);
 
|   Bool GetLONG(PythonBase *base, _PyObject *op, LONG &value);
|   renamed to
|   Bool GetInt32(PythonBase *base, _PyObject *op, Int32 &value);
 
|   Bool GetLLONG(PythonBase *base, _PyObject *op, LLONG &value);
|   renamed to
|   Bool GetInt64(PythonBase *base, _PyObject *op, Int64 &value);
 
|   Bool GetReal(PythonBase *base, _PyObject *op, Real &value);
|   renamed to
|   Bool GetFloat(PythonBase *base, _PyObject *op, Float &value);
 
 
|   _PyObject *ReturnPyLONG(LONG value);
|   renamed to
|   _PyObject *ReturnPyInt32(Int32 value);
 
|   _PyObject *ReturnPyVLONG(VLONG value);
|   renamed to
|   _PyObject *ReturnPyInt(Int value);
 
|   _PyObject *ReturnPyVULONG(VULONG value);
|   renamed to
|   _PyObject *ReturnPyUInt(UInt value);
 
|   _PyObject *ReturnPyLLONG(LLONG value);
|   renamed to
|   _PyObject *ReturnPyInt64(Int64 value);
 
|   _PyObject *ReturnPyReal(Real value);
|   renamed to
|   _PyObject *ReturnPyFloat(Float value);
 
+   Bool PluginMessage(_PyObject* func, Int32 id, void* data);
};
 
 
class PyTuple
{
|   Bool AppendLong(LONG p);
|   renamed to
|   Bool AppendInt32(Int32 p);
 
|   Bool AppendReal(Real p);
|   renamed to
|   Bool AppendFloat(Float p);
 
-   Bool Init(Int32 s);
-   void Free();
 
+   static PyTuple* Alloc(Int32 s);
+   static void Free(PyTuple*& p);
};
 
+ class PyDict;
+ class PyList;
 
 
class GePythonGIL
{
+   Bool Run(const String& code);
 
|   Bool SetReal(const String &name, Real v);
|   renamed to
|   Bool SetFloat(const String &name, Float v);
 
|   Bool SetLong(const String &name, LONG v);
|   renamed to
|   Bool SetInt32(const String &name, Int32 v);
 
|   Bool GetLong(const String &name, LONG &v);
|   renamed to
|   Bool GetInt32(const String &name, Int32 &v);
 
+   Bool PluginMessage(Int32 id, void* data);
};

lib_sculpt.h

+ SCULPT_LAYERSYSTEM_ID
+ SCULPT_BAKESETTINGS
 
 
class SculptLayerData : public BaseList2D
{
+   void ClearMask();
+   void ClearLayer();
 
+   void InitializeAllPointData();
+   void InitializeAllMaskData();
 
+   void TouchPointForUndo(Int32 index);
+   void TouchMaskForUndo(Int32 index);
};
 
 
class SculptLayer : public SculptLayerBase
{
|   SculptLayerData *GetSculptLayerData();
|   renamed to
|   SculptLayerData *GetFirstSculptLayerData();
 
+   SculptLayerData *GetCurrentSculptLayerData();
 
+   void ClearMask();
+   void ClearLayer();
 
+   void InitializeAllPointData();
+   void InitializeAllMaskData();
 
+   void TouchPointForUndo(Int32 index);
+   void TouchMaskForUndo(Int32 index);
};
 
 
+ class SculptLayerSystem : public BaseList2D;
 
 
struct SculptHitData
{
+   Bool backface;
};
 
 
class SculptObject : public BaseList2D
{
|   Bool Hit(BaseDraw* bd, Real mx, Real my, SculptHitData &hitData);
|   changed to
|   Bool Hit(BaseDraw* bd, Float mx, Float my, Bool backfaces, SculptHitData &hitData);
|   added 'backfaces' parameter
 
|   Bool Hit(const Vector &rayp, const Vector &rayv, SculptHitData  &hitData);
|   changed to
|   Bool Hit(const Vector &rayp, const Vector &rayv, Bool backfaces, SculptHitData  &hitData);
|   added 'backfaces' parameter
 
+   Int32 GetPointCount();
 
+   const Vector32 *GetVertexNormals();
 
+   const Vector *GetPointR();
+   Vector *GetPointW();
 
 
+   SculptLayerSystem *GetLayerSystem();
 
+   void OffsetPoint(SculptLayer *pLayer, Vector *pPoints, Bool useMask, Float strength, Int32 index, const Vector &offset, Bool respectLayerStrength = false);
+   void OffsetPreviewPoint(SculptLayer *pLayer, Bool useMask, Float strength, Int32 index, const Vector &offset, Bool respectLayerStrength = false);
+   void SetPreviewPoint(SculptLayer *pLayer, Bool useMask, Float strength, Int32 index, const Vector &offset, Bool respectLayerStrength = false);
 
+   void StartUndo();
+   void EndUndo();
 
+   void Smooth(Int32 count, Bool respectMask);
};
 
 
| SculptObject *GetSelectedSculptObject(BaseDocument *doc);
| changed to
| SculptObject *GetSelectedSculptObject(BaseDocument *doc, Bool includeHiddenObjects = false);
| added includeHiddenObjects parameter
 
| SculptObject *MakeSculptObject(PolygonObject *poly, BaseDocument *doc);
| changed to
| SculptObject *MakeSculptObject(PolygonObject *poly, BaseDocument *doc, Bool addUndo = false);
| added addUndo parameter
 
+ Bool IsObjectEnabled(BaseObject *pObject);
+ void EnsureSculptObjectReady(PolygonObject *obj, BaseDocument *doc);

lib_sculptbrush.h

+ added header
 
 
+ enum FIRSTHITPPOINTTYPE;
 
+ enum SCULPTBRUSHMODE;
+ enum SCULPTBRUSHDATATYPE;
 
+ enum OVERRIDE;
 
+ enum SAMPLEMODE;
 
+ enum SCULPTOFFSETFLAGS;
 
 
+ LIBRARY_SCULPTBRUSH
 
 
+ struct BrushPointData;
+ struct BrushPolyData;
 
+ class BrushDabData;
 
+ class CustomSculptBrushBase;
 
+ class SculptBrushParams;
 
+ class SculptBrushToolData : public DescriptionToolData;
 
 
+ Bool IsSculptBrush(Int32 toolID);
+ SculptBrushToolData *GetSelectedSculptBrush(BaseDocument *doc);

lib_secure_random.h

+ added header
 
 
+ SECURE_RANDOM_LIB
 
+ struct SecureRandomProvider;
+ class SecureRandom;

matrix4.h

| inline SMatrix4 RMtoSM4(const Matrix4 m);
| changed to
| inline Matrix4d32 RMtoSM4(const Matrix4d& m);
| parameter m is now passed as reference
 
| inline LMatrix4 RMtoLM4(const Matrix4 m);
| changed to
| inline Matrix4d64 RMtoSM4(const Matrix4d& m);
| parameter m is now passed as reference

operatingsystem.h

| typedef Bool ZeroConfBrowserCallback(const String& serviceName, Int32 lInterface, ZEROCONFMACHINESTATE state, Bool moreComing, ZEROCONFERROR error, void *context);
| changed to
| typedef ZEROCONFACTION ZeroConfBrowserCallback(const String& serviceName, Int32 lInterface, ZEROCONFMACHINESTATE state, Bool moreComing, ZEROCONFERROR error, void *context);
| return type changed from 'Bool' to 'ZEROCONFACTION'
 
| typedef void ZeroConfBrowserResolvedCallback(const String& serviceName, const String& fullyQualifiedDomainName, Int32 port, Int32 lInterface, const String* keys, const String* values, Int32 count, ZEROCONFERROR error, void* context);
| changed to
| typedef void ZeroConfBrowserResolvedCallback(const String& serviceName, const String& fullyQualifiedDomainName, Int port, Int32 lInterface, Bool txtRecordUpdate, const String* keys, const String* values, Int32 count, ZEROCONFERROR error, void* context);
 
 
| typedef void ProgressHook(Float p, RENDERPROGRESSTYPE progress_type, void *private_data);
| changed to
| typedef void ProgressHook(Float p, RENDERPROGRESSTYPE progress_type, void* context);
 
 
+ typedef void WriteProgressHook(WRITEMODE mode, BaseBitmap* bmp, const Filename &fn, Bool mainImage, Int32 frame, Int32 renderTime, Int32 streamnum, const String& streamname, void* context);
 
 
| typedef GeData CoffeeEditorCallback(BaseList2D *obj, const BaseContainer &msg);
| changed to
| typedef GeData CodeEditorCallback(BaseList2D *obj, const BaseContainer &msg);
 
 
+ typedef const void* ConstUVWHandle;
+ typedef const void* ConstNormalHandle;
 
struct UVWStruct
{
+   Vector& operator[] (Int32 index);
};
 
struct NormalStruct
{
+   Vector& operator[] (Int32 index);
};
 
 
struct IconData
{
+   BaseBitmap* GetClonePart() const;
 
+   BaseBitmap* GetGuiScalePart() const;
+   Int32 GetGuiW() const;
+   Int32 GetGuiH() const;
};
 
 
+ Bool GetAllAssetsNet(BaseDocument *doc, Bool allowDialogs, maxon::BaseArray<AssetEntry>& assets, Filename& lastPath, Bool isNet);
+ RENDERRESULT RenderDocumentNet(BaseDocument *doc, WriteProgressHook *wprog, ProgressHook *prog, void *private_data, BaseBitmap *bmp, const BaseContainer *rdata, RENDERFLAGS renderflags, BaseThread *th, void *data, const maxon::BaseArray<Bool>* renderTask);
/// private

vector4.h

template <class TYPE> class _Vector4
{
-   friend const TYPE operator * (const _Vector4 &a, const _Vector4 &b);
 
-   friend const Vector4d Mix(const _Vector4 &a, const _Vector4 &b, TYPE t);
};

API Changes in R15.057

c4d_basematerial.h

class BaseMaterial
{
+   RayIllumination* GetRayIllumination()
 
+   INITRENDERRESULT InitTextures(const InitRenderStruct &irs);
+   void UnlockTextures();
};

c4d_falloffdata.h

struct FalloffDataData
{
|   Matrix mat;
|   renamed to
|   Matrix _mat;
 
|   Matrix imat;
|   renamed to
|   Matrix _imat;
|   renamed to
 
|   Float falloff;
|   renamed to
|   Float _falloff;
 
|   Float scale;
|   renamed to
|   Float _scale;
 
|   Float strength;
|   renamed to
|   Float _strength;
 
|   Vector size;
|   renamed to
|   Vector _size;
 
|   Bool invert;
|   renamed to
|   Bool _invert;
 
|   Bool clamped;
|   renamed to
|   Bool _clamped;
 
|   Bool visible;
|   renamed to
|   Bool _visible;
 
|   Bool usespline;
|   renamed to
|   Bool _useSpline;
 
|   Matrix nodemat;
|   renamed to
|   Matrix _nodemat;
 
|   Matrix inodemat;
|   renamed to
|   Matrix _inverseNodeMat;
 
|   Vector offset;
|   renamed to
|   Vector _offset;
 
|   Int32 axis;
|   renamed to
|   Int32 _axis;
 
|   Float slice;
|   renamed to
|   Float _slice;
 
|   Float torusRadius;
|   renamed to
|   Float _torusRadius;
 
|   Int32 function;
|   renamed to
|   Int32 _function;
 
|   Float radius;
|   renamed to
|   Float _radius;
 
|   Float iradius;
|   renamed to
|   Float _inverseRadius;
 
|   Bool spherical;
|   renamed to
|   Bool _spherical;
 
|   Float ifalloff;
|   renamed to
|   Float _inverseFalloff;
 
|   void* userdata;
|   renamed to
|   void* _userData;
};

c4d_help.h

+ added header
 
+ Bool PluginHelpDelegate(const String& opType, const String& baseType, const String& group, const String& property);
+ Bool RegisterPluginHelpDelegate(Int32 pluginId, PluginHelpDelegate delegate);
+ void OpenHelpBrowser(const String& opType, const String& baseType, const String& group, const String& property);
 
+ void FreeHelpDelegates();
/// Internal

c4d_painter.h

struct TempUVHandle
{
+   BaseSelect* GetPolyHid();
 
+   Bool SetUVWFromTextureView(UVWStruct* uvw, Bool ignoreHidden, Bool ignoreUnselected, Bool autoSelectAll);
};
 
 
+ GETACTIVEUVSET_POLYHIDDEN

c4d_shader.h

+ struct RayIllumination

ge_prepass.h

+ Tsculptnormals
/// Private

lib_batchrender.h

enum
{
|   RM_WARNING
|   renamed to
|   RM_PROGRESS_WITH_WARNING
}
 
class BatchRender
{
+   Bool SetNetError(const C4DUuid& uuid, const String& machineName, const String& errorString, Bool isWarning);
};

lib_ca.h

class CAMorph
{
+   void SetStrength(CAPoseMorphTag *tag, BaseDocument *doc, BaseList2D *bl);
+   void SetStrength(Float strength);
+   Float GetStrength();
};
 
class CAPoseMorphTag
{
|   void UpdateMorphs();
|   changed to
|   void UpdateMorphs(BaseDocument *doc = nullptr);
|   added optional parameter doc
};

lib_net.h

+ MSG_NETRENDER_MACHINESHARED
+ MSG_NETRENDER_MACHINESHARED_ON
 
| Bool NetRenderGetFileFromServer(NetRenderService* context, const Filename& assetName, const Filename& destination, BaseThread* bt = nullptr);
| changed to
| Bool NetRenderGetFileFromServer(NetRenderService* context, const Filename& source, const Filename& destination, BaseThread* bt = nullptr);
| parameter assetName renamed to source