About

A VoronoiFracture object represents a Voronoi Fracture MoGraph generator. The class provides safe access to the point sources referenced, owned and used by the generator. It is defined in the lib_voronoifracture.h header file.

  // This example creates a Voronoi Fracture object,
  // adds an input Sphere object, a Rigid Body tag and a point generator.
 
  // create Voronoi Fracture object
  VoronoiFracture* const fractureObject = VoronoiFracture::Alloc();
  if (fractureObject == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  doc->InsertObject(fractureObject, nullptr, nullptr);
 
  // add a Rigid Body tag (ID 180000102)
  BaseTag* const rigidBodyTag = BaseTag::Alloc(180000102);
  if (rigidBodyTag == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  fractureObject->InsertTag(rigidBodyTag);
  rigidBodyTag->Message(MSG_MENUPREPARE);
 
  // add sphere as input object
  BaseObject* const sphere = BaseObject::Alloc(Osphere);
  if (sphere == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  doc->InsertObject(sphere, fractureObject, nullptr);
 
  // add point source
  const Int32       pointCreatorType = ID_POINTCREATOR_CREATORTYPE_DISTRIBUTION;
  BaseObject* const pointGenerator = fractureObject->AddPointGenerator(pointCreatorType, NOTOK, nullptr);
  if (pointGenerator == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  // configure point generator
  pointGenerator->SetParameter(ID_POINTCREATOR_CREATEDPOINTAMOUNT, 10, DESCFLAGS_SET::NONE);

Access

A VoronoiFracture object can be accessed like any other object.

  // This example accesses the currently selected
  // Voronoi Fracture object to print the number
  // of used sources.
 
  BaseObject* const obj = doc->GetActiveObject();
 
  // check if the active object is a Voronoi Fracture object (ID 1036557)
  if (obj != nullptr && obj->IsInstanceOf(1036557))
  {
    VoronoiFracture* const voronoiFracture = static_cast<VoronoiFracture*>(obj);
 
    // get source count
    const Int32 srcCnt = voronoiFracture->GetSourcesCount();
 
    // print source count
    const String srcCntStr = String::IntToString(srcCnt);
    ApplicationOutput(voronoiFracture->GetName() + " uses " + srcCntStr + " sources.");
  }

Allocation/Deallocation

VoronoiFracture objects are created with the usual tools:

VoronoiFracture::Alloc(): Creates a new VoronoiFracture object.
VoronoiFracture::Free(): Deletes the given VoronoiFracture object.

  // This example creates a Voronoi Fracture object as the new
  // parent object of the currently active object.
 
  // get active object
  BaseObject* const activeObject = doc->GetActiveObject();
  if (activeObject == nullptr)
    return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
 
  // create voronoi fracture
  VoronoiFracture* const fracture = VoronoiFracture::Alloc();
  if (fracture == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  // insert voronoi fracture
  doc->InsertObject(fracture, nullptr, nullptr);
 
  // insert active object under the fracture object
  activeObject->Remove();
  doc->InsertObject(activeObject, fracture, nullptr);

Parameters

The IDs of the standard parameters of a VoronoiFracture object are defined in the omograph_fracturevoronoi.h header file.

Note: The list of point sources must only be edited through the dedicated functions of the VoronoiFracture class (see below).

Sources

Both scene objects and dedicated point generator objects can be used to define the position of Voronoi points inside the mesh volume. The following functions allow to add, remove and edit these point sources. The type ID of point generator objects is Ovoronoipointgenerator.

Access Sources

The VoronoiFracture class provides functions to access the object and generator sources referenced in the "Sources" parameter.

VoronoiFracture::GetSourcesCount(): Returns the number of sources.
VoronoiFracture::GetSource(): Returns the source at the given index.
VoronoiFracture::GetSourceByType(): Returns the source of the given type.

  // This example loops through all point sources of the given
  // Voronoi Fracture object and prints their names.
 
  // get source count
  const Int32 srcCnt = voronoiFracture->GetSourcesCount();
 
  // loop through all sources
  for (Int32 i = 0; i < srcCnt; ++i)
  {
    // get source
    BaseObject* const source = voronoiFracture->GetSource(i);
    if (source == nullptr)
      return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
 
    // print source name
    const String sourceName = source->GetName();
    ApplicationOutput("Source: " + sourceName);
  }

Remove Sources

The VoronoiFracture class also provides functions to safely remove objects and generators from the "Sources" parameter.

VoronoiFracture::RemoveSource(): Removes the source with the given index, a point generator is also deleted.
VoronoiFracture::ClearSources(): Clears the "Sources" parameter and deletes all point generators.

  // This example removes all point generator sources from the
  // given Voronoi Fracture object.
 
  Int32 index = NOTOK;
 
  // loop through all point generators until no point generator is found anymore
  while (voronoiFracture->GetSourceByType(Ovoronoipointgenerator, NOTOK, &index))
  {
    voronoiFracture->RemoveSource(index);
  }

Add Sources

Using the VoronoiFracture functions it is safe to add new sources and generators to the "Sources" parameter.

VoronoiFracture::AddPointGenerator(): Creates and adds a new point generator of the given type. Valid types are:
- ID_POINTCREATOR_CREATORTYPE_DISTRIBUTION: "Distribution" generator
- ID_POINTCREATOR_CREATORTYPE_SHADER : "Shader" generator

Point generators are represented by dedicated BaseObject elements that are owned by the VoronoiFracture object. To configure such a point generator one can simply edit the parameters of the corresponding BaseObject. The parameter IDs of these parameters are defined in opointcreator_panel.h.

  // This example adds a shader generator source to the given
  // Voronoi Fracture object and adds a shader.
 
  const Int32       shaderGenerator = ID_POINTCREATOR_CREATORTYPE_SHADER;
  BaseObject* const shaderSource = voronoiFracture->AddPointGenerator(shaderGenerator, Xnoise);
  if (shaderSource == nullptr)
    return maxon::UnknownError(MAXON_SOURCE_LOCATION);
 
  // configure generator
  shaderSource->SetParameter(ID_POINTCREATOR_SHADERSAMPLEAMOUNT, 500, DESCFLAGS_SET::NONE);

The VoronoiFracture object can also use external objects as sources of points:

VoronoiFracture::AddSceneObject(): Adds the given BaseObject to the "Sources" list.
VoronoiFracture::GetSourceSettingsContainerForIndex(): Returns the BaseContainer with the settings for the given source object index.
VoronoiFracture::GetSourceSettingsContainerForObject(): Returns the BaseContainer with the settings for the given source object.

The IDs for these settings are defined in tfracturevoronoi.h.

  // This example creates a new cube and uses it
  // as a point source in the given VoronoiFracture object.
 
  BaseObject* const cube = BaseObject::Alloc(Ocube);
  if (cube == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
  doc->InsertObject(cube, nullptr, nullptr);
 
  // use as source object
 
  voronoiFracture->AddSceneObject(cube);
 
  BaseContainer* const settings = voronoiFracture->GetSourceSettingsContainerForObject(cube);
  if (settings == nullptr)
    return maxon::UnknownError(MAXON_SOURCE_LOCATION);
 
  settings->SetInt32(ID_FRACTURETAG_POINTCREATIONTYPE, ID_FRACTURETAG_POLYS);

Table of Contents