Here you will find documentation on all the descriptions that Cinema 4D currently has. You can list them Alphabetically, by Type or Plugin . The sample Python and C++ code is automatically generated and in some cases may not be 100% correct. If something doesn't work then please refer to the official Cinema 4D SDK documentation for more information.

Description Oxpdomain

IDs and information for Oxpdomain

Oxpdomain

Attributes

  • ENGLISH NAME : X-ParticlesDomain
  • NAME : Oxpdomain
  • INCLUDE : Obase
  • PATH : res/description/oxpdomain.res
  • PLUGIN : X-Particles
  • MAXON online help (may not exist): OXPDOMAIN

Elements

ID UI Name Type Parameters Cycle
XPDOMAIN_DOMAIN_TYPE Type LONG  
XPDOMAIN_DOMAIN_TYPE_LIQUID Liquid
XPDOMAIN_DOMAIN_TYPE_GASEOUS Gaseous
XPDOMAIN_DOMAIN_TYPE_PARTICLE Particles(Gas)
XPDOMAIN_DOMAIN_PARTICLES_LINK Particles LINK  
XPDOMAIN_SOLVER_GAS_EMIT ParticlesPerVoxel LONG
MIN 1
MAX 64
XPDOMAIN_SOLVER_WEAKSPRING WeakSpring BOOL  
XPDOMAIN_SOLVER_WEAKSPRING_STRENGTH Strength REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
CUSTOMGUI REALSLIDER
XPDOMAIN_VORTICITY Vorticity REAL
UNIT PERCENT
MIN 0.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XPDOMAIN_VISCOSITY Viscosity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
CUSTOMGUI REALSLIDER
XPDOMAIN_BOUNDS_VOXEL Voxel REAL UNIT
XPDOMAIN_BOUNDS_OFFSET Offset VECTOR UNIT
XPDOMAIN_BOUNDS_SIZE Size VECTOR UNIT
XPDOMAIN_GROUP_BOUNDS_CLOSED_X +X BOOL  
XPDOMAIN_GROUP_BOUNDS_CLOSED_Y +Y BOOL  
XPDOMAIN_GROUP_BOUNDS_CLOSED_Z +Z BOOL  
XPDOMAIN_GROUP_BOUNDS_CLOSED_NX -X BOOL  
XPDOMAIN_GROUP_BOUNDS_CLOSED_NY -Y BOOL  
XPDOMAIN_GROUP_BOUNDS_CLOSED_NZ -Z BOOL  
XPDOMAIN_TIMESCALE Retiming REAL
UNIT PERCENT
MIN 0.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XPDOMAIN_SOLVER_ACCURACY Accuracy REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PARENTCOLLAPSE
XPDOMAIN_SOLVER_FAST Fast BOOL PARENTCOLLAPSE
XPDOMAIN_SOLVER_ITERATIONS Iterations LONG
MIN 1
MAX 5000
XPDOMAIN_SOLVER_PICFLIP Pic/Flip REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
XPDOMAIN_SOLVER_MAXSTEPS MaxSubsteps LONG
MIN 1
MAX 100
XPDOMAIN_SOLVER_STRICT_SAMPLING StrictSampling BOOL  
XPDOMAIN_SOLVER_ADAPTIVE Enable BOOL  
XPDOMAIN_SOLVER_ADAPTIVE_THRESHOLD Threshold REAL
MIN 0.0
MAX 100.0
XPDOMAIN_SOLVER_ADAPTIVE_EXPAND Expand LONG
MIN 0
MAX 1000
XPDOMAIN_EMITTERS_SAMESYSTEM SameSystem BOOL  
XPDOMAIN_EMITTERS_INEX Mode LONG  
XPDOMAIN_EMITTERS_INEX_INCLUDE Include
XPDOMAIN_EMITTERS_INEX_EXCLUDE Exclude
XPDOMAIN_EMITTERS_INCLUDE Emitters IN_EXCLUDE
SCALE_V
NUM_FLAGS 0
SEND_SELCHNGMSG 1
SCALE_V
XPDOMAIN_GROUPS Groups IN_EXCLUDE
NUM_FLAGS 2
INIT_STATE 3
SEND_SELCHNGMSG 1
SCALE_V
IMAGE_01_ON 1009316
IMAGE_01_OFF 1009320
IMAGE_02_ON 300000231
IMAGE_02_OFF 300000230
XPDOMAIN_MODIFIERS_SAMESYSTEM SameSystem BOOL  
XPDOMAIN_MODIFIERS_INEX Mode LONG  
XPDOMAIN_EMITTERS_INEX_INCLUDE Include
XPDOMAIN_EMITTERS_INEX_EXCLUDE Exclude
XPDOMAIN_MODIFIERS_INCLUDE Modifiers IN_EXCLUDE
SCALE_V
NUM_FLAGS 0
SEND_SELCHNGMSG 1
SCALE_V
XPDOMAIN_COLLIDERS_INEX Mode LONG  
XPDOMAIN_EMITTERS_INEX_INCLUDE Include
XPDOMAIN_EMITTERS_INEX_EXCLUDE Exclude
XPDOMAIN_COLLIDERS_INCLUDE Objects IN_EXCLUDE
SCALE_V
NUM_FLAGS 0
SEND_SELCHNGMSG 1
SCALE_V
XPDOMAIN_SOURCES_INEX Mode LONG  
XPDOMAIN_EMITTERS_INEX_INCLUDE Include
XPDOMAIN_EMITTERS_INEX_EXCLUDE Exclude
XPDOMAIN_SOURCES_INCLUDE Objects IN_EXCLUDE
SCALE_V
NUM_FLAGS 0
SEND_SELCHNGMSG 1
SCALE_V
XPDOMAIN_DISPLAY_GRID_TYPE Grid LONG  
XPDOMAIN_DISPLAY_GRID_TYPE_NONE None
XPDOMAIN_DISPLAY_GRID_TYPE_VOXELS Voxels
XPDOMAIN_DISPLAY_GRID_TYPE_BACK Back
XPDOMAIN_DISPLAY_GRID_TYPE_BASE Base
XPDOMAIN_DISPLAY_ADAPATIVE AdaptiveBounds BOOL  
XPDOMAIN_DISPLAY_VELOCITY Velocity BOOL  
XPDOMAIN_DISPLAY_COLLIDERS Colliders BOOL  
XPDOMAIN_DISPLAY_PROPERTY Property LONG  
XPDOMAIN_DISPLAY_PROPERTY_NONE None
XPDOMAIN_DISPLAY_PROPERTY_TEMPERATURE Temperature
XPDOMAIN_DISPLAY_PROPERTY_SMOKE Smoke
XPDOMAIN_DISPLAY_PROPERTY_BURN Fire
XPDOMAIN_DISPLAY_PROPERTY_SMOKE_BURN Fire+Smoke
XPDOMAIN_DISPLAY_PROPERTY_FUEL Fuel
XPDOMAIN_DISPLAY_PROPERTY_SPEED Speed
XPDOMAIN_DISPLAY_PROPERTY_COLOR_TEMP TempColor GRADIENT
COLOR
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_OPACITY_TEMP TempAlpha GRADIENT
ALPHA
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_COLOR_SMOKE SmokeColor GRADIENT
COLOR
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SMOKE SmokeAlpha GRADIENT
ALPHA
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_COLOR_FUEL FuelColor GRADIENT
COLOR
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_OPACITY_FUEL FuelAlpha GRADIENT
ALPHA
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_COLOR_BURN FireColor GRADIENT
COLOR
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_OPACITY_BURN FireAlpha GRADIENT
ALPHA
HIDDEN
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_COLOR_SPEED SpeedColor GRADIENT
COLOR
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SPEED SpeedAlpha GRADIENT
ALPHA
ICC_BASEDOCUMENT
XPDOMAIN_DISPLAY_RANGE_AUTO AutoRange BOOL  
XPDOMAIN_DISPLAY_RANGE_MIN_TEMP TempMin REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MAX_TEMP TempMax REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MIN_SMOKE SmokeMin REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MAX_SMOKE SmokeMax REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MIN_FUEL FuelMin REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MAX_FUEL FuelMax REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MIN_BURN FireMin REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MAX_BURN FireMax REAL HIDDEN
XPDOMAIN_DISPLAY_RANGE_MIN_SPEED SpeedMin REAL  
XPDOMAIN_DISPLAY_RANGE_MAX_SPEED SpeedMax REAL  
XPDOMAIN_DISPLAY_OPACITY Opacity REAL
UNIT PERCENT
MIN 0.0
MAXSLIDER 100.0
MAX 1000.0
CUSTOMGUI REALSLIDER
XPDOMAIN_DISPLAY_SUBD Resolution REAL
UNIT PERCENT
MIN 0.0
MAX 1000.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XPDOMAIN_DISPLAY_SLICES Slices REAL
UNIT PERCENT
MIN 0.0
MAX 1000.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER

