Primitive Data Types Manual (Classic)

About

Primitive data types are the building blocks for data stored within Cinema 4D. These data types are typically based on the standard data types of C++ and are available in a 32 and 64 bit version.

Note
To perform mathematical operations using these data types use the build-in functions, see Mathematical Functions Manual (Classic).
Warning
An overview over MAXON API primitive data types can be found here: Basic Data Types.
// This example reads the "Fillet" settings of the selected Cube object
// and writes them into a HyperFile.
Bool doFillet = false;
Float filletRadius = 20.0;
Int32 filletSubidivision = 5;
// get parameters
GeData data;
// read the "Fillet" parameter
if (!cube->GetParameter(ConstDescID(DescLevel(PRIM_CUBE_DOFILLET)), data, DESCFLAGS_GET::NONE))
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
doFillet = data.GetBool();
// read the "Fillet Radius" parameter
if (!cube->GetParameter(ConstDescID(DescLevel(PRIM_CUBE_FRAD)), data, DESCFLAGS_GET::NONE))
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
filletRadius = data.GetFloat();
// read the "Fillet Subdivision" parameter
if (!cube->GetParameter(ConstDescID(DescLevel(PRIM_CUBE_SUBF)), data, DESCFLAGS_GET::NONE))
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
filletSubidivision = data.GetInt32();
// save to HyperFile
if (hyperFile == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// open the HyperFile to write
if (!hyperFile->Open('cube', filename, FILEOPEN::WRITE, FILEDIALOG::ANY))
return maxon::IoError(MAXON_SOURCE_LOCATION, MaxonConvert(filename, MAXONCONVERTMODE::NONE), "Could not open file."_s);
hyperFile->WriteBool(doFillet);
hyperFile->WriteFloat(filletRadius);
hyperFile->WriteInt32(filletSubidivision);
hyperFile->Close();
PyCompilerFlags const char * filename
Definition: ast.h:15
maxon::Url MaxonConvert(const Filename &fn, MAXONCONVERTMODE convertMode)
@ NONE
No check if file exists under case-sensitive drives.
Definition: ge_autoptr.h:37
Definition: c4d_gedata.h:83
Bool GetBool() const
Definition: c4d_gedata.h:450
Int32 GetInt32() const
Definition: c4d_gedata.h:456
Float GetFloat() const
Definition: c4d_gedata.h:468
maxon::Bool Bool
Definition: ge_sys_math.h:51
maxon::Int32 Int32
Definition: ge_sys_math.h:56
maxon::Float Float
Definition: ge_sys_math.h:62
@ ANY
Show an error dialog for any error.
#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67
#define ConstDescID(...)
Definition: lib_description.h:594
@ PRIM_CUBE_DOFILLET
Definition: ocube.h:13
@ PRIM_CUBE_FRAD
Definition: ocube.h:11
@ PRIM_CUBE_SUBF
Definition: ocube.h:12
Represents a level within a DescID.
Definition: lib_description.h:298

Bool

Boolean values are used for logical operations:

  • Bool: Defined as int.

Access

Bool variables can be created on demand or can be obtained from other entities.

Access Bool values stored in a BaseContainer:

See also BaseContainer Manual.

Access Bool values stored in a GeData object (GeData type is DA_LONG):

See also GeData Manual.

// This example stores and reads a Boolean value in the GeData object.
GeData data;
data.SetInt32(false);
// Boolean values are internally stored as integers
if (data.GetType() == DA_LONG)
{
// get Boolean value
if (data.GetBool())
ApplicationOutput("is true");
else
ApplicationOutput("is false");
}
void SetInt32(Int32 v)
Definition: c4d_gedata.h:645
Int32 GetType() const
Definition: c4d_gedata.h:436
@ DA_LONG
Int32.
Definition: c4d_gedata.h:40
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:204

Disc I/O

A Bool value can be stored in a BaseFile or a HyperFile:

See also BaseFile Manual on Bool and HyperFile Manual on Bool.

Char

A character variable contains a single symbol and is typically the smallest piece of memory.

  • Char: Signed 8 bit character, defined as char.
  • UChar: Unsigned 8 bit character, defined as unsigned char.
  • Utf16Char: Defined as UInt16.
  • Utf32Char: Defined as UInt32.
// This example converts the given String into a C-String to use it with the standard library.
const String string { "foobar" };
// convert to c string and insert into std string.
Char* cstring = string.GetCStringCopy();
std::string stdString { cstring };
DeleteMem(cstring);
PyObject * string
Definition: asdl.h:6
Definition: c4d_string.h:41
Char * GetCStringCopy(STRINGENCODING type=STRINGENCODING::XBIT) const
maxon::Char Char
Definition: ge_sys_math.h:52
void DeleteMem(T *&p)
Definition: defaultallocator.h:257

Disc I/O

A character can be stored in a BaseFile or HyperFile:

Note
To read and write Utf16Char and Utf32Char use BaseFile::ReadBytes() and BaseFile::WriteBytes().

See also BaseFile Manual on Char and HyperFile Manual on Char.

Integer

Integer variables contain whole numbers. Both signed and unsigned variations are available, both in 16, 32 and 64 bit.

  • Int16: Defined as short int.
  • UInt16: Defined as unsigned short int.
  • Int32: Defined as signed int.
  • UInt32: Defined as unsigned int.
  • Int64: Defined as signed long long.
  • UInt64: Defined as unsigned long long.
  • Int: Defined as Int64.
  • UInt: Defined as UInt64.
Note
If larger integer numbers are needed the class maxon::BigInteger can be used.

Access

Integer values can be created by casting them from float values. To do this safely these macros should be used:

Warning
Never try to cast an integer pointer into a float pointer or vice versa.
// This example performs a float point operation and safely converts the result to an integer.
const Float32 percentage = 0.23f;
const Int32 width = 1280;
const Float32 pos = Float32(width) * percentage;
const Int32 pixel = SAFEINT32(pos);
static String IntToString(Int32 v)
Definition: c4d_string.h:497
void Py_ssize_t * pos
Definition: dictobject.h:50
maxon::Float32 Float32
Definition: ge_sys_math.h:64
Int32 SAFEINT32(Float32 x)
Definition: apibasemath.h:275
unsigned long Py_ssize_t width
Definition: pycore_traceback.h:88

Integer variables can be obtained from other entities.

Access integer values stored in a BaseContainer:

See also BaseContainer Manual.

Access Int32 or Int64 values stored in a GeData object (GeData type is DA_LONG or DA_LLONG):

See also GeData Manual.

String objects can be parsed to get the numeric value represented by the string:

See also String Manual (Classic).

// This example converts a string into an integer number.
const String bottles = "99 bottles of beer on the wall";
const String number = bottles.Left(2);
const Int32 numberOfBottles = number.ToInt32(nullptr);
Int32 ToInt32(Bool *error) const
Definition: c4d_string.h:600
String Left(Int count) const
Definition: c4d_string.h:413

Convert

To display them in the GUI, integer numbers also can be converted to String objects:

See also String Manual (Classic).

// This example prints the number of selected objects to the console.
if (selection == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
doc->GetActiveObjects(selection, GETACTIVEOBJECTFLAGS::NONE);
const Int32 selCount = selection->GetCount();
ApplicationOutput(String::IntToString(selCount) + " object(s) selected");
const char * doc
Definition: pyerrors.h:226

Disc I/O

An integer value can be stored in a BaseFile or a HyperFile:

See also BaseFile Manual on Integer and HyperFile Manual on Integer.

Float

Floating point numbers present rational numbers with limited precision. Variations are available in 32 and 64 bit.

Access

Floating point variables can be obtained from other entities.

Access float values stored in a BaseContainer:

See also BaseContainer Manual.

Access float values stored in a GeData object (GeData type is DA_REAL):

See also GeData Manual.

Of course it is also possible to cast integer types into float values. Just be aware of the limited precision of different float formats.

Warning
Never try to cast an integer pointer into a float pointer or vice versa.

String objects can be parsed to get the numeric value represented by the string:

Compare

Since floating point values are only stored with limited precision they cannot represent every value perfectly. This is especially critical when it is needed to compare two floating point values:

// This example compares the result of a float operation with a given float value.
const Float32 x = 0.1f;
const Float32 y = 0.2f;
const Float32 reference = 0.3f;
const Float32 sum = x + y;
// compare float values
if (CompareFloatTolerant(sum, reference))
ApplicationOutput("The float values are really close to each other.");
PyObject * x
Definition: bytesobject.h:38
Bool CompareFloatTolerant(Float32 a, Float32 b)

Convert

To display them in the GUI, floating point numbers also can be converted to String objects:

// This example converts the given float value to a String with two digits after the comma.
const Float32 value = 123.456f;
PyObject * value
Definition: abstract.h:715
static String FloatToString(Float32 v, Int32 vvk=-1, Int32 nnk=-3)
Definition: c4d_string.h:531

Disc I/O

A floating point value can be stored in a BaseFile or a HyperFile:

See also BaseFile Manual on Float and HyperFile Manual on Float.

Further Reading