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 Xxmbsubsurface

IDs and information for Xxmbsubsurface

Xxmbsubsurface

Attributes

  • ENGLISH NAME : SubsurfaceScatteringShader
  • NAME : Xxmbsubsurface
  • INCLUDE : Mpreview
  • INCLUDE : Xbase
  • PATH : c4dplugin/description/xxmbsubsurface.res
  • PLUGIN : c4dplugin
  • MAXON online help (may not exist): XXMBSUBSURFACE

Elements

ID UI Name Type Parameters Cycle
XMBSUBSURFACESHADER_PRESET Preset LONG  
XMBSUBSURFACESHADER_PRESET_CUSTOM Custom
XMBSUBSURFACESHADER_PRESET_APPLE Apple
XMBSUBSURFACESHADER_PRESET_CHICKEN Chicken
XMBSUBSURFACESHADER_PRESET_CREAM Cream
XMBSUBSURFACESHADER_PRESET_KETCHUP Ketchup
XMBSUBSURFACESHADER_PRESET_MARBLE Marble
XMBSUBSURFACESHADER_PRESET_MILK_SKIM Milk(Skim)
XMBSUBSURFACESHADER_PRESET_MILK_WHOLE Milk(Whole)
XMBSUBSURFACESHADER_PRESET_POTATO Potato
XMBSUBSURFACESHADER_PRESET_SKIN_DARK Skin(Dark)
XMBSUBSURFACESHADER_PRESET_SKIN_LIGHT Skin(Light)
XMBSUBSURFACESHADER_PRESET_SPECTRALON Spectralon
XMBSUBSURFACESHADER_DIFFUSE Color COLOR OPEN
XMBSUBSURFACESHADER_STRENGTH Strength REAL
UNIT PERCENT
MIN 0.0
MAX 10000.0
MINSLIDER 0.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_SHADER Shader SHADERLINK  
XMBSUBSURFACESHADER_LENGTH PathLength REAL
PARENTCOLLAPSE
UNIT METER
MIN 0.001
MAX 100000.0
MINSLIDER 0.001
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_LENGTH_R Red REAL
PARENTCOLLAPSE XMBSUBSURFACESHADER_LENGTH
UNIT PERCENT
MIN 0.01
MAX 10000.0
MINSLIDER 100.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_LENGTH_G Green REAL
PARENTCOLLAPSE XMBSUBSURFACESHADER_LENGTH
UNIT PERCENT
MIN 0.01
MAX 10000.0
MINSLIDER 100.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_LENGTH_B Blue REAL
PARENTCOLLAPSE XMBSUBSURFACESHADER_LENGTH
UNIT PERCENT
MIN 0.01
MAX 10000.0
MINSLIDER 100.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_MULTIPLE_MODE Mode LONG  
XMBSUBSURFACESHADER_MULTIPLE_MODE_CACHE Cache
XMBSUBSURFACESHADER_MULTIPLE_MODE_DIRECT Direct
XMBSUBSURFACESHADER_MULTIPLE_ENABLED Enabled BOOL  
XMBSUBSURFACESHADER_CACHE_INTERPOLATION FastEvaluation BOOL ANIM
XMBSUBSURFACESHADER_CACHE_SAMPLE_DENSITY SampleDensity REAL
UNIT PERCENT
MIN 10.0
MAX 1000.0
MINSLIDER 10.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_CACHE_SMOOTHING Smoothing REAL
UNIT PERCENT
MIN 0.0
MAX 1000.0
MINSLIDER 0.0
MAXSLIDER 1000.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_CACHE_ERROR Threshold REAL
MIN 0.01
MAX 1.0
STEP 0.01
MINSLIDER 0.01
MAXSLIDER 1.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_DIRECT_SPLIT SeparateColorChannels BOOL  
XMBSUBSURFACESHADER_DIRECT_RATIO MinimumThreshold REAL
MIN 0.0
MAX 1.0
STEP 0.01
MINSLIDER 0.0
MAXSLIDER 1.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_ENABLED CustomSampling BOOL ANIM
XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_SAMPLING SamplingSubdivision REAL
MIN 0.0
MAX 16.0
STEP 0.01
MINSLIDER 0.0
MAXSLIDER 16.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_SINGLE_ENABLED Enabled BOOL  
XMBSUBSURFACESHADER_SINGLE_SPLIT SeparateColorChannels BOOL  
XMBSUBSURFACESHADER_SINGLE_TRACE TraceShadowRays BOOL  
XMBSUBSURFACESHADER_SINGLE_PHASE PhaseFunction REAL
MIN -1.0
MAX 1.0
STEP 0.01
MINSLIDER -1.0
MAXSLIDER 1.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_SINGLE_CUSTOM_ENABLED CustomSampling BOOL ANIM
XMBSUBSURFACESHADER_SINGLE_CUSTOM_SAMPLING SamplingSubdivision REAL
MIN 0.0
MAX 16.0
STEP 0.01
MINSLIDER 0.0
MAXSLIDER 16.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_FRESNEL FresnelReflectivity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
MINSLIDER 0.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_DITHER Dithering REAL
UNIT PERCENT
MIN 0.0
MAX 500.0
MINSLIDER 0.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_IOR IndexofRefraction REAL
MIN 1.0
MAX 2.0
STEP 0.01
MINSLIDER 1.0
MAXSLIDER 2.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_LIGHTS_GI ComputeGIContribution BOOL  
XMBSUBSURFACESHADER_LIGHTS_MODE UseLights LONG  
XMBSUBSURFACESHADER_LIGHTS_MODE_INCLUDE Include
XMBSUBSURFACESHADER_LIGHTS_MODE_EXCLUDE Exclude
XMBSUBSURFACESHADER_LIGHTS Lights IN_EXCLUDE
NUM_FLAGS 0
INIT_STATE 0
SEND_SELCHNGMSG 1
XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT Strength REAL
PARENTCOLLAPSE
MIN 0.0
MAX 100.0
UNIT PERCENT
MINSLIDER 0.0
MAXSLIDER 100.0
STEP 1.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT_SHADER Texture SHADERLINK PARENTCOLLAPSE
XMBSUBSURFACESHADER_GPURENDER_PRESET Preset LONG  
XMBSUBSURFACESHADER_PRESET_CUSTOM Custom
XMBSUBSURFACESHADER_PRESET_APPLE Apple
XMBSUBSURFACESHADER_PRESET_CHICKEN Chicken
XMBSUBSURFACESHADER_PRESET_CREAM Cream
XMBSUBSURFACESHADER_PRESET_KETCHUP Ketchup
XMBSUBSURFACESHADER_PRESET_MARBLE Marble
XMBSUBSURFACESHADER_PRESET_MILK_SKIM Milk(Skim)
XMBSUBSURFACESHADER_PRESET_MILK_WHOLE Milk(Whole)
XMBSUBSURFACESHADER_PRESET_POTATO Potato
XMBSUBSURFACESHADER_PRESET_SKIN_DARK Skin(Dark)
XMBSUBSURFACESHADER_PRESET_SKIN_LIGHT Skin(Light)
XMBSUBSURFACESHADER_PRESET_SPECTRALON Spectralon
XMBSUBSURFACESHADER_GPURENDER_SURFACE_COLOR ScatterColor COLOR PARENTCOLLAPSE
XMBSUBSURFACESHADER_GPURENDER_SURFACE_COLOR_SHADER Texture SHADERLINK PARENTCOLLAPSE
XMBSUBSURFACESHADER_GPURENDER_RADIUS_SCALE ScatterDepth REAL
MIN 0.0
MAX 100000.0
MINSLIDER 1.0
MAXSLIDER 1000.0
UNIT METER
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_GPURENDER_RADIUS_RGB DepthColor COLOR  
XMBSUBSURFACESHADER_GPURENDER_PHASE Phase REAL
MIN -1.0
MAX 1.0
STEP 0.01
MINSLIDER -1.0
MAXSLIDER 1.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_GPURENDER_IS_TRANSPARENT Transparent BOOL  
XMBSUBSURFACESHADER_GPURENDER_EMISSION_COLOR Emission COLOR PARENTCOLLAPSE
XMBSUBSURFACESHADER_GPURENDER_EMISSION_SHADER Texture SHADERLINK PARENTCOLLAPSE
XMBSUBSURFACESHADER_GPURENDER_EMISSION_BRIGHTNESS Intensity REAL
MIN 0.0
MAX 10000.0
MINSLIDER 0.0
MAXSLIDER 100.0
CUSTOMGUI REALSLIDER
XMBSUBSURFACESHADER_GPURENDER_MULTISCATTER_ENABLED EnableMulti-Scattering 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():
    shader = c4d.BaseShader(c4d.Xxmbsubsurface)
    
    #You can set parameters two different ways. 
    #First way              
    shader[c4d.XMBSUBSURFACESHADER_PRESET] = c4d.XMBSUBSURFACESHADER_PRESET_CUSTOM
    shader[c4d.XMBSUBSURFACESHADER_STRENGTH] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_LENGTH] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_LENGTH_R] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_LENGTH_G] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_LENGTH_B] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_MULTIPLE_MODE] = c4d.XMBSUBSURFACESHADER_MULTIPLE_MODE_CACHE
    shader[c4d.XMBSUBSURFACESHADER_MULTIPLE_ENABLED] = True
    shader[c4d.XMBSUBSURFACESHADER_CACHE_INTERPOLATION] = True
    shader[c4d.XMBSUBSURFACESHADER_CACHE_SAMPLE_DENSITY] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_CACHE_SMOOTHING] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_CACHE_ERROR] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_DIRECT_SPLIT] = True
    shader[c4d.XMBSUBSURFACESHADER_DIRECT_RATIO] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_ENABLED] = True
    shader[c4d.XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_SAMPLING] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_ENABLED] = True
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_SPLIT] = True
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_TRACE] = True
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_PHASE] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_CUSTOM_ENABLED] = True
    shader[c4d.XMBSUBSURFACESHADER_SINGLE_CUSTOM_SAMPLING] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_FRESNEL] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_DITHER] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_IOR] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_LIGHTS_GI] = True
    shader[c4d.XMBSUBSURFACESHADER_LIGHTS_MODE] = c4d.XMBSUBSURFACESHADER_LIGHTS_MODE_INCLUDE
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_PRESET] = c4d.XMBSUBSURFACESHADER_PRESET_CUSTOM
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_RADIUS_SCALE] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_PHASE] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_IS_TRANSPARENT] = True
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_EMISSION_BRIGHTNESS] = 0.1
    shader[c4d.XMBSUBSURFACESHADER_GPURENDER_MULTISCATTER_ENABLED] = True
    
    #Second way, using the base container.
    bc = shader.GetDataInstance()
    bc.SetInt32(c4d.XMBSUBSURFACESHADER_PRESET,c4d.XMBSUBSURFACESHADER_PRESET_CUSTOM)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_STRENGTH,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_LENGTH,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_LENGTH_R,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_LENGTH_G,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_LENGTH_B,0.1)
    bc.SetInt32(c4d.XMBSUBSURFACESHADER_MULTIPLE_MODE,c4d.XMBSUBSURFACESHADER_MULTIPLE_MODE_CACHE)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_MULTIPLE_ENABLED,True)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_CACHE_INTERPOLATION,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_CACHE_SAMPLE_DENSITY,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_CACHE_SMOOTHING,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_CACHE_ERROR,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_DIRECT_SPLIT,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_DIRECT_RATIO,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_ENABLED,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_SAMPLING,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_SINGLE_ENABLED,True)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_SINGLE_SPLIT,True)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_SINGLE_TRACE,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_SINGLE_PHASE,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_SINGLE_CUSTOM_ENABLED,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_SINGLE_CUSTOM_SAMPLING,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_FRESNEL,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_DITHER,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_IOR,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_LIGHTS_GI,True)
    bc.SetInt32(c4d.XMBSUBSURFACESHADER_LIGHTS_MODE,c4d.XMBSUBSURFACESHADER_LIGHTS_MODE_INCLUDE)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT,0.1)
    bc.SetInt32(c4d.XMBSUBSURFACESHADER_GPURENDER_PRESET,c4d.XMBSUBSURFACESHADER_PRESET_CUSTOM)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_GPURENDER_RADIUS_SCALE,0.1)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_GPURENDER_PHASE,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_GPURENDER_IS_TRANSPARENT,True)
    bc.SetFloat(c4d.XMBSUBSURFACESHADER_GPURENDER_EMISSION_BRIGHTNESS,0.1)
    bc.SetBool(c4d.XMBSUBSURFACESHADER_GPURENDER_MULTISCATTER_ENABLED,True)