Example Code

The following code does not use the correct values when setting the data. You should check directly in C4D for the correct values that you should use in place of the ones that are shown. This code is just to show you how to access the values for getting and setting the parameters.

Python

import c4d
from c4d import gui
def main():
    obj = c4d.BaseObject(c4d.Oxpdomain)
    doc.InsertObject(obj)
    c4d.EventAdd(c4d.EVENT_FORCEREDRAW)
    
    #You can set parameters two different ways. 
    #First way              
    obj[c4d.XPDOMAIN_DOMAIN_TYPE] = c4d.XPDOMAIN_DOMAIN_TYPE_LIQUID
    obj[c4d.XPDOMAIN_SOLVER_GAS_EMIT] = 1
    obj[c4d.XPDOMAIN_SOLVER_WEAKSPRING] = True
    obj[c4d.XPDOMAIN_SOLVER_WEAKSPRING_STRENGTH] = 0.1
    obj[c4d.XPDOMAIN_VORTICITY] = 0.1
    obj[c4d.XPDOMAIN_VISCOSITY] = 0.1
    obj[c4d.XPDOMAIN_BOUNDS_VOXEL] = 0.1
    obj[c4d.XPDOMAIN_BOUNDS_OFFSET] = c4d.Vector(1.0,1.0,1.0)
    obj[c4d.XPDOMAIN_BOUNDS_SIZE] = c4d.Vector(1.0,1.0,1.0)
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_X] = True
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_Y] = True
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_Z] = True
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NX] = True
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NY] = True
    obj[c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NZ] = True
    obj[c4d.XPDOMAIN_TIMESCALE] = 0.1
    obj[c4d.XPDOMAIN_SOLVER_ACCURACY] = 0.1
    obj[c4d.XPDOMAIN_SOLVER_FAST] = True
    obj[c4d.XPDOMAIN_SOLVER_ITERATIONS] = 1
    obj[c4d.XPDOMAIN_SOLVER_PICFLIP] = 0.1
    obj[c4d.XPDOMAIN_SOLVER_MAXSTEPS] = 1
    obj[c4d.XPDOMAIN_SOLVER_STRICT_SAMPLING] = True
    obj[c4d.XPDOMAIN_SOLVER_ADAPTIVE] = True
    obj[c4d.XPDOMAIN_SOLVER_ADAPTIVE_THRESHOLD] = 0.1
    obj[c4d.XPDOMAIN_SOLVER_ADAPTIVE_EXPAND] = 1
    obj[c4d.XPDOMAIN_EMITTERS_SAMESYSTEM] = True
    obj[c4d.XPDOMAIN_EMITTERS_INEX] = c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE
    obj[c4d.XPDOMAIN_MODIFIERS_SAMESYSTEM] = True
    obj[c4d.XPDOMAIN_MODIFIERS_INEX] = c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE
    obj[c4d.XPDOMAIN_COLLIDERS_INEX] = c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE
    obj[c4d.XPDOMAIN_SOURCES_INEX] = c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE
    obj[c4d.XPDOMAIN_DISPLAY_GRID_TYPE] = c4d.XPDOMAIN_DISPLAY_GRID_TYPE_NONE
    obj[c4d.XPDOMAIN_DISPLAY_ADAPATIVE] = True
    obj[c4d.XPDOMAIN_DISPLAY_VELOCITY] = True
    obj[c4d.XPDOMAIN_DISPLAY_COLLIDERS] = True
    obj[c4d.XPDOMAIN_DISPLAY_PROPERTY] = c4d.XPDOMAIN_DISPLAY_PROPERTY_NONE
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_AUTO] = True
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MIN_TEMP] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MAX_TEMP] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MIN_SMOKE] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MAX_SMOKE] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MIN_FUEL] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MAX_FUEL] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MIN_BURN] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MAX_BURN] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MIN_SPEED] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_RANGE_MAX_SPEED] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_OPACITY] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_SUBD] = 0.1
    obj[c4d.XPDOMAIN_DISPLAY_SLICES] = 0.1
    
    #Second way, using the base container.
    bc = obj.GetDataInstance()
    bc.SetInt32(c4d.XPDOMAIN_DOMAIN_TYPE,c4d.XPDOMAIN_DOMAIN_TYPE_LIQUID)
    bc.SetInt32(c4d.XPDOMAIN_SOLVER_GAS_EMIT,1)
    bc.SetBool(c4d.XPDOMAIN_SOLVER_WEAKSPRING,True)
    bc.SetFloat(c4d.XPDOMAIN_SOLVER_WEAKSPRING_STRENGTH,0.1)
    bc.SetFloat(c4d.XPDOMAIN_VORTICITY,0.1)
    bc.SetFloat(c4d.XPDOMAIN_VISCOSITY,0.1)
    bc.SetFloat(c4d.XPDOMAIN_BOUNDS_VOXEL,0.1)
    bc.SetVector(c4d.XPDOMAIN_BOUNDS_OFFSET, c4d.Vector(1.0,1.0,1.0)
    bc.SetVector(c4d.XPDOMAIN_BOUNDS_SIZE, c4d.Vector(1.0,1.0,1.0)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_X,True)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_Y,True)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_Z,True)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NX,True)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NY,True)
    bc.SetBool(c4d.XPDOMAIN_GROUP_BOUNDS_CLOSED_NZ,True)
    bc.SetFloat(c4d.XPDOMAIN_TIMESCALE,0.1)
    bc.SetFloat(c4d.XPDOMAIN_SOLVER_ACCURACY,0.1)
    bc.SetBool(c4d.XPDOMAIN_SOLVER_FAST,True)
    bc.SetInt32(c4d.XPDOMAIN_SOLVER_ITERATIONS,1)
    bc.SetFloat(c4d.XPDOMAIN_SOLVER_PICFLIP,0.1)
    bc.SetInt32(c4d.XPDOMAIN_SOLVER_MAXSTEPS,1)
    bc.SetBool(c4d.XPDOMAIN_SOLVER_STRICT_SAMPLING,True)
    bc.SetBool(c4d.XPDOMAIN_SOLVER_ADAPTIVE,True)
    bc.SetFloat(c4d.XPDOMAIN_SOLVER_ADAPTIVE_THRESHOLD,0.1)
    bc.SetInt32(c4d.XPDOMAIN_SOLVER_ADAPTIVE_EXPAND,1)
    bc.SetBool(c4d.XPDOMAIN_EMITTERS_SAMESYSTEM,True)
    bc.SetInt32(c4d.XPDOMAIN_EMITTERS_INEX,c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE)
    bc.SetBool(c4d.XPDOMAIN_MODIFIERS_SAMESYSTEM,True)
    bc.SetInt32(c4d.XPDOMAIN_MODIFIERS_INEX,c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE)
    bc.SetInt32(c4d.XPDOMAIN_COLLIDERS_INEX,c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE)
    bc.SetInt32(c4d.XPDOMAIN_SOURCES_INEX,c4d.XPDOMAIN_EMITTERS_INEX_INCLUDE)
    bc.SetInt32(c4d.XPDOMAIN_DISPLAY_GRID_TYPE,c4d.XPDOMAIN_DISPLAY_GRID_TYPE_NONE)
    bc.SetBool(c4d.XPDOMAIN_DISPLAY_ADAPATIVE,True)
    bc.SetBool(c4d.XPDOMAIN_DISPLAY_VELOCITY,True)
    bc.SetBool(c4d.XPDOMAIN_DISPLAY_COLLIDERS,True)
    bc.SetInt32(c4d.XPDOMAIN_DISPLAY_PROPERTY,c4d.XPDOMAIN_DISPLAY_PROPERTY_NONE)
    bc.SetBool(c4d.XPDOMAIN_DISPLAY_RANGE_AUTO,True)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MIN_TEMP,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MAX_TEMP,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MIN_SMOKE,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MAX_SMOKE,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MIN_FUEL,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MAX_FUEL,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MIN_BURN,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MAX_BURN,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MIN_SPEED,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_RANGE_MAX_SPEED,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_OPACITY,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_SUBD,0.1)
    bc.SetFloat(c4d.XPDOMAIN_DISPLAY_SLICES,0.1)

