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 PyroShader

IDs and information for PyroShader

PyroShader

Attributes

  • ENGLISH NAME : PyroCluster
  • NAME : PS_NAME
  • INCLUDE : Mpreview
  • INCLUDE : Mbase
  • PATH : advanced_render/description/pyroshader.res
  • PLUGIN : advanced_render
  • MAXON online help (may not exist): PYROSHADER

Elements

ID UI Name Type Parameters Cycle
PYRO_PAGE_GLOBALS Globals BOOL
HIDDEN
PAGE
PARENTMSG PS_GLOBALS_GROUP
PYRO_PAGE_AGE Age BOOL
HIDDEN
PAGE
PARENTMSG PS_AGE_GROUP
PYRO_PAGE_DIST Distance BOOL
HIDDEN
PAGE
PARENTMSG PS_DIST_GROUP
PYRO_PAGE_RADDIST Cyl.Distance BOOL
HIDDEN
PAGE
PARENTMSG PS_RADDIST_GROUP
PYRO_PAGE_SHP Shape BOOL
HIDDEN
PAGE
PARENTMSG PS_SHP_GROUP
PYRO_PAGE_IL Illumination BOOL
HIDDEN
PAGE
PARENTMSG PS_IL_GROUP
PYRO_PAGE_SH Shadow BOOL
HIDDEN
PAGE
PARENTMSG PS_SH_GROUP
PYRO_PAGE_FF Noise BOOL
HIDDEN
PAGE
PARENTMSG PS_FF_GROUP
PS_ON On BOOL  
PS_PREVIEW Preview... BUTTON ANIM
PS_SAMPLES Volume REAL
UNIT PERCENT
MIN 1.0
MAX 100.0
PS_PARTLUM Luminosity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_DENSITY Density REAL
MIN 0.0
STEP 0.1
PS_GRADPART Color GRADIENT
COLOR
ALPHA
ICC_BASEDOCUMENT
PS_GRADMODE GradientMode LONG  
GRAD_MODE_FLAT FlatRadius
GRAD_MODE_LOCAL LocalRadius
GRAD_MODE_WORLD WorldRadius
GRAD_MODE_DENSITY Density
PS_GRADMIN Min REAL
UNIT PERCENT
MIN 0.0
PS_GRADMAX Max REAL
UNIT PERCENT
MIN 0.0
PS_INTERSECT UseIntersection BOOL  
PS_ISECTBIAS RayBias REAL
UNIT METER
MIN 0.0
STEP 0.01
PS_SETTINGS Settings LONG ANIM
PS_SET_FIRE Fire
PS_SET_VOLCANO Volcano
PS_SET_CLOUD Cloud
PS_SET_STEAM Steam
PS_SET_FIREBALL FireBall
PS_SET_SMOKE Smoke
PS_SET_USER User
PS_AGEON UseAgeEffects BOOL  
PS_AGERAD Radius GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_AGEPLUM Luminosity GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_AGEMIX ColorMix GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_GRADLIFE Color GRADIENT
COLOR
ALPHA
ICC_BASEDOCUMENT
PS_USEDIST UseDistanceEffects BOOL  
PS_USEEPLANE UseEmitterPlane BOOL  
PS_NEARDIST NearRange REAL
UNIT METER
MIN 0.0
PS_FARDIST FarRange REAL
UNIT METER
MIN 0.0
PS_DISTRAD Radius GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_DISTPLUM Luminosity GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_DISTMIX ColorMix GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_DISTGRAD Color GRADIENT
COLOR
ALPHA
ICC_BASEDOCUMENT
PS_USERADDIST UseCylindricalDistanceEffects BOOL  
PS_EMITTERDIR EmitterDirection LONG  
PS_EMITTERDIR_X X
PS_EMITTERDIR_Y Y
PS_EMITTERDIR_Z Z
PS_NEARRADDIST NearRange REAL
UNIT METER
MIN 0.0
PS_FARRADDIST FarRange REAL
UNIT METER
MIN 0.0
PS_RADDISTRAD Radius GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_RADDISTPLUM Luminosity GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_RADDISTMIX ColorMix GRADIENT
ALPHA
ICC_BASEDOCUMENT
NOPRESETS
PS_RADDISTGRAD Color GRADIENT
COLOR
ALPHA
ICC_BASEDOCUMENT
PS_SHP_TYPE Type LONG  
PART_SHAPE_SPHERE Sphere
PART_SHAPE_CYLINDER Cylinder
PART_SHAPE_BOX Box
PS_SHP_RADIUS Radius REAL
UNIT METER
MIN 0.0
PS_SHP_HEMI UseHemisphere BOOL  
PS_SHP_HEMILEN Hemisphere REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_SHP_USETM UseParticleTM BOOL  
PS_SHP_AUTOROT UseAutoRotation BOOL  
PS_SHP_ROTVECTOR Rotation VECTOR  
PS_SHP_SCALE Scale VECTOR
MIN 0.0
STEP 0.01
PS_SHP_VELSCALE VelocityScale VECTOR
MIN 0.0
STEP 0.01
PS_SHP_PREVIEW Preview BOOL  
PS_SHP_VISIBLE Max.Visible LONG MIN
PS_IL_ON UseIllumination BOOL  
PS_IL_MODE Mode LONG PARENTID
PS_IL_MODE_ISOTROPIC Diffuse
PS_IL_MODE_RAYANGLE RayAngle
PS_IL_MODE_BUMP Bump
PS_IL_HIGHLIGHT BITMAPBUTTON BORDER
PS_IL_SELF SelfIllum. REAL
PARENTID PS_IL_ON
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_IL_TRANS Trans.Illum. REAL
PARENTID PS_IL_ON
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_IL_SHINY Shininess REAL
PARENTID PS_IL_ON
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_IL_STRENGTH Strength REAL
PARENTID PS_IL_ON
UNIT PERCENT
MIN 0.0
PS_IL_SOFTEN Soften REAL
PARENTID PS_IL_ON
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_IL_BUMP Bump REAL
PARENTID PS_IL_ON
UNIT PERCENT
PS_SH_RECVSHADOWS ReceiveShadows BOOL  
PS_SH_CASTSHADOWS CastShadows BOOL  
PS_SH_SELFSHADOWS SelfShadows BOOL  
PS_SH_TRANS Transparency REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_SH_AMBIENT Ambient COLOR  
PS_SH_CFILTER ShadowColorFilter BOOL  
PS_SH_MAPSAMPLESON UseShadowMapsSamples BOOL  
PS_SH_MAPSAMPLES Volume REAL
PARENTID PS_SH_MAPSAMPLESON
MIN 1.0
MAX 100.0
STEP 0.1
PS_SH_TRACEDSAMPLESON UseRaytracedSamples BOOL  
PS_SH_TRACEDSAMPLES Volume REAL
PARENTID PS_SH_TRACEDSAMPLESON
MIN 1.0
MAX 100.0
STEP 0.1
PS_SH_DARKALPHA DarkenOpacity BOOL  
PS_SH_DARKFAC DarkFactor REAL
PARENTID PS_SH_DARKALPHA
UNIT PERCENT
PS_SH_DARKBRIGHT Brightness REAL
PARENTID PS_SH_DARKALPHA
UNIT PERCENT
MIN 0.0
PS_SH_USESELFOPT SelfShadowOptions BOOL  
PS_SH_SELFBIAS Bias REAL
PARENTID PS_SH_USESELFOPT
UNIT METER
MIN 0.0
STEP 0.01
PS_SH_SELFSAMPLES Smp.Range REAL
PARENTID PS_SH_USESELFOPT
MIN 0.0
MAX 20.0
STEP 0.01
PS_FFON UseNoise BOOL  
PS_FF_TYPE NoiseType LONG  
PS_FF_TYPE_GAS Gaseous
PS_FF_TYPE_FIRE Fire
PS_FF_TYPE_ELECTRIC Electric
PS_FF_TYPE_REGULAR Regular
PS_FF_TYPE_FRACTAL Fractal
PS_FF_TYPE_TURBULENCE Turbulence
PS_FF_TYPE_FBM_FRACTAL fBmFractal
PS_FF_TYPE_FBM_TURBULENCE fBmTurbulence
PS_FF_REGULAR Regularity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_GROWRAD GrowRadius REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_SCALE Scale REAL
UNIT PERCENT
MIN 0.0
PS_FF_EXP PeakBlend REAL UNIT
PS_FF_LEVEL Detail REAL
MIN 1.0
MAX 5.0
STEP 0.01
PS_FF_PHASE Phase REAL UNIT
PS_FF_GAIN Gain REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_BIAS Bias REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_LOWTHRESH LowThreshold REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_HIGHTHRESH HighThreshold REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
PS_FF_COLORON UseColor BOOL  
PS_FF_COLOR Color GRADIENT
PARENTID PS_FF_COLORON
COLOR
ALPHA
ICC_BASEDOCUMENT
PS_FF_PSTATIC StaticPos BOOL  
PS_FF_NOSCALE NoScale BOOL  
PS_FF_INVERT InvertNoise BOOL  

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():
    material = c4d.BaseMaterial(c4d.PyroShader)
    
    #You can set parameters two different ways. 
    #First way              
    material[c4d.PYRO_PAGE_GLOBALS] = True
    material[c4d.PYRO_PAGE_AGE] = True
    material[c4d.PYRO_PAGE_DIST] = True
    material[c4d.PYRO_PAGE_RADDIST] = True
    material[c4d.PYRO_PAGE_SHP] = True
    material[c4d.PYRO_PAGE_IL] = True
    material[c4d.PYRO_PAGE_SH] = True
    material[c4d.PYRO_PAGE_FF] = True
    material[c4d.PS_ON] = True
    material[c4d.PS_SAMPLES] = 0.1
    material[c4d.PS_PARTLUM] = 0.1
    material[c4d.PS_DENSITY] = 0.1
    material[c4d.PS_GRADMODE] = c4d.GRAD_MODE_FLAT
    material[c4d.PS_GRADMIN] = 0.1
    material[c4d.PS_GRADMAX] = 0.1
    material[c4d.PS_INTERSECT] = True
    material[c4d.PS_ISECTBIAS] = 0.1
    material[c4d.PS_SETTINGS] = c4d.PS_SET_FIRE
    material[c4d.PS_AGEON] = True
    material[c4d.PS_USEDIST] = True
    material[c4d.PS_USEEPLANE] = True
    material[c4d.PS_NEARDIST] = 0.1
    material[c4d.PS_FARDIST] = 0.1
    material[c4d.PS_USERADDIST] = True
    material[c4d.PS_EMITTERDIR] = c4d.PS_EMITTERDIR_X
    material[c4d.PS_NEARRADDIST] = 0.1
    material[c4d.PS_FARRADDIST] = 0.1
    material[c4d.PS_SHP_TYPE] = c4d.PART_SHAPE_SPHERE
    material[c4d.PS_SHP_RADIUS] = 0.1
    material[c4d.PS_SHP_HEMI] = True
    material[c4d.PS_SHP_HEMILEN] = 0.1
    material[c4d.PS_SHP_USETM] = True
    material[c4d.PS_SHP_AUTOROT] = True
    material[c4d.PS_SHP_ROTVECTOR] = c4d.Vector(1.0,1.0,1.0)
    material[c4d.PS_SHP_SCALE] = c4d.Vector(1.0,1.0,1.0)
    material[c4d.PS_SHP_VELSCALE] = c4d.Vector(1.0,1.0,1.0)
    material[c4d.PS_SHP_PREVIEW] = True
    material[c4d.PS_SHP_VISIBLE] = 1
    material[c4d.PS_IL_ON] = True
    material[c4d.PS_IL_MODE] = c4d.PS_IL_MODE_ISOTROPIC
    material[c4d.PS_IL_SELF] = 0.1
    material[c4d.PS_IL_TRANS] = 0.1
    material[c4d.PS_IL_SHINY] = 0.1
    material[c4d.PS_IL_STRENGTH] = 0.1
    material[c4d.PS_IL_SOFTEN] = 0.1
    material[c4d.PS_IL_BUMP] = 0.1
    material[c4d.PS_SH_RECVSHADOWS] = True
    material[c4d.PS_SH_CASTSHADOWS] = True
    material[c4d.PS_SH_SELFSHADOWS] = True
    material[c4d.PS_SH_TRANS] = 0.1
    material[c4d.PS_SH_CFILTER] = True
    material[c4d.PS_SH_MAPSAMPLESON] = True
    material[c4d.PS_SH_MAPSAMPLES] = 0.1
    material[c4d.PS_SH_TRACEDSAMPLESON] = True
    material[c4d.PS_SH_TRACEDSAMPLES] = 0.1
    material[c4d.PS_SH_DARKALPHA] = True
    material[c4d.PS_SH_DARKFAC] = 0.1
    material[c4d.PS_SH_DARKBRIGHT] = 0.1
    material[c4d.PS_SH_USESELFOPT] = True
    material[c4d.PS_SH_SELFBIAS] = 0.1
    material[c4d.PS_SH_SELFSAMPLES] = 0.1
    material[c4d.PS_FFON] = True
    material[c4d.PS_FF_TYPE] = c4d.PS_FF_TYPE_GAS
    material[c4d.PS_FF_REGULAR] = 0.1
    material[c4d.PS_FF_GROWRAD] = 0.1
    material[c4d.PS_FF_SCALE] = 0.1
    material[c4d.PS_FF_EXP] = 0.1
    material[c4d.PS_FF_LEVEL] = 0.1
    material[c4d.PS_FF_PHASE] = 0.1
    material[c4d.PS_FF_GAIN] = 0.1
    material[c4d.PS_FF_BIAS] = 0.1
    material[c4d.PS_FF_LOWTHRESH] = 0.1
    material[c4d.PS_FF_HIGHTHRESH] = 0.1
    material[c4d.PS_FF_COLORON] = True
    material[c4d.PS_FF_PSTATIC] = True
    material[c4d.PS_FF_NOSCALE] = True
    material[c4d.PS_FF_INVERT] = True
    
    #Second way, using the base container.
    bc = material.GetDataInstance()
    bc.SetBool(c4d.PYRO_PAGE_GLOBALS,True)
    bc.SetBool(c4d.PYRO_PAGE_AGE,True)
    bc.SetBool(c4d.PYRO_PAGE_DIST,True)
    bc.SetBool(c4d.PYRO_PAGE_RADDIST,True)
    bc.SetBool(c4d.PYRO_PAGE_SHP,True)
    bc.SetBool(c4d.PYRO_PAGE_IL,True)
    bc.SetBool(c4d.PYRO_PAGE_SH,True)
    bc.SetBool(c4d.PYRO_PAGE_FF,True)
    bc.SetBool(c4d.PS_ON,True)
    bc.SetFloat(c4d.PS_SAMPLES,0.1)
    bc.SetFloat(c4d.PS_PARTLUM,0.1)
    bc.SetFloat(c4d.PS_DENSITY,0.1)
    bc.SetInt32(c4d.PS_GRADMODE,c4d.GRAD_MODE_FLAT)
    bc.SetFloat(c4d.PS_GRADMIN,0.1)
    bc.SetFloat(c4d.PS_GRADMAX,0.1)
    bc.SetBool(c4d.PS_INTERSECT,True)
    bc.SetFloat(c4d.PS_ISECTBIAS,0.1)
    bc.SetInt32(c4d.PS_SETTINGS,c4d.PS_SET_FIRE)
    bc.SetBool(c4d.PS_AGEON,True)
    bc.SetBool(c4d.PS_USEDIST,True)
    bc.SetBool(c4d.PS_USEEPLANE,True)
    bc.SetFloat(c4d.PS_NEARDIST,0.1)
    bc.SetFloat(c4d.PS_FARDIST,0.1)
    bc.SetBool(c4d.PS_USERADDIST,True)
    bc.SetInt32(c4d.PS_EMITTERDIR,c4d.PS_EMITTERDIR_X)
    bc.SetFloat(c4d.PS_NEARRADDIST,0.1)
    bc.SetFloat(c4d.PS_FARRADDIST,0.1)
    bc.SetInt32(c4d.PS_SHP_TYPE,c4d.PART_SHAPE_SPHERE)
    bc.SetFloat(c4d.PS_SHP_RADIUS,0.1)
    bc.SetBool(c4d.PS_SHP_HEMI,True)
    bc.SetFloat(c4d.PS_SHP_HEMILEN,0.1)
    bc.SetBool(c4d.PS_SHP_USETM,True)
    bc.SetBool(c4d.PS_SHP_AUTOROT,True)
    bc.SetVector(c4d.PS_SHP_ROTVECTOR, c4d.Vector(1.0,1.0,1.0)
    bc.SetVector(c4d.PS_SHP_SCALE, c4d.Vector(1.0,1.0,1.0)
    bc.SetVector(c4d.PS_SHP_VELSCALE, c4d.Vector(1.0,1.0,1.0)
    bc.SetBool(c4d.PS_SHP_PREVIEW,True)
    bc.SetInt32(c4d.PS_SHP_VISIBLE,1)
    bc.SetBool(c4d.PS_IL_ON,True)
    bc.SetInt32(c4d.PS_IL_MODE,c4d.PS_IL_MODE_ISOTROPIC)
    bc.SetFloat(c4d.PS_IL_SELF,0.1)
    bc.SetFloat(c4d.PS_IL_TRANS,0.1)
    bc.SetFloat(c4d.PS_IL_SHINY,0.1)
    bc.SetFloat(c4d.PS_IL_STRENGTH,0.1)
    bc.SetFloat(c4d.PS_IL_SOFTEN,0.1)
    bc.SetFloat(c4d.PS_IL_BUMP,0.1)
    bc.SetBool(c4d.PS_SH_RECVSHADOWS,True)
    bc.SetBool(c4d.PS_SH_CASTSHADOWS,True)
    bc.SetBool(c4d.PS_SH_SELFSHADOWS,True)
    bc.SetFloat(c4d.PS_SH_TRANS,0.1)
    bc.SetBool(c4d.PS_SH_CFILTER,True)
    bc.SetBool(c4d.PS_SH_MAPSAMPLESON,True)
    bc.SetFloat(c4d.PS_SH_MAPSAMPLES,0.1)
    bc.SetBool(c4d.PS_SH_TRACEDSAMPLESON,True)
    bc.SetFloat(c4d.PS_SH_TRACEDSAMPLES,0.1)
    bc.SetBool(c4d.PS_SH_DARKALPHA,True)
    bc.SetFloat(c4d.PS_SH_DARKFAC,0.1)
    bc.SetFloat(c4d.PS_SH_DARKBRIGHT,0.1)
    bc.SetBool(c4d.PS_SH_USESELFOPT,True)
    bc.SetFloat(c4d.PS_SH_SELFBIAS,0.1)
    bc.SetFloat(c4d.PS_SH_SELFSAMPLES,0.1)
    bc.SetBool(c4d.PS_FFON,True)
    bc.SetInt32(c4d.PS_FF_TYPE,c4d.PS_FF_TYPE_GAS)
    bc.SetFloat(c4d.PS_FF_REGULAR,0.1)
    bc.SetFloat(c4d.PS_FF_GROWRAD,0.1)
    bc.SetFloat(c4d.PS_FF_SCALE,0.1)
    bc.SetFloat(c4d.PS_FF_EXP,0.1)
    bc.SetFloat(c4d.PS_FF_LEVEL,0.1)
    bc.SetFloat(c4d.PS_FF_PHASE,0.1)
    bc.SetFloat(c4d.PS_FF_GAIN,0.1)
    bc.SetFloat(c4d.PS_FF_BIAS,0.1)
    bc.SetFloat(c4d.PS_FF_LOWTHRESH,0.1)
    bc.SetFloat(c4d.PS_FF_HIGHTHRESH,0.1)
    bc.SetBool(c4d.PS_FF_COLORON,True)
    bc.SetBool(c4d.PS_FF_PSTATIC,True)
    bc.SetBool(c4d.PS_FF_NOSCALE,True)
    bc.SetBool(c4d.PS_FF_INVERT,True)

if __name__=='__main__':
    main()

C++

#include "c4d.h"
#include "../advanced_render/description/pyroshader.h"
void SampleFunction()
{
    BaseDocument *pDoc = GetActiveDocument();
    BaseMaterial *pMaterial = BaseMaterial::Alloc(PyroShader);  
    
    //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;
    pMaterial->SetParameter(DescID(PYRO_PAGE_GLOBALS),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_AGE),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_DIST),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_RADDIST),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_SHP),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_IL),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_SH),GeData(true),flags);
    pMaterial->SetParameter(DescID(PYRO_PAGE_FF),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_ON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SAMPLES),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_PARTLUM),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_DENSITY),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_GRADMODE),GeData(GRAD_MODE_FLAT),flags);
    pMaterial->SetParameter(DescID(PS_GRADMIN),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_GRADMAX),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_INTERSECT),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_ISECTBIAS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SETTINGS),GeData(PS_SET_FIRE),flags);
    pMaterial->SetParameter(DescID(PS_AGEON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_USEDIST),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_USEEPLANE),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_NEARDIST),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FARDIST),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_USERADDIST),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_EMITTERDIR),GeData(PS_EMITTERDIR_X),flags);
    pMaterial->SetParameter(DescID(PS_NEARRADDIST),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FARRADDIST),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SHP_TYPE),GeData(PART_SHAPE_SPHERE),flags);
    pMaterial->SetParameter(DescID(PS_SHP_RADIUS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SHP_HEMI),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SHP_HEMILEN),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SHP_USETM),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SHP_AUTOROT),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SHP_ROTVECTOR),GeData(Vector(1.0,1.0,1.0)),flags);
    pMaterial->SetParameter(DescID(PS_SHP_SCALE),GeData(Vector(1.0,1.0,1.0)),flags);
    pMaterial->SetParameter(DescID(PS_SHP_VELSCALE),GeData(Vector(1.0,1.0,1.0)),flags);
    pMaterial->SetParameter(DescID(PS_SHP_PREVIEW),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SHP_VISIBLE),GeData(1),flags);
    pMaterial->SetParameter(DescID(PS_IL_ON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_IL_MODE),GeData(PS_IL_MODE_ISOTROPIC),flags);
    pMaterial->SetParameter(DescID(PS_IL_SELF),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_IL_TRANS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_IL_SHINY),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_IL_STRENGTH),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_IL_SOFTEN),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_IL_BUMP),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_RECVSHADOWS),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_CASTSHADOWS),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_SELFSHADOWS),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_TRANS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_CFILTER),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_MAPSAMPLESON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_MAPSAMPLES),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_TRACEDSAMPLESON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_TRACEDSAMPLES),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_DARKALPHA),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_DARKFAC),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_DARKBRIGHT),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_USESELFOPT),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_SH_SELFBIAS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_SH_SELFSAMPLES),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FFON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_FF_TYPE),GeData(PS_FF_TYPE_GAS),flags);
    pMaterial->SetParameter(DescID(PS_FF_REGULAR),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_GROWRAD),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_SCALE),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_EXP),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_LEVEL),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_PHASE),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_GAIN),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_BIAS),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_LOWTHRESH),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_HIGHTHRESH),GeData(0.1),flags);
    pMaterial->SetParameter(DescID(PS_FF_COLORON),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_FF_PSTATIC),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_FF_NOSCALE),GeData(true),flags);
    pMaterial->SetParameter(DescID(PS_FF_INVERT),GeData(true),flags);
    pMaterial->Message(MSG_UPDATE);            

    //Second way, using the base container.
    BaseContainer *bc =     pMaterial->GetDataInstance();
    bc->SetBool(PYRO_PAGE_GLOBALS,true);
    bc->SetBool(PYRO_PAGE_AGE,true);
    bc->SetBool(PYRO_PAGE_DIST,true);
    bc->SetBool(PYRO_PAGE_RADDIST,true);
    bc->SetBool(PYRO_PAGE_SHP,true);
    bc->SetBool(PYRO_PAGE_IL,true);
    bc->SetBool(PYRO_PAGE_SH,true);
    bc->SetBool(PYRO_PAGE_FF,true);
    bc->SetBool(PS_ON,true);
    bc->SetFloat(PS_SAMPLES,0.1);
    bc->SetFloat(PS_PARTLUM,0.1);
    bc->SetFloat(PS_DENSITY,0.1);
    bc->SetInt32(PS_GRADMODE,GRAD_MODE_FLAT);
    bc->SetFloat(PS_GRADMIN,0.1);
    bc->SetFloat(PS_GRADMAX,0.1);
    bc->SetBool(PS_INTERSECT,true);
    bc->SetFloat(PS_ISECTBIAS,0.1);
    bc->SetInt32(PS_SETTINGS,PS_SET_FIRE);
    bc->SetBool(PS_AGEON,true);
    bc->SetBool(PS_USEDIST,true);
    bc->SetBool(PS_USEEPLANE,true);
    bc->SetFloat(PS_NEARDIST,0.1);
    bc->SetFloat(PS_FARDIST,0.1);
    bc->SetBool(PS_USERADDIST,true);
    bc->SetInt32(PS_EMITTERDIR,PS_EMITTERDIR_X);
    bc->SetFloat(PS_NEARRADDIST,0.1);
    bc->SetFloat(PS_FARRADDIST,0.1);
    bc->SetInt32(PS_SHP_TYPE,PART_SHAPE_SPHERE);
    bc->SetFloat(PS_SHP_RADIUS,0.1);
    bc->SetBool(PS_SHP_HEMI,true);
    bc->SetFloat(PS_SHP_HEMILEN,0.1);
    bc->SetBool(PS_SHP_USETM,true);
    bc->SetBool(PS_SHP_AUTOROT,true);
    bc->SetVector(PS_SHP_ROTVECTOR, c4d.Vector(1.0,1.0,1.0);
    bc->SetVector(PS_SHP_SCALE, c4d.Vector(1.0,1.0,1.0);
    bc->SetVector(PS_SHP_VELSCALE, c4d.Vector(1.0,1.0,1.0);
    bc->SetBool(PS_SHP_PREVIEW,true);
    bc->SetInt32(PS_SHP_VISIBLE,1);
    bc->SetBool(PS_IL_ON,true);
    bc->SetInt32(PS_IL_MODE,PS_IL_MODE_ISOTROPIC);
    bc->SetFloat(PS_IL_SELF,0.1);
    bc->SetFloat(PS_IL_TRANS,0.1);
    bc->SetFloat(PS_IL_SHINY,0.1);
    bc->SetFloat(PS_IL_STRENGTH,0.1);
    bc->SetFloat(PS_IL_SOFTEN,0.1);
    bc->SetFloat(PS_IL_BUMP,0.1);
    bc->SetBool(PS_SH_RECVSHADOWS,true);
    bc->SetBool(PS_SH_CASTSHADOWS,true);
    bc->SetBool(PS_SH_SELFSHADOWS,true);
    bc->SetFloat(PS_SH_TRANS,0.1);
    bc->SetBool(PS_SH_CFILTER,true);
    bc->SetBool(PS_SH_MAPSAMPLESON,true);
    bc->SetFloat(PS_SH_MAPSAMPLES,0.1);
    bc->SetBool(PS_SH_TRACEDSAMPLESON,true);
    bc->SetFloat(PS_SH_TRACEDSAMPLES,0.1);
    bc->SetBool(PS_SH_DARKALPHA,true);
    bc->SetFloat(PS_SH_DARKFAC,0.1);
    bc->SetFloat(PS_SH_DARKBRIGHT,0.1);
    bc->SetBool(PS_SH_USESELFOPT,true);
    bc->SetFloat(PS_SH_SELFBIAS,0.1);
    bc->SetFloat(PS_SH_SELFSAMPLES,0.1);
    bc->SetBool(PS_FFON,true);
    bc->SetInt32(PS_FF_TYPE,PS_FF_TYPE_GAS);
    bc->SetFloat(PS_FF_REGULAR,0.1);
    bc->SetFloat(PS_FF_GROWRAD,0.1);
    bc->SetFloat(PS_FF_SCALE,0.1);
    bc->SetFloat(PS_FF_EXP,0.1);
    bc->SetFloat(PS_FF_LEVEL,0.1);
    bc->SetFloat(PS_FF_PHASE,0.1);
    bc->SetFloat(PS_FF_GAIN,0.1);
    bc->SetFloat(PS_FF_BIAS,0.1);
    bc->SetFloat(PS_FF_LOWTHRESH,0.1);
    bc->SetFloat(PS_FF_HIGHTHRESH,0.1);
    bc->SetBool(PS_FF_COLORON,true);
    bc->SetBool(PS_FF_PSTATIC,true);
    bc->SetBool(PS_FF_NOSCALE,true);
    bc->SetBool(PS_FF_INVERT,true);
    pMaterial->Message(MSG_UPDATE);                                                      
}

Buttons

This node has buttons. Buttons can manually be executed by calling the following code

Python

c4d.CallButton(material,c4d.PS_PREVIEW)
c4d.CallButton(material,c4d.PS_IL_HIGHLIGHT)

C++

DescriptionCommand dc;
dc.id = DescID(PS_PREVIEW);             
pMaterial->Message(MSG_DESCRIPTION_COMMAND, &dc);


DescriptionCommand dc;
dc.id = DescID(PS_IL_HIGHLIGHT);             
pMaterial->Message(MSG_DESCRIPTION_COMMAND, &dc);

Gradients

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

Python



C++
 

           
#include "customgui_gradient.h"

PS_GRADPART
                                
GeData data;
pMaterial->GetParameter(DescID(PS_GRADPART),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);
}
pMaterial->SetParameter(DescID(PS_GRADPART),data,DESCFLAGS_SET_PARAM_SET));

