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 XVPrender

IDs and information for XVPrender

XVPrender

Attributes

  • ENGLISH NAME : XPRender
  • NAME : XVPrender
  • INCLUDE : VPbase
  • PATH : res/description/xvprender.res
  • PLUGIN : X-Particles
  • MAXON online help (may not exist): XVPRENDER

Elements

ID UI Name Type Parameters Cycle
XP_RENDER_BLEND Blend LONG  
XP_RENDER_BLEND_NORMAL Normal
XP_RENDER_BLEND_ADD Add
XP_RENDER_RENDER RenderMode LONG HIDDEN
XP_RENDER_RENDER_RAY Ray
XP_RENDER_RENDER_SOFT SoftRay
XP_RENDER_RENDER_CUSTOM Custom
XP_RENDER_RENDER_AA Softness REAL
HIDDEN
UNIT PERCENT
MIN 0.0
MAXSLIDER 100.0
MAX 1000.0
CUSTOMGUI REALSLIDER
SCALE_H
XP_RENDER_SHADOWS Shadows LONG HIDDEN
XP_RENDER_SHADOWS_AUTO Auto
XP_RENDER_SHADOWS_RAY Ray
XP_RENDER_SHADOWS_SOFT_MAP SoftMap
XP_RENDER_SHADOWS_SOFT SoftRay
XP_RENDER_SHADOWS_CUSTOM Custom
XP_RENDER_SHADOW_AA ShadowSoftness REAL
HIDDEN
UNIT PERCENT
MIN 0.0
MAXSLIDER 100.0
MAX 1000.0
CUSTOMGUI REALSLIDER
SCALE_H
XP_RENDER_SHADOW_DEPTH_DELTA ShadowDepthThreshold REAL
UNIT METER
MIN 0.0
MAXSLIDER 10.0
STEP 0.1
CUSTOMGUI REALSLIDER
SCALE_H
XP_RENDER_SHADOW_TRANS_DELTA ShadowTransThreshold REAL
UNIT PERCENT
MIN 0.0
MAXSLIDER 100.0
STEP 0.1
CUSTOMGUI REALSLIDER
SCALE_H
XP_RENDER_SCREEN_SPACE HighQRender BOOL  
XP_RENDER_TRACER Reflections/Refraction BOOL  
XP_RENDER_SIMPLE_COL_SAMPLE CacheSampling BOOL  
XP_RENDER_SIMPLE_SHADOW_SAMPLE CacheShadowSampling BOOL  
XP_RENDER_VOLUME_ADAPTIVE Adaptive BOOL PARENTCOLLAPSE
XP_RENDER_VOLUME_STEP VolumeStep REAL
UNIT METER
MIN 0.0
XP_RENDER_VOLUME_ADAPTIVE_Z_MIN ZMin REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_ADAPTIVE
XP_RENDER_VOLUME_ADAPTIVE_Z_MAX ZMax REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_ADAPTIVE
XP_RENDER_VOLUME_ADAPTIVE_MAX_STEP MaxStep REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_ADAPTIVE
XP_RENDER_VOLUME_SHD_ADAPTIVE Adaptive BOOL PARENTCOLLAPSE
XP_RENDER_VOLUME_SHD_STEP ShadowStep REAL
UNIT METER
MIN 0.0
XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MIN ZMin REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_SHD_ADAPTIVE
XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MAX ZMax REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_SHD_ADAPTIVE
XP_RENDER_VOLUME_SHD_ADAPTIVE_MAX_STEP MaxStep REAL
UNIT METER
MIN 0.0
PARENTCOLLAPSE XP_RENDER_VOLUME_SHD_ADAPTIVE
XP_RENDER_FILTER Filter BOOL  
XP_RENDER_FILTER_SAMPLES Samples LONG
MIN 1
MAX 1000
XP_RENDER_FILTER_TYPE Type LONG  
XP_RENDER_FILTER_TYPE_LINEAR Linear
XP_RENDER_FILTER_TYPE_CUBIC Cubic
XPRENDER_HELP_BUTTON BITMAPBUTTON  
XP_RENDER_MP_PPASS X-ParticlesPositionPass BOOL  
XP_RENDER_MP_NPASS X-ParticlesNormalsPass BOOL  
XP_RENDER_MP_SCALE Scale REAL MIN
XP_RENDER_MP_INVZ InvertZ BOOL  
XP_RENDER_MP_RGBOUT Output LONG  
XP_RENDER_MP_RGBOUT_RGB RGB
XP_RENDER_MP_RGBOUT_RBG RBG
XP_RENDER_MP_RGBOUT_GBR GBR
XP_RENDER_MP_RGBOUT_GRB GRB
XP_RENDER_MP_RGBOUT_BGR BGR
XP_RENDER_MP_RGBOUT_BRG BRG
XP_RENDER_MP_SPACE Space LONG  
XP_RENDER_MP_SPACE_WORLD World
XP_RENDER_MP_SPACE_CAMERA Camera
XP_RENDER_MP_SPACE_OBJECT Object

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():
    videoPost = c4d.BaseVideoPost(c4d.XVPrender)
    
    #You can set parameters two different ways. 
    #First way              
    videoPost[c4d.XP_RENDER_BLEND] = c4d.XP_RENDER_BLEND_NORMAL
    videoPost[c4d.XP_RENDER_RENDER] = c4d.XP_RENDER_RENDER_RAY
    videoPost[c4d.XP_RENDER_RENDER_AA] = 0.1
    videoPost[c4d.XP_RENDER_SHADOWS] = c4d.XP_RENDER_SHADOWS_AUTO
    videoPost[c4d.XP_RENDER_SHADOW_AA] = 0.1
    videoPost[c4d.XP_RENDER_SHADOW_DEPTH_DELTA] = 0.1
    videoPost[c4d.XP_RENDER_SHADOW_TRANS_DELTA] = 0.1
    videoPost[c4d.XP_RENDER_SCREEN_SPACE] = True
    videoPost[c4d.XP_RENDER_TRACER] = True
    videoPost[c4d.XP_RENDER_SIMPLE_COL_SAMPLE] = True
    videoPost[c4d.XP_RENDER_SIMPLE_SHADOW_SAMPLE] = True
    videoPost[c4d.XP_RENDER_VOLUME_ADAPTIVE] = True
    videoPost[c4d.XP_RENDER_VOLUME_STEP] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_ADAPTIVE_Z_MIN] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_ADAPTIVE_Z_MAX] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_ADAPTIVE_MAX_STEP] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE] = True
    videoPost[c4d.XP_RENDER_VOLUME_SHD_STEP] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MIN] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MAX] = 0.1
    videoPost[c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_MAX_STEP] = 0.1
    videoPost[c4d.XP_RENDER_FILTER] = True
    videoPost[c4d.XP_RENDER_FILTER_SAMPLES] = 1
    videoPost[c4d.XP_RENDER_FILTER_TYPE] = c4d.XP_RENDER_FILTER_TYPE_LINEAR
    videoPost[c4d.XP_RENDER_MP_PPASS] = True
    videoPost[c4d.XP_RENDER_MP_NPASS] = True
    videoPost[c4d.XP_RENDER_MP_SCALE] = 0.1
    videoPost[c4d.XP_RENDER_MP_INVZ] = True
    videoPost[c4d.XP_RENDER_MP_RGBOUT] = c4d.XP_RENDER_MP_RGBOUT_RGB
    videoPost[c4d.XP_RENDER_MP_SPACE] = c4d.XP_RENDER_MP_SPACE_WORLD
    
    #Second way, using the base container.
    bc = videoPost.GetDataInstance()
    bc.SetInt32(c4d.XP_RENDER_BLEND,c4d.XP_RENDER_BLEND_NORMAL)
    bc.SetInt32(c4d.XP_RENDER_RENDER,c4d.XP_RENDER_RENDER_RAY)
    bc.SetFloat(c4d.XP_RENDER_RENDER_AA,0.1)
    bc.SetInt32(c4d.XP_RENDER_SHADOWS,c4d.XP_RENDER_SHADOWS_AUTO)
    bc.SetFloat(c4d.XP_RENDER_SHADOW_AA,0.1)
    bc.SetFloat(c4d.XP_RENDER_SHADOW_DEPTH_DELTA,0.1)
    bc.SetFloat(c4d.XP_RENDER_SHADOW_TRANS_DELTA,0.1)
    bc.SetBool(c4d.XP_RENDER_SCREEN_SPACE,True)
    bc.SetBool(c4d.XP_RENDER_TRACER,True)
    bc.SetBool(c4d.XP_RENDER_SIMPLE_COL_SAMPLE,True)
    bc.SetBool(c4d.XP_RENDER_SIMPLE_SHADOW_SAMPLE,True)
    bc.SetBool(c4d.XP_RENDER_VOLUME_ADAPTIVE,True)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_STEP,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_ADAPTIVE_Z_MIN,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_ADAPTIVE_Z_MAX,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_ADAPTIVE_MAX_STEP,0.1)
    bc.SetBool(c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE,True)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_SHD_STEP,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MIN,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MAX,0.1)
    bc.SetFloat(c4d.XP_RENDER_VOLUME_SHD_ADAPTIVE_MAX_STEP,0.1)
    bc.SetBool(c4d.XP_RENDER_FILTER,True)
    bc.SetInt32(c4d.XP_RENDER_FILTER_SAMPLES,1)
    bc.SetInt32(c4d.XP_RENDER_FILTER_TYPE,c4d.XP_RENDER_FILTER_TYPE_LINEAR)
    bc.SetBool(c4d.XP_RENDER_MP_PPASS,True)
    bc.SetBool(c4d.XP_RENDER_MP_NPASS,True)
    bc.SetFloat(c4d.XP_RENDER_MP_SCALE,0.1)
    bc.SetBool(c4d.XP_RENDER_MP_INVZ,True)
    bc.SetInt32(c4d.XP_RENDER_MP_RGBOUT,c4d.XP_RENDER_MP_RGBOUT_RGB)
    bc.SetInt32(c4d.XP_RENDER_MP_SPACE,c4d.XP_RENDER_MP_SPACE_WORLD)