if __name__=='__main__':
    main()

C++

#include "c4d.h"
#include "../res/description/oxpdomain.h"
void SampleFunction()
{
    BaseDocument *pDoc = GetActiveDocument();
    BaseObject *pObject = BaseObject::Alloc(Oxpdomain);
    pDoc->InsertObject(pObject);
    pDoc->StartUndo();
    pDoc->AddUndo(UNDO_NEW,pObject);
    pDoc->EndUndo();
    EventAdd(EVENT_FORCEREDRAW);
    
    //You can set parameters two different ways. 

    //First way              
    //Some objects do not store all their data in the container. You need to use GetParameter()/SetParameter() instead. 

    DESCFLAGS_SET flags = DESCFLAGS_SET_PARAM_SET;
    pObject->SetParameter(DescID(XPDOMAIN_DOMAIN_TYPE),GeData(XPDOMAIN_DOMAIN_TYPE_LIQUID),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_GAS_EMIT),GeData(1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_WEAKSPRING),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_WEAKSPRING_STRENGTH),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_VORTICITY),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_VISCOSITY),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_BOUNDS_VOXEL),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_BOUNDS_OFFSET),GeData(Vector(1.0,1.0,1.0)),flags);
    pObject->SetParameter(DescID(XPDOMAIN_BOUNDS_SIZE),GeData(Vector(1.0,1.0,1.0)),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_X),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_Y),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_Z),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_NX),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_NY),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_GROUP_BOUNDS_CLOSED_NZ),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_TIMESCALE),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_ACCURACY),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_FAST),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_ITERATIONS),GeData(1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_PICFLIP),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_MAXSTEPS),GeData(1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_STRICT_SAMPLING),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_ADAPTIVE),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_ADAPTIVE_THRESHOLD),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOLVER_ADAPTIVE_EXPAND),GeData(1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_EMITTERS_SAMESYSTEM),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_EMITTERS_INEX),GeData(XPDOMAIN_EMITTERS_INEX_INCLUDE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_MODIFIERS_SAMESYSTEM),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_MODIFIERS_INEX),GeData(XPDOMAIN_EMITTERS_INEX_INCLUDE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_COLLIDERS_INEX),GeData(XPDOMAIN_EMITTERS_INEX_INCLUDE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_SOURCES_INEX),GeData(XPDOMAIN_EMITTERS_INEX_INCLUDE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_GRID_TYPE),GeData(XPDOMAIN_DISPLAY_GRID_TYPE_NONE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_ADAPATIVE),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_VELOCITY),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_COLLIDERS),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY),GeData(XPDOMAIN_DISPLAY_PROPERTY_NONE),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_AUTO),GeData(true),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MIN_TEMP),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MAX_TEMP),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MIN_SMOKE),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MAX_SMOKE),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MIN_FUEL),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MAX_FUEL),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MIN_BURN),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MAX_BURN),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MIN_SPEED),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_RANGE_MAX_SPEED),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_OPACITY),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_SUBD),GeData(0.1),flags);
    pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_SLICES),GeData(0.1),flags);
    pObject->Message(MSG_UPDATE);            

    //Second way, using the base container.
    BaseContainer *bc =     pObject->GetDataInstance();
    bc->SetInt32(XPDOMAIN_DOMAIN_TYPE,XPDOMAIN_DOMAIN_TYPE_LIQUID);
    bc->SetInt32(XPDOMAIN_SOLVER_GAS_EMIT,1);
    bc->SetBool(XPDOMAIN_SOLVER_WEAKSPRING,true);
    bc->SetFloat(XPDOMAIN_SOLVER_WEAKSPRING_STRENGTH,0.1);
    bc->SetFloat(XPDOMAIN_VORTICITY,0.1);
    bc->SetFloat(XPDOMAIN_VISCOSITY,0.1);
    bc->SetFloat(XPDOMAIN_BOUNDS_VOXEL,0.1);
    bc->SetVector(XPDOMAIN_BOUNDS_OFFSET, c4d.Vector(1.0,1.0,1.0);
    bc->SetVector(XPDOMAIN_BOUNDS_SIZE, c4d.Vector(1.0,1.0,1.0);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_X,true);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_Y,true);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_Z,true);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_NX,true);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_NY,true);
    bc->SetBool(XPDOMAIN_GROUP_BOUNDS_CLOSED_NZ,true);
    bc->SetFloat(XPDOMAIN_TIMESCALE,0.1);
    bc->SetFloat(XPDOMAIN_SOLVER_ACCURACY,0.1);
    bc->SetBool(XPDOMAIN_SOLVER_FAST,true);
    bc->SetInt32(XPDOMAIN_SOLVER_ITERATIONS,1);
    bc->SetFloat(XPDOMAIN_SOLVER_PICFLIP,0.1);
    bc->SetInt32(XPDOMAIN_SOLVER_MAXSTEPS,1);
    bc->SetBool(XPDOMAIN_SOLVER_STRICT_SAMPLING,true);
    bc->SetBool(XPDOMAIN_SOLVER_ADAPTIVE,true);
    bc->SetFloat(XPDOMAIN_SOLVER_ADAPTIVE_THRESHOLD,0.1);
    bc->SetInt32(XPDOMAIN_SOLVER_ADAPTIVE_EXPAND,1);
    bc->SetBool(XPDOMAIN_EMITTERS_SAMESYSTEM,true);
    bc->SetInt32(XPDOMAIN_EMITTERS_INEX,XPDOMAIN_EMITTERS_INEX_INCLUDE);
    bc->SetBool(XPDOMAIN_MODIFIERS_SAMESYSTEM,true);
    bc->SetInt32(XPDOMAIN_MODIFIERS_INEX,XPDOMAIN_EMITTERS_INEX_INCLUDE);
    bc->SetInt32(XPDOMAIN_COLLIDERS_INEX,XPDOMAIN_EMITTERS_INEX_INCLUDE);
    bc->SetInt32(XPDOMAIN_SOURCES_INEX,XPDOMAIN_EMITTERS_INEX_INCLUDE);
    bc->SetInt32(XPDOMAIN_DISPLAY_GRID_TYPE,XPDOMAIN_DISPLAY_GRID_TYPE_NONE);
    bc->SetBool(XPDOMAIN_DISPLAY_ADAPATIVE,true);
    bc->SetBool(XPDOMAIN_DISPLAY_VELOCITY,true);
    bc->SetBool(XPDOMAIN_DISPLAY_COLLIDERS,true);
    bc->SetInt32(XPDOMAIN_DISPLAY_PROPERTY,XPDOMAIN_DISPLAY_PROPERTY_NONE);
    bc->SetBool(XPDOMAIN_DISPLAY_RANGE_AUTO,true);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MIN_TEMP,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MAX_TEMP,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MIN_SMOKE,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MAX_SMOKE,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MIN_FUEL,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MAX_FUEL,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MIN_BURN,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MAX_BURN,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MIN_SPEED,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_RANGE_MAX_SPEED,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_OPACITY,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_SUBD,0.1);
    bc->SetFloat(XPDOMAIN_DISPLAY_SLICES,0.1);
    pObject->Message(MSG_UPDATE);                                                      
}