if __name__=='__main__':
    main()

C++

#include "c4d.h"
#include "../c4dplugin/description/xxmbsubsurface.h"
void SampleFunction()
{
    BaseDocument *pDoc = GetActiveDocument();
    BaseShader *pShader = BaseShader::Alloc(Xxmbsubsurface);  
    
    //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;
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_PRESET),GeData(XMBSUBSURFACESHADER_PRESET_CUSTOM),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_STRENGTH),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LENGTH),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LENGTH_R),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LENGTH_G),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LENGTH_B),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_MULTIPLE_MODE),GeData(XMBSUBSURFACESHADER_MULTIPLE_MODE_CACHE),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_MULTIPLE_ENABLED),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_CACHE_INTERPOLATION),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_CACHE_SAMPLE_DENSITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_CACHE_SMOOTHING),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_CACHE_ERROR),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_DIRECT_SPLIT),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_DIRECT_RATIO),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_ENABLED),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_SAMPLING),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_ENABLED),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_SPLIT),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_TRACE),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_PHASE),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_CUSTOM_ENABLED),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_SINGLE_CUSTOM_SAMPLING),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_FRESNEL),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_DITHER),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_IOR),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LIGHTS_GI),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_LIGHTS_MODE),GeData(XMBSUBSURFACESHADER_LIGHTS_MODE_INCLUDE),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_PRESET),GeData(XMBSUBSURFACESHADER_PRESET_CUSTOM),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_RADIUS_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_PHASE),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_IS_TRANSPARENT),GeData(true),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_EMISSION_BRIGHTNESS),GeData(0.1),flags);
    pShader->SetParameter(DescID(XMBSUBSURFACESHADER_GPURENDER_MULTISCATTER_ENABLED),GeData(true),flags);
    pShader->Message(MSG_UPDATE);            

    //Second way, using the base container.
    BaseContainer *bc =     pShader->GetDataInstance();
    bc->SetInt32(XMBSUBSURFACESHADER_PRESET,XMBSUBSURFACESHADER_PRESET_CUSTOM);
    bc->SetFloat(XMBSUBSURFACESHADER_STRENGTH,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_LENGTH,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_LENGTH_R,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_LENGTH_G,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_LENGTH_B,0.1);
    bc->SetInt32(XMBSUBSURFACESHADER_MULTIPLE_MODE,XMBSUBSURFACESHADER_MULTIPLE_MODE_CACHE);
    bc->SetBool(XMBSUBSURFACESHADER_MULTIPLE_ENABLED,true);
    bc->SetBool(XMBSUBSURFACESHADER_CACHE_INTERPOLATION,true);
    bc->SetFloat(XMBSUBSURFACESHADER_CACHE_SAMPLE_DENSITY,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_CACHE_SMOOTHING,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_CACHE_ERROR,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_DIRECT_SPLIT,true);
    bc->SetFloat(XMBSUBSURFACESHADER_DIRECT_RATIO,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_ENABLED,true);
    bc->SetFloat(XMBSUBSURFACESHADER_MULTIPLE_CUSTOM_SAMPLING,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_SINGLE_ENABLED,true);
    bc->SetBool(XMBSUBSURFACESHADER_SINGLE_SPLIT,true);
    bc->SetBool(XMBSUBSURFACESHADER_SINGLE_TRACE,true);
    bc->SetFloat(XMBSUBSURFACESHADER_SINGLE_PHASE,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_SINGLE_CUSTOM_ENABLED,true);
    bc->SetFloat(XMBSUBSURFACESHADER_SINGLE_CUSTOM_SAMPLING,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_FRESNEL,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_DITHER,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_IOR,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_LIGHTS_GI,true);
    bc->SetInt32(XMBSUBSURFACESHADER_LIGHTS_MODE,XMBSUBSURFACESHADER_LIGHTS_MODE_INCLUDE);
    bc->SetFloat(XMBSUBSURFACESHADER_GPURENDER_SSS_WEIGHT,0.1);
    bc->SetInt32(XMBSUBSURFACESHADER_GPURENDER_PRESET,XMBSUBSURFACESHADER_PRESET_CUSTOM);
    bc->SetFloat(XMBSUBSURFACESHADER_GPURENDER_RADIUS_SCALE,0.1);
    bc->SetFloat(XMBSUBSURFACESHADER_GPURENDER_PHASE,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_GPURENDER_IS_TRANSPARENT,true);
    bc->SetFloat(XMBSUBSURFACESHADER_GPURENDER_EMISSION_BRIGHTNESS,0.1);
    bc->SetBool(XMBSUBSURFACESHADER_GPURENDER_MULTISCATTER_ENABLED,true);
    pShader->Message(MSG_UPDATE);                                                      
}