if __name__=='__main__':
    main()

C++

#include "c4d.h"
#include "../res/description/xvprender.h"
void SampleFunction()
{
    BaseDocument *pDoc = GetActiveDocument();
    BaseVideoPost *pVideoPost = BaseVideoPost::Alloc(XVPrender);  
    
    //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;
    pVideoPost->SetParameter(DescID(XP_RENDER_BLEND),GeData(XP_RENDER_BLEND_NORMAL),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_RENDER),GeData(XP_RENDER_RENDER_RAY),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_RENDER_AA),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SHADOWS),GeData(XP_RENDER_SHADOWS_AUTO),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SHADOW_AA),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SHADOW_DEPTH_DELTA),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SHADOW_TRANS_DELTA),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SCREEN_SPACE),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_TRACER),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SIMPLE_COL_SAMPLE),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_SIMPLE_SHADOW_SAMPLE),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_ADAPTIVE),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_STEP),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_ADAPTIVE_Z_MIN),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_ADAPTIVE_Z_MAX),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_ADAPTIVE_MAX_STEP),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_SHD_ADAPTIVE),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_SHD_STEP),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MIN),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MAX),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_VOLUME_SHD_ADAPTIVE_MAX_STEP),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_FILTER),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_FILTER_SAMPLES),GeData(1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_FILTER_TYPE),GeData(XP_RENDER_FILTER_TYPE_LINEAR),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_PPASS),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_NPASS),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_SCALE),GeData(0.1),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_INVZ),GeData(true),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_RGBOUT),GeData(XP_RENDER_MP_RGBOUT_RGB),flags);
    pVideoPost->SetParameter(DescID(XP_RENDER_MP_SPACE),GeData(XP_RENDER_MP_SPACE_WORLD),flags);
    pVideoPost->Message(MSG_UPDATE);            

    //Second way, using the base container.
    BaseContainer *bc =     pVideoPost->GetDataInstance();
    bc->SetInt32(XP_RENDER_BLEND,XP_RENDER_BLEND_NORMAL);
    bc->SetInt32(XP_RENDER_RENDER,XP_RENDER_RENDER_RAY);
    bc->SetFloat(XP_RENDER_RENDER_AA,0.1);
    bc->SetInt32(XP_RENDER_SHADOWS,XP_RENDER_SHADOWS_AUTO);
    bc->SetFloat(XP_RENDER_SHADOW_AA,0.1);
    bc->SetFloat(XP_RENDER_SHADOW_DEPTH_DELTA,0.1);
    bc->SetFloat(XP_RENDER_SHADOW_TRANS_DELTA,0.1);
    bc->SetBool(XP_RENDER_SCREEN_SPACE,true);
    bc->SetBool(XP_RENDER_TRACER,true);
    bc->SetBool(XP_RENDER_SIMPLE_COL_SAMPLE,true);
    bc->SetBool(XP_RENDER_SIMPLE_SHADOW_SAMPLE,true);
    bc->SetBool(XP_RENDER_VOLUME_ADAPTIVE,true);
    bc->SetFloat(XP_RENDER_VOLUME_STEP,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_ADAPTIVE_Z_MIN,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_ADAPTIVE_Z_MAX,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_ADAPTIVE_MAX_STEP,0.1);
    bc->SetBool(XP_RENDER_VOLUME_SHD_ADAPTIVE,true);
    bc->SetFloat(XP_RENDER_VOLUME_SHD_STEP,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MIN,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_SHD_ADAPTIVE_Z_MAX,0.1);
    bc->SetFloat(XP_RENDER_VOLUME_SHD_ADAPTIVE_MAX_STEP,0.1);
    bc->SetBool(XP_RENDER_FILTER,true);
    bc->SetInt32(XP_RENDER_FILTER_SAMPLES,1);
    bc->SetInt32(XP_RENDER_FILTER_TYPE,XP_RENDER_FILTER_TYPE_LINEAR);
    bc->SetBool(XP_RENDER_MP_PPASS,true);
    bc->SetBool(XP_RENDER_MP_NPASS,true);
    bc->SetFloat(XP_RENDER_MP_SCALE,0.1);
    bc->SetBool(XP_RENDER_MP_INVZ,true);
    bc->SetInt32(XP_RENDER_MP_RGBOUT,XP_RENDER_MP_RGBOUT_RGB);
    bc->SetInt32(XP_RENDER_MP_SPACE,XP_RENDER_MP_SPACE_WORLD);
    pVideoPost->Message(MSG_UPDATE);                                                      
}

Buttons

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

Python

c4d.CallButton(videoPost,c4d.XPRENDER_HELP_BUTTON)

C++

DescriptionCommand dc;
dc.id = DescID(XPRENDER_HELP_BUTTON);             
pVideoPost->Message(MSG_DESCRIPTION_COMMAND, &dc);