LoggerInterface Manual


The logger interface allows to create new custom loggers for specific tasks and to access existing loggers. Loggers are presented in the "Console" window in Cinema 4D and registered at the maxon::Loggers registry.

Messages can be sent to the default logger using ApplicationOutput().

Custom Loggers

A new custom logger can be created with maxon::LoggerRef::Create() and is then registered at maxon::Loggers. A logger type defines the target of the logger (see Logger Types).

A custom logger is configured with:

// This example creates a new custom logger and adds it to the registered loggers.
// g_exampleLogger is a maxon::LoggerRef instance.
// define logger ID
const maxon::Id loggerID { "net.maxonexample.logger" };
// check if a logger with that ID already exists
if (!maxon::Loggers::Get(loggerID))
// create the new logger and store it in a global variable for later access
// make sure to set this object to nullptr when Cinema shuts down
iferr (g_exampleLogger = maxon::LoggerRef::Create())
// if the logger could not be created, use the default logger instead
g_exampleLogger = maxon::Loggers::Default();
// if the logger could be created
// add the logger type "Application" to display logged messages in the "Console" window
g_exampleLogger.AddLoggerType(maxon::TARGETAUDIENCE::ALL, maxon::LoggerTypes::Application()) iferr_return;
// define logger name
g_exampleLogger.SetName("Example Logger"_s);
// insert the logger in the "Loggers" registry
maxon::Loggers::Insert(loggerID, g_exampleLogger) iferr_return;
// this message must be send to update the console window
const maxon::Int32 BFM_REBUILDCONSOLETREE = 334295845;
void SpecialEventAdd(Int32 messageid, UInt p1=0, UInt p2=0)
Definition: apibaseid.h:253
int32_t Int32
32 bit signed integer datatype.
Definition: apibase.h:176
static auto Create(ARGS &&... args)
Definition: apibase.h:2750
#define iferr(...)
Definition: errorbase.h:388
const Class< R > & Get(const Id &cls)
Definition: objectbase.h:2073
#define iferr_return
Definition: resultbase.h:1465
// This example shows how to free the logger reference.
static void FreeExampleLogger()
g_exampleLogger = nullptr; // reference must be freed
// make sure to also remove the entry of your logger from Loggers.
maxon::Loggers::Erase(maxon::Id { "net.maxonexample.logger" }) iferr_ignore("");
MAXON_INITIALIZATION(nullptr, FreeExampleLogger);
Definition: module.h:785
#define iferr_ignore(...)
Definition: resultbase.h:1430

Using Custom Loggers

A message is sent to a custom logger using the Write() function:

// This example writes a message to a custom logger.
// write to a custom logger referenced in g_exampleLogger
// or write to the logger by getting the logger using the logger ID
// get logger
const maxon::Id loggerId { "net.maxonexample.logger" };
const maxon::LoggerRef logger = maxon::Loggers::Get(loggerId);
Definition: memoryallocationbase.h:67

Built-In Loggers

All existing loggers are registered at maxon::Loggers. These three loggers are there for public use:

  • maxon::Loggers::Default: The default logger (published object for direct use).
  • maxon::ID_LOGGER_PYTHON: The Python logger's ID, defined in python.framework, cpython.h.
  • maxon::Loggers::Process: The IDE console logger (published object for direct use).
The default logger is used with ApplicationOutput().
// This example sends a message to the default logger.
ApplicationOutput("Some Message."_s);
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:210

Logger Types

A logger type implements the actual processing of a given message e.g. if that message is displayed in the GUI or written to a file.

Logger types are based on maxon::LoggerTypeInterface:

// This example adds an observer to the given logger. This observer
// will be called if a message is sent to that logger.
for (const auto& loggerTypeAudience : logger.GetLoggerTypes())
const maxon::LoggerTypeRef loggerType = loggerTypeAudience.GetFirst(); // get first element of the pair
loggerType.ObservableLoggerNotify().AddObserver(LoggerCallback) iferr_return;

maxon::UserLoggerTypeInterface is the logger type that displays the message in Cinema 4D's "Console" window:

maxon::FileLoggerTypeInterface is the logger type that writes the message to a file:

// This example accesses the default logger and gets all displayed lines.
// get default logger
const maxon::LoggerRef defaultLogger = maxon::Loggers::Default();
for (const auto& logger : defaultLogger.GetLoggerTypes())
const maxon::LoggerTypeRef loggerType = logger.GetFirst(); // get first element of the pair
if (loggerType.IsInstanceOf<maxon::UserLoggerTypeRef>())
const maxon::UserLoggerTypeRef userLoggerType = maxon::Cast<maxon::UserLoggerTypeRef>(loggerType);
// iterate over all lines sent to the logger
userLoggerType.Iterate([](maxon::LoggerLine& line) -> maxon::Result<void>
DiagnosticOutput("Line: @", line._str);
return maxon::OK;
return OK
Definition: apibase.h:2667
#define DiagnosticOutput(formatString,...)
Definition: debugdiagnostics.h:176
const char const char const char int line
Definition: object.h:440
Each object of LoggerLine represents an entry in the logger with several meta information....
Definition: logger.h:56

Further Reading