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 xbrick

IDs and information for xbrick

xbrick

Attributes

  • ENGLISH NAME : Brick
  • NAME : xbrick
  • INCLUDE : Mpreview
  • INCLUDE : Xbase
  • PATH : shader/description/xbrick.res
  • PLUGIN : shader
  • MAXON online help (may not exist): XBRICK

Elements

ID UI Name Type Parameters Cycle
BRICK_SCALE Scale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_WIDTH BrickWidth REAL
UNIT PERCENT
MIN 0
STEP 0.1
BRICK_HEIGHT BrickHeight REAL
UNIT PERCENT
MIN 0
STEP 0.1
BRICK_SHIFT Shift REAL
UNIT PERCENT
STEP 1.0
BRICK_SHIFT_RESET ResetEverynthRow LONG MIN
BRICK_HALFWIDTH HalfWidthEverynthRow LONG MIN
BRICK_HALFWIDTH_SHIFT Shift REAL
UNIT PERCENT
STEP 1.0
BRICK_ALTCOL_BALANCE_HPERIOD BalanceAlt.ColorPeriod BOOL  
BRICK_DISPLACEMENTMODE_ENABLE Enable BOOL  
BRICK_DISPLACEMENTMODE_RANDOM_HEIGHT HeightVariation REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_DISPLACEMENTMODE_RANDOM_SLOPE SlopeIntensity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_DISPLACEMENTMODE_SLOPE_MODE SlopeDirection LONG  
BRICK_DISPLACEMENTMODE_MODE_SLOPE_RANDOM Random
BRICK_DISPLACEMENTMODE_MODE_SLOPE_LEFT Left
BRICK_DISPLACEMENTMODE_MODE_SLOPE_RIGHT Right
BRICK_DISPLACEMENTMODE_MODE_SLOPE_UP Up
BRICK_DISPLACEMENTMODE_MODE_SLOPE_DOWN Down
BRICK_DISPLACEMENTMODE_SEED Seed LONG MIN
BRICK_COL BrickColor GRADIENT
COLOR
ICC_BASEDOCUMENT
BRICK_TEX_LINK Texture SHADERLINK  
BRICK_TEX_OFFSET Offset REAL
UNIT PERCENT
STEP 1.0
BRICK_TEX_OFFSET_RANDOM Random BOOL  
BRICK_TEX_SCALE Scale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_TEX_FLIP Flip BOOL  
BRICK_TEX_OPACITY Opacity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_TEX_BLENDMODE BlendMode LONG  
BRICK_BLENDMODE_NORMAL Normal
BRICK_BLENDMODE_MULTIPLY Multiply
BRICK_BLENDMODE_OVERLAY Overlay
BRICK_BLENDMODE_DODGE Dodge
BRICK_BLENDMODE_BURN Burn
BRICK_BLENDMODE_LIGHTEN Lighten
BRICK_BLENDMODE_DARKEN Darken
BRICK_BLENDMODE_COLOR Color
BRICK_ALTCOL Alt.BrickColor GRADIENT
COLOR
ICC_BASEDOCUMENT
BRICK_ALTTEX_LINK Texture SHADERLINK  
BRICK_ALTTEX_OFFSET Offset REAL
UNIT PERCENT
STEP 1.0
BRICK_ALTTEX_OFFSET_RANDOM Random BOOL  
BRICK_ALTTEX_SCALE Scale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_ALTTEX_FLIP Flip BOOL  
BRICK_ALTTEX_OPACITY Opacity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_ALTTEX_BLENDMODE BlendMode LONG  
BRICK_BLENDMODE_NORMAL Normal
BRICK_BLENDMODE_MULTIPLY Multiply
BRICK_BLENDMODE_OVERLAY Overlay
BRICK_BLENDMODE_DODGE Dodge
BRICK_BLENDMODE_BURN Burn
BRICK_BLENDMODE_LIGHTEN Lighten
BRICK_BLENDMODE_DARKEN Darken
BRICK_BLENDMODE_COLOR Color
BRICK_ALTCOL_VPERIOD Alt.ColorEverynRows LONG MIN
BRICK_ALTCOL_HPERIOD Alt.ColorEverynColumns LONG MIN
BRICK_COL_NOISE_SCALE BrickNoiseScale REAL
UNIT PERCENT
STEP 0.1
BRICK_COL_DETAILS_INTENSITY Detail REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_COL_DETAILS_SCALE DetailScale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_GAPCOL GapColor GRADIENT
COLOR
ICC_BASEDOCUMENT
BRICK_GAPTEX_LINK Texture SHADERLINK  
BRICK_GAPTEX_SCALE Scale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_GAPTEX_FLIP Flip BOOL  
BRICK_GAPTEX_OPACITY Opacity REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_GAPTEX_BLENDMODE BlendMode LONG  
BRICK_BLENDMODE_NORMAL Normal
BRICK_BLENDMODE_MULTIPLY Multiply
BRICK_BLENDMODE_OVERLAY Overlay
BRICK_BLENDMODE_DODGE Dodge
BRICK_BLENDMODE_BURN Burn
BRICK_BLENDMODE_LIGHTEN Lighten
BRICK_BLENDMODE_DARKEN Darken
BRICK_BLENDMODE_COLOR Color
BRICK_GAPCOL_NOISE_SCALE GapNoiseScale REAL
UNIT PERCENT
STEP 0.1
BRICK_DEPTH Depth REAL
UNIT PERCENT
MIN 0.0
STEP 0.1
BRICK_GAPSIZE Size REAL
UNIT PERCENT
MIN 0.0
STEP 0.1
BRICK_GAPNOTCH Groove REAL
UNIT PERCENT
MIN -100.0
MAX 100.0
BRICK_NOISE_INTENSITY SizeVariation REAL
UNIT PERCENT
MIN 0.0
MAX 100.0
STEP 1.0
BRICK_NOISE_SCALE SizeVariationScale REAL
UNIT PERCENT
MIN 0.0
STEP 1.0
BRICK_DIRT_ENABLE Enable BOOL  
BRICK_DIRT_ENABLE_BRICK Brick BOOL  
BRICK_DIRT_ENABLE_GAP Gap BOOL  
BRICK_DIRT_OPACITY Opacity REAL
UNIT PERCENT
MIN 0
MAX 100.0
CUSTOMGUI REALSLIDER
BRICK_DIRT_GAP_BLEND GapBlending REAL
UNIT PERCENT
MIN -100.0
MAX 100.0
CUSTOMGUI REALSLIDER
BRICK_DIRT_BRICK_BLEND BrickBlending REAL
UNIT PERCENT
MIN -100.0
MAX 100.0
CUSTOMGUI REALSLIDER
BRICK_DIRT_COL Color GRADIENT
COLOR
ALPHA
ICC_BASEDOCUMENT
BRICK_DIRT_COL_SCALE ColorScale REAL
UNIT PERCENT
STEP 0.1
BRICK_DIRT_ALPHA_SHIFT Shift VECTOR
UNIT PERCENT
STEP 0.1
BRICK_DIRT_ALPHA_SCALE OpacityScale REAL
UNIT PERCENT
STEP 0.1
BRICK_DIRT_ALPHA_OCT Octaves REAL
MIN 0
MAX 10
STEP 0.1
BRICK_DIRTTEX_LINK Texture SHADERLINK  
BRICK_DIRTTEX_COLOR_LINK ColorTexture SHADERLINK  
BRICK_DIRTTEX_SHIFT Shift VECTOR
UNIT PERCENT
STEP 0.1
BRICK_DIRTTEX_SCALE Scale REAL
UNIT PERCENT
STEP 0.1
BRICK_DIRTTEX_FLIP Flip BOOL  
BRICK_DIRTTEX_MULTIPLYCOLOR MultiplywithGradient BOOL  
BRICK_DIRTTEX_ALPHA_INVERT AlphaInvert BOOL  
BRICK_DIRTTEX_ALPHA_CONTRAST AlphaContrast REAL
UNIT PERCENT
MIN 0.0
BRICK_DIRTTEX_ALPHA_BIAS AlphaBias REAL UNIT
BRICK_DIRTTEX_RAIN Rain REAL
UNIT PERCENT
MIN 0.0
MAX 5000.0
BRICK_DIRTTEX_RAIN_SAMPLES Samples LONG MIN
BRICK_DIRTTEX_RAIN_DOCOLOR BlurColorTexture 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.Xbrick)
    
    #You can set parameters two different ways. 
    #First way              
    shader[c4d.BRICK_SCALE] = 0.1
    shader[c4d.BRICK_WIDTH] = 0.1
    shader[c4d.BRICK_HEIGHT] = 0.1
    shader[c4d.BRICK_SHIFT] = 0.1
    shader[c4d.BRICK_SHIFT_RESET] = 1
    shader[c4d.BRICK_HALFWIDTH] = 1
    shader[c4d.BRICK_HALFWIDTH_SHIFT] = 0.1
    shader[c4d.BRICK_ALTCOL_BALANCE_HPERIOD] = True
    shader[c4d.BRICK_DISPLACEMENTMODE_ENABLE] = True
    shader[c4d.BRICK_DISPLACEMENTMODE_RANDOM_HEIGHT] = 0.1
    shader[c4d.BRICK_DISPLACEMENTMODE_RANDOM_SLOPE] = 0.1
    shader[c4d.BRICK_DISPLACEMENTMODE_SLOPE_MODE] = c4d.BRICK_DISPLACEMENTMODE_MODE_SLOPE_RANDOM
    shader[c4d.BRICK_DISPLACEMENTMODE_SEED] = 1
    shader[c4d.BRICK_TEX_OFFSET] = 0.1
    shader[c4d.BRICK_TEX_OFFSET_RANDOM] = True
    shader[c4d.BRICK_TEX_SCALE] = 0.1
    shader[c4d.BRICK_TEX_FLIP] = True
    shader[c4d.BRICK_TEX_OPACITY] = 0.1
    shader[c4d.BRICK_TEX_BLENDMODE] = c4d.BRICK_BLENDMODE_NORMAL
    shader[c4d.BRICK_ALTTEX_OFFSET] = 0.1
    shader[c4d.BRICK_ALTTEX_OFFSET_RANDOM] = True
    shader[c4d.BRICK_ALTTEX_SCALE] = 0.1
    shader[c4d.BRICK_ALTTEX_FLIP] = True
    shader[c4d.BRICK_ALTTEX_OPACITY] = 0.1
    shader[c4d.BRICK_ALTTEX_BLENDMODE] = c4d.BRICK_BLENDMODE_NORMAL
    shader[c4d.BRICK_ALTCOL_VPERIOD] = 1
    shader[c4d.BRICK_ALTCOL_HPERIOD] = 1
    shader[c4d.BRICK_COL_NOISE_SCALE] = 0.1
    shader[c4d.BRICK_COL_DETAILS_INTENSITY] = 0.1
    shader[c4d.BRICK_COL_DETAILS_SCALE] = 0.1
    shader[c4d.BRICK_GAPTEX_SCALE] = 0.1
    shader[c4d.BRICK_GAPTEX_FLIP] = True
    shader[c4d.BRICK_GAPTEX_OPACITY] = 0.1
    shader[c4d.BRICK_GAPTEX_BLENDMODE] = c4d.BRICK_BLENDMODE_NORMAL
    shader[c4d.BRICK_GAPCOL_NOISE_SCALE] = 0.1
    shader[c4d.BRICK_DEPTH] = 0.1
    shader[c4d.BRICK_GAPSIZE] = 0.1
    shader[c4d.BRICK_GAPNOTCH] = 0.1
    shader[c4d.BRICK_NOISE_INTENSITY] = 0.1
    shader[c4d.BRICK_NOISE_SCALE] = 0.1
    shader[c4d.BRICK_DIRT_ENABLE] = True
    shader[c4d.BRICK_DIRT_ENABLE_BRICK] = True
    shader[c4d.BRICK_DIRT_ENABLE_GAP] = True
    shader[c4d.BRICK_DIRT_OPACITY] = 0.1
    shader[c4d.BRICK_DIRT_GAP_BLEND] = 0.1
    shader[c4d.BRICK_DIRT_BRICK_BLEND] = 0.1
    shader[c4d.BRICK_DIRT_COL_SCALE] = 0.1
    shader[c4d.BRICK_DIRT_ALPHA_SHIFT] = c4d.Vector(1.0,1.0,1.0)
    shader[c4d.BRICK_DIRT_ALPHA_SCALE] = 0.1
    shader[c4d.BRICK_DIRT_ALPHA_OCT] = 0.1
    shader[c4d.BRICK_DIRTTEX_SHIFT] = c4d.Vector(1.0,1.0,1.0)
    shader[c4d.BRICK_DIRTTEX_SCALE] = 0.1
    shader[c4d.BRICK_DIRTTEX_FLIP] = True
    shader[c4d.BRICK_DIRTTEX_MULTIPLYCOLOR] = True
    shader[c4d.BRICK_DIRTTEX_ALPHA_INVERT] = True
    shader[c4d.BRICK_DIRTTEX_ALPHA_CONTRAST] = 0.1
    shader[c4d.BRICK_DIRTTEX_ALPHA_BIAS] = 0.1
    shader[c4d.BRICK_DIRTTEX_RAIN] = 0.1
    shader[c4d.BRICK_DIRTTEX_RAIN_SAMPLES] = 1
    shader[c4d.BRICK_DIRTTEX_RAIN_DOCOLOR] = True
    
    #Second way, using the base container.
    bc = shader.GetDataInstance()
    bc.SetFloat(c4d.BRICK_SCALE,0.1)
    bc.SetFloat(c4d.BRICK_WIDTH,0.1)
    bc.SetFloat(c4d.BRICK_HEIGHT,0.1)
    bc.SetFloat(c4d.BRICK_SHIFT,0.1)
    bc.SetInt32(c4d.BRICK_SHIFT_RESET,1)
    bc.SetInt32(c4d.BRICK_HALFWIDTH,1)
    bc.SetFloat(c4d.BRICK_HALFWIDTH_SHIFT,0.1)
    bc.SetBool(c4d.BRICK_ALTCOL_BALANCE_HPERIOD,True)
    bc.SetBool(c4d.BRICK_DISPLACEMENTMODE_ENABLE,True)
    bc.SetFloat(c4d.BRICK_DISPLACEMENTMODE_RANDOM_HEIGHT,0.1)
    bc.SetFloat(c4d.BRICK_DISPLACEMENTMODE_RANDOM_SLOPE,0.1)
    bc.SetInt32(c4d.BRICK_DISPLACEMENTMODE_SLOPE_MODE,c4d.BRICK_DISPLACEMENTMODE_MODE_SLOPE_RANDOM)
    bc.SetInt32(c4d.BRICK_DISPLACEMENTMODE_SEED,1)
    bc.SetFloat(c4d.BRICK_TEX_OFFSET,0.1)
    bc.SetBool(c4d.BRICK_TEX_OFFSET_RANDOM,True)
    bc.SetFloat(c4d.BRICK_TEX_SCALE,0.1)
    bc.SetBool(c4d.BRICK_TEX_FLIP,True)
    bc.SetFloat(c4d.BRICK_TEX_OPACITY,0.1)
    bc.SetInt32(c4d.BRICK_TEX_BLENDMODE,c4d.BRICK_BLENDMODE_NORMAL)
    bc.SetFloat(c4d.BRICK_ALTTEX_OFFSET,0.1)
    bc.SetBool(c4d.BRICK_ALTTEX_OFFSET_RANDOM,True)
    bc.SetFloat(c4d.BRICK_ALTTEX_SCALE,0.1)
    bc.SetBool(c4d.BRICK_ALTTEX_FLIP,True)
    bc.SetFloat(c4d.BRICK_ALTTEX_OPACITY,0.1)
    bc.SetInt32(c4d.BRICK_ALTTEX_BLENDMODE,c4d.BRICK_BLENDMODE_NORMAL)
    bc.SetInt32(c4d.BRICK_ALTCOL_VPERIOD,1)
    bc.SetInt32(c4d.BRICK_ALTCOL_HPERIOD,1)
    bc.SetFloat(c4d.BRICK_COL_NOISE_SCALE,0.1)
    bc.SetFloat(c4d.BRICK_COL_DETAILS_INTENSITY,0.1)
    bc.SetFloat(c4d.BRICK_COL_DETAILS_SCALE,0.1)
    bc.SetFloat(c4d.BRICK_GAPTEX_SCALE,0.1)
    bc.SetBool(c4d.BRICK_GAPTEX_FLIP,True)
    bc.SetFloat(c4d.BRICK_GAPTEX_OPACITY,0.1)
    bc.SetInt32(c4d.BRICK_GAPTEX_BLENDMODE,c4d.BRICK_BLENDMODE_NORMAL)
    bc.SetFloat(c4d.BRICK_GAPCOL_NOISE_SCALE,0.1)
    bc.SetFloat(c4d.BRICK_DEPTH,0.1)
    bc.SetFloat(c4d.BRICK_GAPSIZE,0.1)
    bc.SetFloat(c4d.BRICK_GAPNOTCH,0.1)
    bc.SetFloat(c4d.BRICK_NOISE_INTENSITY,0.1)
    bc.SetFloat(c4d.BRICK_NOISE_SCALE,0.1)
    bc.SetBool(c4d.BRICK_DIRT_ENABLE,True)
    bc.SetBool(c4d.BRICK_DIRT_ENABLE_BRICK,True)
    bc.SetBool(c4d.BRICK_DIRT_ENABLE_GAP,True)
    bc.SetFloat(c4d.BRICK_DIRT_OPACITY,0.1)
    bc.SetFloat(c4d.BRICK_DIRT_GAP_BLEND,0.1)
    bc.SetFloat(c4d.BRICK_DIRT_BRICK_BLEND,0.1)
    bc.SetFloat(c4d.BRICK_DIRT_COL_SCALE,0.1)
    bc.SetVector(c4d.BRICK_DIRT_ALPHA_SHIFT, c4d.Vector(1.0,1.0,1.0)
    bc.SetFloat(c4d.BRICK_DIRT_ALPHA_SCALE,0.1)
    bc.SetFloat(c4d.BRICK_DIRT_ALPHA_OCT,0.1)
    bc.SetVector(c4d.BRICK_DIRTTEX_SHIFT, c4d.Vector(1.0,1.0,1.0)
    bc.SetFloat(c4d.BRICK_DIRTTEX_SCALE,0.1)
    bc.SetBool(c4d.BRICK_DIRTTEX_FLIP,True)
    bc.SetBool(c4d.BRICK_DIRTTEX_MULTIPLYCOLOR,True)
    bc.SetBool(c4d.BRICK_DIRTTEX_ALPHA_INVERT,True)
    bc.SetFloat(c4d.BRICK_DIRTTEX_ALPHA_CONTRAST,0.1)
    bc.SetFloat(c4d.BRICK_DIRTTEX_ALPHA_BIAS,0.1)
    bc.SetFloat(c4d.BRICK_DIRTTEX_RAIN,0.1)
    bc.SetInt32(c4d.BRICK_DIRTTEX_RAIN_SAMPLES,1)
    bc.SetBool(c4d.BRICK_DIRTTEX_RAIN_DOCOLOR,True)

if __name__=='__main__':
    main()

C++

#include "c4d.h"
#include "../shader/description/xbrick.h"
void SampleFunction()
{
    BaseDocument *pDoc = GetActiveDocument();
    BaseShader *pShader = BaseShader::Alloc(Xbrick);  
    
    //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(BRICK_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_WIDTH),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_HEIGHT),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_SHIFT),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_SHIFT_RESET),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_HALFWIDTH),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_HALFWIDTH_SHIFT),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_ALTCOL_BALANCE_HPERIOD),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DISPLACEMENTMODE_ENABLE),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DISPLACEMENTMODE_RANDOM_HEIGHT),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DISPLACEMENTMODE_RANDOM_SLOPE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DISPLACEMENTMODE_SLOPE_MODE),GeData(BRICK_DISPLACEMENTMODE_MODE_SLOPE_RANDOM),flags);
    pShader->SetParameter(DescID(BRICK_DISPLACEMENTMODE_SEED),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_TEX_OFFSET),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_TEX_OFFSET_RANDOM),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_TEX_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_TEX_FLIP),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_TEX_OPACITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_TEX_BLENDMODE),GeData(BRICK_BLENDMODE_NORMAL),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_OFFSET),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_OFFSET_RANDOM),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_FLIP),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_OPACITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_ALTTEX_BLENDMODE),GeData(BRICK_BLENDMODE_NORMAL),flags);
    pShader->SetParameter(DescID(BRICK_ALTCOL_VPERIOD),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_ALTCOL_HPERIOD),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_COL_NOISE_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_COL_DETAILS_INTENSITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_COL_DETAILS_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_GAPTEX_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_GAPTEX_FLIP),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_GAPTEX_OPACITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_GAPTEX_BLENDMODE),GeData(BRICK_BLENDMODE_NORMAL),flags);
    pShader->SetParameter(DescID(BRICK_GAPCOL_NOISE_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DEPTH),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_GAPSIZE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_GAPNOTCH),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_NOISE_INTENSITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_NOISE_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ENABLE),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ENABLE_BRICK),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ENABLE_GAP),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_OPACITY),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_GAP_BLEND),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_BRICK_BLEND),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_COL_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ALPHA_SHIFT),GeData(Vector(1.0,1.0,1.0)),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ALPHA_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRT_ALPHA_OCT),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_SHIFT),GeData(Vector(1.0,1.0,1.0)),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_SCALE),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_FLIP),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_MULTIPLYCOLOR),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_ALPHA_INVERT),GeData(true),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_ALPHA_CONTRAST),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_ALPHA_BIAS),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_RAIN),GeData(0.1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_RAIN_SAMPLES),GeData(1),flags);
    pShader->SetParameter(DescID(BRICK_DIRTTEX_RAIN_DOCOLOR),GeData(true),flags);
    pShader->Message(MSG_UPDATE);            

    //Second way, using the base container.
    BaseContainer *bc =     pShader->GetDataInstance();
    bc->SetFloat(BRICK_SCALE,0.1);
    bc->SetFloat(BRICK_WIDTH,0.1);
    bc->SetFloat(BRICK_HEIGHT,0.1);
    bc->SetFloat(BRICK_SHIFT,0.1);
    bc->SetInt32(BRICK_SHIFT_RESET,1);
    bc->SetInt32(BRICK_HALFWIDTH,1);
    bc->SetFloat(BRICK_HALFWIDTH_SHIFT,0.1);
    bc->SetBool(BRICK_ALTCOL_BALANCE_HPERIOD,true);
    bc->SetBool(BRICK_DISPLACEMENTMODE_ENABLE,true);
    bc->SetFloat(BRICK_DISPLACEMENTMODE_RANDOM_HEIGHT,0.1);
    bc->SetFloat(BRICK_DISPLACEMENTMODE_RANDOM_SLOPE,0.1);
    bc->SetInt32(BRICK_DISPLACEMENTMODE_SLOPE_MODE,BRICK_DISPLACEMENTMODE_MODE_SLOPE_RANDOM);
    bc->SetInt32(BRICK_DISPLACEMENTMODE_SEED,1);
    bc->SetFloat(BRICK_TEX_OFFSET,0.1);
    bc->SetBool(BRICK_TEX_OFFSET_RANDOM,true);
    bc->SetFloat(BRICK_TEX_SCALE,0.1);
    bc->SetBool(BRICK_TEX_FLIP,true);
    bc->SetFloat(BRICK_TEX_OPACITY,0.1);
    bc->SetInt32(BRICK_TEX_BLENDMODE,BRICK_BLENDMODE_NORMAL);
    bc->SetFloat(BRICK_ALTTEX_OFFSET,0.1);
    bc->SetBool(BRICK_ALTTEX_OFFSET_RANDOM,true);
    bc->SetFloat(BRICK_ALTTEX_SCALE,0.1);
    bc->SetBool(BRICK_ALTTEX_FLIP,true);
    bc->SetFloat(BRICK_ALTTEX_OPACITY,0.1);
    bc->SetInt32(BRICK_ALTTEX_BLENDMODE,BRICK_BLENDMODE_NORMAL);
    bc->SetInt32(BRICK_ALTCOL_VPERIOD,1);
    bc->SetInt32(BRICK_ALTCOL_HPERIOD,1);
    bc->SetFloat(BRICK_COL_NOISE_SCALE,0.1);
    bc->SetFloat(BRICK_COL_DETAILS_INTENSITY,0.1);
    bc->SetFloat(BRICK_COL_DETAILS_SCALE,0.1);
    bc->SetFloat(BRICK_GAPTEX_SCALE,0.1);
    bc->SetBool(BRICK_GAPTEX_FLIP,true);
    bc->SetFloat(BRICK_GAPTEX_OPACITY,0.1);
    bc->SetInt32(BRICK_GAPTEX_BLENDMODE,BRICK_BLENDMODE_NORMAL);
    bc->SetFloat(BRICK_GAPCOL_NOISE_SCALE,0.1);
    bc->SetFloat(BRICK_DEPTH,0.1);
    bc->SetFloat(BRICK_GAPSIZE,0.1);
    bc->SetFloat(BRICK_GAPNOTCH,0.1);
    bc->SetFloat(BRICK_NOISE_INTENSITY,0.1);
    bc->SetFloat(BRICK_NOISE_SCALE,0.1);
    bc->SetBool(BRICK_DIRT_ENABLE,true);
    bc->SetBool(BRICK_DIRT_ENABLE_BRICK,true);
    bc->SetBool(BRICK_DIRT_ENABLE_GAP,true);
    bc->SetFloat(BRICK_DIRT_OPACITY,0.1);
    bc->SetFloat(BRICK_DIRT_GAP_BLEND,0.1);
    bc->SetFloat(BRICK_DIRT_BRICK_BLEND,0.1);
    bc->SetFloat(BRICK_DIRT_COL_SCALE,0.1);
    bc->SetVector(BRICK_DIRT_ALPHA_SHIFT, c4d.Vector(1.0,1.0,1.0);
    bc->SetFloat(BRICK_DIRT_ALPHA_SCALE,0.1);
    bc->SetFloat(BRICK_DIRT_ALPHA_OCT,0.1);
    bc->SetVector(BRICK_DIRTTEX_SHIFT, c4d.Vector(1.0,1.0,1.0);
    bc->SetFloat(BRICK_DIRTTEX_SCALE,0.1);
    bc->SetBool(BRICK_DIRTTEX_FLIP,true);
    bc->SetBool(BRICK_DIRTTEX_MULTIPLYCOLOR,true);
    bc->SetBool(BRICK_DIRTTEX_ALPHA_INVERT,true);
    bc->SetFloat(BRICK_DIRTTEX_ALPHA_CONTRAST,0.1);
    bc->SetFloat(BRICK_DIRTTEX_ALPHA_BIAS,0.1);
    bc->SetFloat(BRICK_DIRTTEX_RAIN,0.1);
    bc->SetInt32(BRICK_DIRTTEX_RAIN_SAMPLES,1);
    bc->SetBool(BRICK_DIRTTEX_RAIN_DOCOLOR,true);
    pShader->Message(MSG_UPDATE);                                                      
}

Gradients

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

Python



C++
 

           
#include "customgui_gradient.h"

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

BRICK_ALTCOL
                                
pShader->GetParameter(DescID(BRICK_ALTCOL),data,DESCFLAGS_GET_PARAM_GET));

BRICK_GAPCOL
                                
pShader->GetParameter(DescID(BRICK_GAPCOL),data,DESCFLAGS_GET_PARAM_GET));

BRICK_DIRT_COL
                                
pShader->GetParameter(DescID(BRICK_DIRT_COL),data,DESCFLAGS_GET_PARAM_GET));