Gradients

This node has gradients. Gradients can manually be edited by calling the following code

Python



C++
 

           
#include "customgui_gradient.h"

XPDOMAIN_DISPLAY_PROPERTY_COLOR_TEMP
                                
GeData data;
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_TEMP),data,DESCFLAGS_GET_PARAM_GET));
Gradient *pGradient = (Gradient*)data.GetCustomDataType(CUSTOMDATATYPE_GRADIENT);
if(pGradient)
{    
    //must be set before any knot is set
    pGradient->SetData(GRADIENT_MODE, GeData(GRADIENTMODE_ALPHA));
    GradientKnot k1, k2;
    k1.col = Vector(0.0, 0.0, 1.0);
    k1.pos = 0.0;
    k2.col = 1.0;
    k2.pos = 1.0;
    pGradient->InsertKnot(k1);
    pGradient->InsertKnot(k2);
}
pObject->SetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_TEMP),data,DESCFLAGS_SET_PARAM_SET));

XPDOMAIN_DISPLAY_PROPERTY_OPACITY_TEMP
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_OPACITY_TEMP),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_COLOR_SMOKE
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_SMOKE),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SMOKE
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SMOKE),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_COLOR_FUEL
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_FUEL),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_OPACITY_FUEL
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_OPACITY_FUEL),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_COLOR_BURN
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_BURN),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_OPACITY_BURN
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_OPACITY_BURN),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_COLOR_SPEED
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_COLOR_SPEED),data,DESCFLAGS_GET_PARAM_GET));

XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SPEED
                                
pObject->GetParameter(DescID(XPDOMAIN_DISPLAY_PROPERTY_OPACITY_SPEED),data,DESCFLAGS_GET_PARAM_GET));