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
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
doFillet = data.GetBool();
// read the "Fillet Radius" parameter
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
filletRadius = data.GetFloat();
// read the "Fillet Subdivision" parameter
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();

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");
}

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);

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);

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);

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);
const Int32 selCount = selection->GetCount();
ApplicationOutput(String::IntToString(selCount) + " object(s) selected");

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.");

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;
ApplicationOutput("Value: " + String::FloatToString(value, -1, 2));

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