PS_AGERAD
                                
pMaterial->GetParameter(DescID(PS_AGERAD),data,DESCFLAGS_GET_PARAM_GET));

PS_AGEPLUM
                                
pMaterial->GetParameter(DescID(PS_AGEPLUM),data,DESCFLAGS_GET_PARAM_GET));

PS_AGEMIX
                                
pMaterial->GetParameter(DescID(PS_AGEMIX),data,DESCFLAGS_GET_PARAM_GET));

PS_GRADLIFE
                                
pMaterial->GetParameter(DescID(PS_GRADLIFE),data,DESCFLAGS_GET_PARAM_GET));

PS_DISTRAD
                                
pMaterial->GetParameter(DescID(PS_DISTRAD),data,DESCFLAGS_GET_PARAM_GET));

PS_DISTPLUM
                                
pMaterial->GetParameter(DescID(PS_DISTPLUM),data,DESCFLAGS_GET_PARAM_GET));

PS_DISTMIX
                                
pMaterial->GetParameter(DescID(PS_DISTMIX),data,DESCFLAGS_GET_PARAM_GET));

PS_DISTGRAD
                                
pMaterial->GetParameter(DescID(PS_DISTGRAD),data,DESCFLAGS_GET_PARAM_GET));

PS_RADDISTRAD
                                
pMaterial->GetParameter(DescID(PS_RADDISTRAD),data,DESCFLAGS_GET_PARAM_GET));

PS_RADDISTPLUM
                                
pMaterial->GetParameter(DescID(PS_RADDISTPLUM),data,DESCFLAGS_GET_PARAM_GET));

PS_RADDISTMIX
                                
pMaterial->GetParameter(DescID(PS_RADDISTMIX),data,DESCFLAGS_GET_PARAM_GET));

PS_RADDISTGRAD
                                
pMaterial->GetParameter(DescID(PS_RADDISTGRAD),data,DESCFLAGS_GET_PARAM_GET));

PS_FF_COLOR
                                
pMaterial->GetParameter(DescID(PS_FF_COLOR),data,DESCFLAGS_GET_PARAM_GET));