Adding Shave-and-a-Haircut 9.6

1 files changed, 1361 insertions, 0 deletions

diff --git a/mayaPlug/shaveVrayCmd.cpp b/mayaPlug/shaveVrayCmd.cpp
new file mode 100644
index 0000000..608e00d
--- /dev/null
+++ b/mayaPlug/shaveVrayCmd.cpp
@@ -0,0 +1,1361 @@
+// Shave and a Haircut
+// (c) 2019 Epic Games
+// US Patent 6720962
+
+/**********************************************************************
+ *<
+	FILE:			shaveVrayCmd.cpp  
+
+	DESCRIPTION:	Maya node
+
+	HISTORY:		created  01-04-2010 
+
+ *>
+ **********************************************************************/
+
+#include "shaveRender.h"
+#include "shaveVrayNode.h"
+#include "shaveVrayCmd.h"
+#include "shaveVrayRenderer.h"
+#include "shaveVraySharedFunctions.h"
+
+#include "shaveHairShape.h"
+
+#include <maya/MDagPath.h>
+#include <maya/MFnDependencyNode.h>
+#include <maya/MDGModifier.h>
+#include <maya/MArgDatabase.h>
+#include <maya/MPlugArray.h>
+#include <maya/MDagModifier.h>
+#include <maya/MSelectionList.h>
+#include <maya/MFnRenderLayer.h>
+#include <maya/MItDependencyNodes.h>
+
+
+#include <assert.h>
+#include <vector>
+#include <string.h>
+
+#ifdef USE_VRAY
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
+|						Layer change callback								|							
+/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+#if 0
+static MCallbackId layerCbkId=0;
+static void shaveVrayLayerCbk(MNodeMessage::AttributeMessage msg, MPlug &plug, MPlug &otherPlug, void *clientData);
+#endif
+
+static std::vector<MCallbackId> cbkIds;
+static void shaveVrayShaderChangeCbk(MNodeMessage::AttributeMessage msg, MPlug &plug, MPlug &otherPlug, void *clientData);
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
+|								Command										|							
+/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+MString shaveVrayCmd::cmd = "shaveVrayShader";
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
+|								Flags										|							
+/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+char* shaveVrayCmd::sf_create	= "c";
+char* shaveVrayCmd::lf_create	= "create";
+
+char* shaveVrayCmd::sf_delete	= "d";
+char* shaveVrayCmd::lf_delete	= "delete";
+
+char* shaveVrayCmd::sf_all		 = "all";
+char* shaveVrayCmd::lf_all		 = "allShapes";
+
+#if 0
+char* shaveVrayCmd::sf_addCbk	 = "ac";
+char* shaveVrayCmd::lf_addCbk	 = "addCallback";
+
+char* shaveVrayCmd::sf_delCbk	= "rc";
+char* shaveVrayCmd::lf_delCbk	= "removeCallback";
+#endif
+
+//char* shaveVrayCmd::sf_shaveInit = "si";
+//char* shaveVrayCmd::lf_shaveInit = "shaveInit";
+//
+//char* shaveVrayCmd::sf_shaveClear= "sc";
+//char* shaveVrayCmd::lf_shaveClear= "shaveClear";
+
+//char* shaveVrayCmd::sf_frameStart= "fs";
+//char* shaveVrayCmd::lf_frameStart= "frameStart";
+//
+//char* shaveVrayCmd::sf_frameEnd  = "fe";
+//char* shaveVrayCmd::lf_frameEnd	 = "frameEnd";
+
+//char* shaveVrayCmd::sf_shutterOpen = "so";
+//char* shaveVrayCmd::lf_shutterOpen = "shutterOpen";
+//
+//char* shaveVrayCmd::sf_shutterClose= "sc";
+//char* shaveVrayCmd::lf_shutterClose= "shutterClose";
+
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
+|								Methods										|							
+/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+MStatus shaveVrayCmd::doIt(const MArgList &maList) 
+{
+	MStatus stat;
+
+	setResult(0); // will be changed later.
+
+	MArgDatabase parser(syntax(),maList,&stat);
+	if(stat != MStatus::kSuccess)
+	{
+		MGlobal::displayError("shaveVray: can not parse arguments.");
+		return stat;
+	}
+	{
+		if(parser.isFlagSet(sf_create))
+		{
+			if(parser.isFlagSet(sf_all))	
+			{
+				shaveVrayRenderer* renderer = dynamic_cast<shaveVrayRenderer*>(shaveRender::getRenderer());
+				if (renderer == NULL) {
+					MGlobal::displayError("'shaveVray -create -all' used when current renderer is not VRay");
+					return MS::kFailure;
+				}
+
+				MObjectArray shaveShapes;
+				renderer->getRenderableShaveNodesByRenderMode(NULL, &shaveShapes);
+
+				if(shaveShapes.length() > 0)
+				{
+			
+					for(unsigned int i = 0; i < shaveShapes.length(); i++)
+					{
+						//////
+						MFnDependencyNode nodeFn(shaveShapes[i]);
+						shaveHairShape*	nodePtr = (shaveHairShape*)nodeFn.userNode();
+
+						MObject	displayNode = nodePtr->getDisplayShape();
+						
+						if (!displayNode.isNull())
+						{
+							MFnDagNode	dagNodeFn(displayNode);
+							//visibility
+							{
+								MPlug		plug = dagNodeFn.findPlug("visibility");
+								if(!plug.isNull())
+								{
+									bool		v;
+									plug.getValue(v);
+									if (!v) continue;
+								}
+							}
+							//overriden visibility
+							{
+								MPlug plug = dagNodeFn.findPlug("overrideEnabled");
+								if(!plug.isNull())
+								{
+									bool overridesEnabled;
+									plug.getValue(overridesEnabled);
+									if(overridesEnabled)
+									{
+										MPlug plug2 = dagNodeFn.findPlug("overrideVisibility");
+										if(!plug2.isNull())
+										{
+											bool ovi;
+											plug2.getValue(ovi);
+											if(!ovi) continue;
+										}
+									}
+								}
+							}
+						}
+						
+						if(!attachShaderTo(shaveShapes[i]))
+						{
+							MGlobal::displayError("shaveVray: can not attach the shader.");
+							return MStatus::kNotFound; 
+						}
+					}//for shapes
+
+					///////////////////////////////////////
+#if 0
+					{
+						MObjectArray layers;
+						MFnRenderLayer::listAllRenderLayers(layers);
+						for(unsigned int oo = 0; oo < layers.length(); oo++)
+						{
+								
+							MObjectArray members;
+							MFnRenderLayer layerFn(layers[oo]);
+							MGlobal::displayInfo(MString(" Layer ") + layerFn.name());  
+							MGlobal::displayInfo("~~~~~~~~~~~~~~~~~~~~~~~~");
+								
+							if(MStatus::kSuccess == layerFn.listMembers(members))
+							{
+								for(unsigned int kk = 0; kk < members.length(); kk++)
+								{
+									MFnDependencyNode dFn(members[kk]);
+									MGlobal::displayInfo(MString("member ") + dFn.name());
+								}
+							}
+							MGlobal::displayInfo("~~~~~~~~~~~~~~~~~~~~~~~~");
+						}
+					}
+#endif
+					//////////////////////////////////////
+				}
+			}
+			else
+			{
+				MObject shaveShape;
+				if(FindCurrentShaveShape(shaveShape))
+				{
+					if(attachShaderTo(shaveShape))
+					{
+						setResult(1);
+						return MStatus::kSuccess;
+					}
+					else
+					{
+						MGlobal::displayError("shaveVray: can not attach the shader.");
+						return MStatus::kNotFound;
+					}
+				}
+				else
+				{
+					MGlobal::displayError("shaveVray: select the hairShape to attach the shader.");
+					return MStatus::kNotFound;
+				}
+			}
+		}
+		else if(parser.isFlagSet(sf_delete))
+		{
+			deregisterShaderChangeCallacks();
+			if(parser.isFlagSet(sf_all))	
+			{
+				MObjectArray shaveShapes;
+				if(FindAllShaveShapes(shaveShapes))
+				{
+					for(unsigned int i = 0; i < shaveShapes.length(); i++)
+					{
+						if(!detachShaderFrom(shaveShapes[i]))
+						{
+							MGlobal::displayError("shaveVray: can not dettach the shader.");
+							return MStatus::kNotFound;
+						}
+					}
+				}
+			}
+			else
+			{
+				MObject shaveShape;
+				if(FindCurrentShaveShape(shaveShape))
+				{
+					if(detachShaderFrom(shaveShape))
+					{
+						setResult(1);
+						return MStatus::kSuccess;
+					}
+					else
+					{
+						MGlobal::displayError("shaveVray: can not dettach the shader.");
+						return MStatus::kNotFound;
+					}
+				}
+				else
+				{
+					MGlobal::displayError("shaveVray: select the hairShape to attach the shader.");
+					return MStatus::kNotFound;
+				}
+			}
+		}
+#if 0
+		else if(parser.isFlagSet(sf_addCbk))
+		{
+			registerLayersCallback();
+		}
+		else if(parser.isFlagSet(sf_delCbk))
+		{
+			deregisterLayersCallack();
+		}
+#endif		
+	}
+	setResult(1);
+	return MStatus::kSuccess;
+}
+
+
+MSyntax shaveVrayCmd::newSyntax()
+{
+	MSyntax syn;
+
+	syn.enableQuery(true);
+	syn.addFlag(sf_create,		lf_create);
+	syn.addFlag(sf_delete,		lf_delete);
+	syn.addFlag(sf_all,			lf_all);
+#if 0
+	syn.addFlag(sf_addCbk,		lf_addCbk);
+	syn.addFlag(sf_delCbk,		lf_delCbk);
+#endif
+	return syn;
+}
+
+
+struct PlugPair {
+	MPlug from;
+	MPlug to;
+};
+//static std::vector<PlugPair> restore;
+
+bool shaveVrayCmd::attachShaderTo(MObject shaveShape)
+{
+#ifdef _DEBUG
+	{
+		MFnDependencyNode sFn(shaveShape);
+		MGlobal::displayInfo(MString("shaveVrayCmd::attachShaderTo( ") + sFn.name() + " )");
+	}
+#endif
+	MStatus stat;
+	MFnDependencyNode shapeFn(shaveShape,&stat);
+	if(stat == MStatus::kSuccess)
+	{
+		MPlug shaveStackIdxPlug = shapeFn.findPlug("stackIndex",&stat);
+		if(stat == MStatus::kSuccess && !shaveStackIdxPlug.isNull())
+		{
+#if 0
+			///////////////////////////////////////////////
+			if(shaveStackIdxPlug.isConnected())
+			{
+				MPlugArray plugs;
+				if(shaveStackIdxPlug.connectedTo(plugs,false,true,&stat))
+				{
+					for(unsigned int i = 0; i < plugs.length(); i++)
+					{
+						MObject shaderNode = plugs[i].node();
+						if(!shaderNode.isNull())
+						{
+							MObjectArray nodes;
+							EnumDownNodes(shaderNode,nodes);
+							MDagModifier dagMod;
+							for(unsigned int j = 0; j < nodes.length(); j++)
+							{
+								MFnDependencyNode dfn(nodes[j]);
+
+								if(nodes[j].hasFn(MFn::kShape))
+								{
+									MPlug visible = dfn.findPlug("visibility");
+									visible.setValue(true);
+
+									setupLayers(shaveShape,nodes[j]);
+								}
+							}
+						}
+					}
+				}
+				return true;
+			}
+#endif
+			///////////////////////////////////////////////
+			MDGModifier dgMod;
+			MObject vrayNode = dgMod.createNode(shaveVrayNode::typeId,&stat);
+			if(stat == MStatus::kSuccess && !vrayNode.isNull())
+			{
+				MFnDependencyNode vrayFn(vrayNode,&stat);
+				if(stat == MStatus::kSuccess)
+				{
+					//connect stack index
+					MPlug vrayStackIdxPlug = vrayFn.findPlug(shaveVrayNode::attr_stackIndex,&stat);
+					if(stat == MStatus::kSuccess && !vrayStackIdxPlug.isNull())
+					{
+						stat = dgMod.connect(shaveStackIdxPlug,vrayStackIdxPlug);
+						if(stat == MStatus::kSuccess)
+						{
+							dgMod.doIt();
+
+							/// connect instancing status 
+							{
+								MPlug shaveIsInstancedPlug = shapeFn.findPlug("instancingStatus",&stat);
+								if(stat == MStatus::kSuccess && ! shaveIsInstancedPlug.isNull())
+								{
+									MPlug vrayIsInstancedPlug = vrayFn.findPlug(shaveVrayNode::attr_isInstanced,&stat);
+									if(stat == MStatus::kSuccess && ! vrayIsInstancedPlug.isNull())
+									{
+										stat = dgMod.connect(shaveIsInstancedPlug,vrayIsInstancedPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect instacing status plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.isInstanced plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.instancingStatus plug.");
+							}
+
+							//// connect override surf shader flag
+							{
+								MPlug shaveOverrideShPlug = shapeFn.findPlug("overrideGeomShader",&stat);
+								if(stat == MStatus::kSuccess && ! shaveOverrideShPlug.isNull())
+								{
+									MPlug vrayOverrideShPlug = vrayFn.findPlug(shaveVrayNode::attr_ownshader,&stat);
+									if(stat == MStatus::kSuccess && !vrayOverrideShPlug.isNull())
+									{
+										stat = dgMod.connect(shaveOverrideShPlug,vrayOverrideShPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect overrideShader status plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.ownshader plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.overrideGeomShader plug.");
+							}
+
+
+							/////// connect tipfade plugs
+							{
+								MPlug shaveTipfadePlug = shapeFn.findPlug("tipFade",&stat);
+								if(stat == MStatus::kSuccess && ! shaveTipfadePlug.isNull())
+								{
+									MPlug vrayTipfadePlug = vrayFn.findPlug(shaveVrayNode::attr_tipfade,&stat);
+									if(stat == MStatus::kSuccess && ! vrayTipfadePlug.isNull())
+									{
+										stat = dgMod.connect(shaveTipfadePlug,vrayTipfadePlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect tipfade plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.tipfade plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.tipFade plug.");
+							}
+							/////// connect specular tint ////////
+							{
+								MPlug shavePlug = shapeFn.findPlug("specularTint",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_specTint,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect specular tint plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.specTint plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.specularTint plug.");
+							}
+							/////// connect specular tint 2 ////////
+							{
+								MPlug shavePlug = shapeFn.findPlug("specularTint2",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_specTint2,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect specular tint2 plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.specTint2 plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.specularTint2 plug.");
+							}
+
+							/////// connect squirrel plugs
+							{
+								MPlug shaveSquirrelPlug = shapeFn.findPlug("squirrel",&stat);
+								if(stat == MStatus::kSuccess && ! shaveSquirrelPlug.isNull())
+								{
+									MPlug vraySquirrelPlug = vrayFn.findPlug(shaveVrayNode::attr_squirrel,&stat);
+									if(stat == MStatus::kSuccess && ! vraySquirrelPlug.isNull())
+									{
+										stat = dgMod.connect(shaveSquirrelPlug,vraySquirrelPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect squirrel plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.squirrel plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.squirrel plug.");
+							}
+
+							/////// connect instance mesh 
+							{
+								MPlug shaveInstancePlug = shapeFn.findPlug("instanceMesh",&stat);
+								if(stat == MStatus::kSuccess && ! shaveInstancePlug.isNull())
+								{
+									MPlug vrayInstancePlug = vrayFn.findPlug(shaveVrayNode::attr_instanceMesh,&stat);
+									if(stat == MStatus::kSuccess && ! vrayInstancePlug.isNull())
+									{
+										stat = dgMod.connect(shaveInstancePlug,vrayInstancePlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect instace mesh plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.instanceMesh plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.instanceMesh plug.");
+							}
+
+							/////// connect self shadow
+							{
+								MPlug shavePlug = shapeFn.findPlug("selfShadow",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_selfshadow,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect selfshadow plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.selfshadow plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.selfShadow plug.");
+							}
+
+							/////// connect cast shadow
+							{
+								MPlug shavePlug = shapeFn.findPlug("castsShadows",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_castshadow,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect castshadow plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.castshadow plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.castsShadows plug.");
+							}
+							/////// connect cast shadow
+							{
+								MPlug shavePlug = shapeFn.findPlug("receiveShadows",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_recvshadow,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect recvhadow plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.recvhadow plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.receiveShadows plug.");
+							}
+
+							/////// connect primary visibility
+							{
+								MPlug shavePlug = shapeFn.findPlug("primaryVisibility",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_primaryvis,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect prmary visibility plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.primaryvis plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.primaryVisibility plug.");
+							}
+							
+							/// other attribs visibleInReflections visibleInRefractions castsShadows receiveShadows 
+
+							/////// connect visibility in reflectinss
+							{
+								MPlug shavePlug = shapeFn.findPlug("visibleInReflections",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_reflvis,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect refl visibility plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.reflvis plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.visibleInReflections plug.");
+							}
+							/////// connect visibility in refractinss
+							{
+								MPlug shavePlug = shapeFn.findPlug("visibleInRefractions",&stat);
+								if(stat == MStatus::kSuccess && ! shavePlug.isNull())
+								{
+									MPlug vrayPlug = vrayFn.findPlug(shaveVrayNode::attr_refrvis,&stat);
+									if(stat == MStatus::kSuccess && ! vrayPlug.isNull())
+									{
+										stat = dgMod.connect(shavePlug,vrayPlug);
+										if(stat == MStatus::kSuccess)
+											dgMod.doIt();
+										else
+											MGlobal::displayError("shaveVrayCmd: can not connect refr visibility plugs.");
+									}
+									else 
+										MGlobal::displayError("shaveVrayCmd: can not find shaveVrayNode.refrvis plug.");
+								}
+								else 
+									MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.visibleInRefractions plug.");
+							}
+
+							/// create dummy shape
+
+							MCommandResult cmdResult;
+							MGlobal::executeCommand("polyPrimitive", cmdResult, false);
+
+							MStringArray resArray;
+							cmdResult.getResult(resArray);
+
+							MString node=resArray[0];
+							MString gen=resArray[1];
+
+							MObject nodeObj=getNodeByName(node.asChar());
+							MDagPath dagPath = MDagPath::getAPathTo(nodeObj);
+							dagPath.extendToShape();
+
+							setupLayers(shaveShape,nodeObj);
+
+							// Find where to connect the node to. We need to leave the groupParts nodes to give us face-mtl id info.
+							MFnDependencyNode destNode(dagPath.node());
+							MPlug destPlug = destNode.findPlug("inMesh");
+							MPlug srcPlug;
+							bool hasSource = false;
+							while ((hasSource = getSourcePlugFromPlug(destPlug, srcPlug)) && srcPlug.node().apiType() == MFn::kGroupParts) 
+							{
+								MFnDependencyNode srcNode(srcPlug.node());
+								destPlug = srcNode.findPlug("inputGeometry");
+							}
+
+							// Make the necessary connections and set the attributes.
+							if (hasSource) 
+								MGlobal::executeCommand("disconnectAttr " + srcPlug.name() + " " + destPlug.name() + ";");
+
+							MGlobal::executeCommand("connectAttr " + vrayFn.name() + ".output " + destPlug.name() + ";");
+
+							
+							shaveHairShape* shaveUserNode = (shaveHairShape*)shapeFn.userNode();
+							if(shaveUserNode)
+							{
+
+								/// connect material
+								MObject display = shaveUserNode->getDisplayShape();
+								registerShaderChangeCallback(display);
+								MObject shader = shaveUserNode->getShader();
+								if(!shader.isNull())
+								{
+									MFnDependencyNode shaderFn(shader);
+
+									MPlug instGroups = destNode.findPlug("instObjGroups"); 
+									if(!instGroups.isNull())
+									{
+										
+										MPlug instGroups0 = instGroups.elementByPhysicalIndex(0);
+										if(!instGroups0.isNull())
+										{
+											if(instGroups0.isConnected())
+											{
+												MPlugArray groupsTo;
+												instGroups0.connectedTo(groupsTo,false,true);
+												for(unsigned int k = 0; k < groupsTo.length(); k++)
+												{
+													MGlobal::executeCommand("disconnectAttr " +instGroups.name() + " " + groupsTo[k].name() + ";");
+													//dgMod.disconnect(instGroups0,groupsTo[k]);
+													//dgMod.doIt();
+												}
+											}
+
+											MPlug dagSetPlug = shaderFn.findPlug("dagSetMembers");
+											if(!dagSetPlug.isNull())
+											{
+												//int dagSetN = dagSetPlug.numElements();
+												//MPlug dagSetPlugK = dagSetPlug.elementByLogicalIndex(dagSetN+2);
+												MPlug dagSetPlugK;
+												for(int oo = 0; oo < 100000; oo++)
+												{
+													dagSetPlugK = dagSetPlug.elementByLogicalIndex(oo);
+													if(!dagSetPlugK.isConnected())
+														break;
+												}
+#ifdef _DEBUG
+												MGlobal::displayInfo("connectAttr " + instGroups0.name() + " " + dagSetPlugK.name() + ";");
+#endif
+												MGlobal::executeCommand("connectAttr " + instGroups0.name() + " " + dagSetPlugK.name() + ";");
+												//MGlobal::executeCommand("connectAttr " + instGroups0.name() + " " + dagSetPlug.name() + ";");
+												//stat = dgMod.connect(instGroups0,dagSetPlugK);
+												//if(stat == MStatus::kSuccess)
+												//	dgMod.doIt();
+												//else
+												//	MGlobal::displayError("shaveVrayCmd: can not connect surface shader.");
+											}
+											else
+												MGlobal::displayError("shaveVrayCmd: can not find 'dagSetMembers'.");
+											}
+											else
+												MGlobal::displayError("shaveVrayCmd: can not find 'instObjGroups0' plug.");
+									}
+									else
+										MGlobal::displayError("shaveVrayCmd: can not find 'instObjGroups' plug.");
+									
+								}
+							}
+							else
+								MGlobal::displayError("shaveVrayCmd: can not get 'userNode'.");
+							
+							
+							printf("shaveVrayCmd::attachShaderTo(...) -- OK\n");fflush(stdout); 
+
+							
+
+							return true;
+						}
+						else
+							MGlobal::displayError("shaveVrayCmd: can not connect stack index plugs.");
+					}
+					else
+						MGlobal::displayError("shaveVrayCmd: find shaveVrayNode.stackIndex plug.");
+				}
+				else
+					MGlobal::displayError("shaveVrayCmd: can not attach MFnDependencyNode fucntion set to shaveVrayNode.");
+			}
+			else
+				MGlobal::displayError("shaveVrayCmd: can not create shaveVrayNode.");
+		}
+		else
+			MGlobal::displayError("shaveVrayCmd: can not find shaveHairShape.stackIndex plug.");
+	}
+	else
+		MGlobal::displayError("shaveVrayCmd: can not attach MFnDependencyNode fucntion set to shaveHairShape node.");
+
+	return false;
+}
+
+bool shaveVrayCmd::detachShaderFrom(MObject shShape)
+{
+#ifdef _DEBUG
+	MGlobal::displayInfo("shaveVrayCmd::dettachShaderFrom(...)");
+#endif
+
+	MStatus stat;
+	MFnDependencyNode shapeFn(shShape,&stat);
+	if(stat == MStatus::kSuccess)
+	{
+		MPlug shavePlug = shapeFn.findPlug("stackIndex",&stat);
+		if(stat == MStatus::kSuccess && !shavePlug.isNull())
+		{
+			if(shavePlug.isConnected())
+			{
+				MPlugArray plugs;
+				if(shavePlug.connectedTo(plugs,false,true,&stat))
+				{
+					for(unsigned int i = 0; i < plugs.length(); i++)
+					{
+#if 1
+						MDGModifier dgMod;
+						dgMod.disconnect(shavePlug,plugs[i]);
+						dgMod.doIt();
+#endif
+
+
+						MObject shaderNode = plugs[i].node();
+						if(!shaderNode.isNull())
+						{
+							MObjectArray nodes;
+							EnumDownNodes(shaderNode,nodes);
+							MDagModifier dagMod;
+							for(unsigned int j = 0; j < nodes.length(); j++)
+							{
+#if 0
+								MFnDependencyNode dfn(nodes[j]);
+
+								if(nodes[j].hasFn(MFn::kShape))
+								{
+									MPlug visible = dfn.findPlug("visibility");
+									visible.setValue(false);
+
+									resetLayers(nodes[j]);
+								}
+#endif
+
+#if 1
+								dagMod.deleteNode(nodes[j]);
+#endif
+							}
+#if 1
+							dagMod.doIt();
+#endif
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+		return false;
+
+	return true;
+}
+
+bool shaveVrayCmd::setupLayers(MObject shaveShape, MObject vrayShape)
+{
+	MFnDependencyNode vrFn(vrayShape);
+
+	MDagPath dagPath = MDagPath::getAPathTo(vrayShape);
+	dagPath.extendToShape();
+	MFnDependencyNode destNode(dagPath.node());
+	
+	MFnDependencyNode shapeFn(shaveShape);
+
+	MFnDagNode shdagFn(shaveShape);
+	MObject hair = shdagFn.parent(0);
+
+	/////// set up same render layers as shave display shape //////
+	//// proably need to set up same as growth object ?
+	{
+		MObjectArray layers;
+
+		shaveHairShape*	nodePtr = (shaveHairShape*)shapeFn.userNode();
+		MObject	displayNode = nodePtr->getDisplayShape();
+								
+
+		MFnRenderLayer::listAllRenderLayers(layers);
+		for(unsigned int oo = 0; oo < layers.length(); oo++)
+		{
+			MObjectArray members;
+			MFnRenderLayer layerFn(layers[oo]);
+
+			///////////////////
+			//MGlobal::displayInfo(MString(" ----- Checking layer ---- ") + layerFn.name() + "---dest--" + destNode.name()+"---"+vrFn.name());
+			//////////////////
+			
+			if(MStatus::kSuccess == layerFn.listMembers(members))
+			{
+				bool owner_found = false;
+				bool dummy_found = false;
+				int idx_to_remove = -1;
+				for(unsigned int xx = 0; xx < members.length(); xx++)
+				{
+					MFnDependencyNode dFn(members[xx]);
+					
+					////////////////////
+					//MGlobal::displayInfo(dFn.name());
+					////////////////////	
+
+					
+					if(members[xx] == dagPath.node() || members[xx] == vrayShape)
+					{
+						dummy_found |= true;
+						///////////////////
+						//MGlobal::displayInfo(MString("Dummy found ") + destNode.name() + " in " + layerFn.name() );
+						//////////////////
+						for(unsigned int kkk = 0; kkk < members.length(); kkk++)
+						{
+							if(members[kkk] == shaveShape ||
+								members[kkk] == displayNode ||
+								members[kkk] == hair)
+							{
+								owner_found |= true;
+								break;
+							}
+						}
+						idx_to_remove = xx;
+						break;
+					}
+				}
+				for(unsigned int kk = 0; kk < members.length(); kk++)
+				{
+					if(members[kk] == shaveShape ||
+						members[kk] == displayNode ||
+						members[kk] == hair)
+					{
+						///////////////////
+						//MFnDependencyNode dFn(members[kk]);
+						//MGlobal::displayInfo(MString("Layer ") + layerFn.name() + " contains " + dFn.name());
+						//////////////////
+						bool found = false;
+						
+						for(unsigned int xx = 0; xx < members.length(); xx++)
+						{
+							if(members[xx] == dagPath.node())
+							{
+								found = true;
+								break;
+							}
+						}
+						if(found)
+							continue;
+
+						///////////////////
+						//MGlobal::displayInfo(MString("Adding ") + destNode.name() + " to " + layerFn.name() );
+						//////////////////
+
+						MString cmd = MString("editRenderLayerMembers -noRecurse ") + layerFn.name() + MString(" ") + destNode.name();
+						MGlobal::executeCommand(cmd);
+					}
+				}//end for
+				//need to remove
+				if(!owner_found && dummy_found && idx_to_remove !=-1) 
+				{
+					MFnDependencyNode dFn(members[idx_to_remove]);
+					
+					///////////////////
+					//MGlobal::displayInfo(MString("Removing ") + dFn.name() + " from " + layerFn.name() );
+					//////////////////
+					
+					MString cmd = MString("editRenderLayerMembers -remove ") + layerFn.name() + MString(" ") + dFn.name();
+					MGlobal::executeCommand(cmd);
+				}
+			}
+		}
+	}
+	
+	/////// set up same display layers as shave display shape //////
+	{
+								
+
+		MObjectArray layers;
+		MItDependencyNodes	iter;
+		for (; !iter.isDone(); iter.next())
+		{
+			MObject	node = iter.item();
+			if(node.hasFn(MFn::kDisplayLayer))
+			layers.append(node);
+		}
+
+		shaveHairShape*	nodePtr = (shaveHairShape*)shapeFn.userNode();
+		MObject	displayNode = nodePtr->getDisplayShape();
+		for(unsigned int oo = 0; oo < layers.length(); oo++)
+		{
+									
+			MFnDependencyNode layerFn(layers[oo]);
+			MPlug drPlug = layerFn.findPlug("drawInfo");
+			if(!drPlug.isNull())
+			{
+				MStatus stat;
+				MPlugArray members;
+				if(drPlug.connectedTo(members,false,true,&stat) && stat == MStatus::kSuccess) 
+				{
+					for(unsigned int kk = 0; kk < members.length(); kk++)
+					{
+						if(members[kk].node() == shaveShape ||
+							members[kk].node() == displayNode ||
+							members[kk].node() == hair)
+						{
+							bool found = false;
+							for(unsigned int xx = 0; xx < members.length(); xx++)
+							{
+								if(members[xx].node() == dagPath.node())
+								{
+									found = true;
+									break;
+								}
+							}
+							if(found)
+								continue;
+
+							MString cmd = MString("editDisplayLayerMembers -noRecurse ") + layerFn.name() + MString(" ") + destNode.name();
+							MGlobal::executeCommand(cmd);
+						}
+					}
+				}
+			}
+		}
+	}
+	return true;
+}
+
+bool shaveVrayCmd::resetLayers(MObject vrayShape)
+{
+	{	//reset render layers
+		MObjectArray layers;
+
+		MFnRenderLayer::listAllRenderLayers(layers);
+		for(unsigned int oo = 0; oo < layers.length(); oo++)
+		{
+			MObjectArray members;
+			MFnRenderLayer layerFn(layers[oo]);
+			
+			if(layerFn.name() == "defaultRenderLayer")
+				continue;
+
+			if(MStatus::kSuccess == layerFn.listMembers(members))
+			{
+				for(unsigned int kk = 0; kk < members.length(); kk++)
+				{
+					MFnDependencyNode mFn(members[kk]);
+					if(members[kk] == vrayShape)
+					{
+
+						MString cmd = MString("editRenderLayerMembers -remove ") + layerFn.name() + MString(" ") + mFn.name();
+						MGlobal::executeCommand(cmd);
+					}
+				}
+			}
+		}
+	}
+	{	//reset display layers
+								
+		MObjectArray layers;
+		MItDependencyNodes	iter;
+		for (; !iter.isDone(); iter.next())
+		{
+			MObject	node = iter.item();
+			if(node.hasFn(MFn::kDisplayLayer))
+			layers.append(node);
+		}
+		for(unsigned int oo = 0; oo < layers.length(); oo++)
+		{
+									
+			MFnDependencyNode layerFn(layers[oo]);
+			MPlug drPlug = layerFn.findPlug("drawInfo");
+			if(!drPlug.isNull())
+			{
+				MStatus stat;
+				MPlugArray members;
+				if(drPlug.connectedTo(members,false,true,&stat) && stat == MStatus::kSuccess) 
+				{
+					for(unsigned int kk = 0; kk < members.length(); kk++)
+					{
+						MFnDependencyNode mFn(members[kk].node());
+						if(members[kk].node() == vrayShape)
+						{
+
+							MString cmd = MString("editRenderLayerMembers -remove ") + layerFn.name() + MString(" ") + mFn.name();
+							MGlobal::executeCommand(cmd);
+													
+						}
+					}
+				}
+			}
+		}
+	}
+	return true;
+}
+bool shaveVrayCmd::registerShaderChangeCallback(MObject shape)
+{
+	MStatus stat;
+	MCallbackId cbkId = MNodeMessage::addAttributeChangedCallback (shape, shaveVrayShaderChangeCbk, NULL, &stat);
+	if(stat!=MStatus::kSuccess)
+	{
+		MGlobal::displayError("shaveVrayCmd: can not register attribute change callback.");
+		return false;
+	}
+	cbkIds.push_back(cbkId);
+	return true;
+}
+bool shaveVrayCmd::deregisterShaderChangeCallacks()
+{
+	for(size_t i = 0; i < cbkIds.size(); i++)
+	{
+		MStatus stat = MNodeMessage::removeCallback(cbkIds[i]);
+		 if(stat != MStatus::kSuccess)
+		 	MGlobal::displayError("shaveVrayCmd: can not deregister attribute change callback.");
+	}
+	cbkIds.clear();
+	return true;
+}
+
+void shaveVrayShaderChangeCbk(MNodeMessage::AttributeMessage msg, MPlug &plug, MPlug &otherPlug, void *clientData)
+{
+#ifdef _DEBUG
+	MGlobal::displayInfo(MString("shaveVrayShaderChangeCbk( ")+ plug.name() + " ---> " + otherPlug.name()+" )");
+#endif
+
+	if( msg & MNodeMessage::kConnectionMade )
+	{
+		std::string s(plug.name().asChar());
+		if(s.find("instObjGroups") != std::string::npos)
+		{
+#ifdef _DEBUG
+			MGlobal::displayInfo(plug.name());
+#endif
+			MObject display = plug.node();
+			MFnDependencyNode dFn(display);
+
+#ifdef _DEBUG
+			MGlobal::displayInfo(MString("display node ") + dFn.name());
+#endif
+			
+			MPlug msg = dFn.findPlug("message");
+			MPlugArray	connections;
+			msg.connectedTo(connections, false, true);
+#ifdef _DEBUG
+			MGlobal::displayInfo("message connections");
+			for(int oo=0; oo<connections.length(); oo++) MGlobal::displayInfo(connections[oo].name());
+			MGlobal::displayInfo("-------------------");
+#endif
+			//MPlug dsh = connections[0];
+			int idx=-1;
+			for(int oo=0; oo<(int)connections.length(); oo++)
+			{
+				MFnDependencyNode cFn(connections[oo].node());
+				if(cFn.typeId() == shaveHairShape::id)
+				{
+					MGlobal::displayInfo(MString("found ")+cFn.name());
+					idx = oo;
+					break;
+				}
+			}
+			if(idx == -1) return;
+			MPlug dsh = connections[idx];
+			MObject shape = dsh.node();
+
+			MFnDependencyNode dFn1(shape);
+#ifdef _DEBUG
+			MGlobal::displayInfo(dFn1.name());
+#endif
+			//crap, userNode is NULL for referenced object :S in 2013
+			//shaveHairShape* shaveNode = (shaveHairShape*)dFn1.userNode();
+			//MObject shader = shaveNode->getShader();
+			///////////////////////////////
+			MObject shader;
+			{
+				//MPlug		dplug= dFn1.findPlug("displayNode");
+				//MPlugArray	dconnections;
+
+				//dplug.connectedTo(dconnections, true, false);
+
+#ifdef _DEBUG
+				//if (dconnections.length() == 0) MGlobal::displayInfo(plug.name() + " does not have connection!!!!");
+#endif
+				//if (dconnections.length() > 0)
+				{
+					//MObject displayNode = dconnections[0].node();
+					//if (!displayNode.isNull())
+					{
+						//MFnDependencyNode	nodeFn(displayNode);
+						//MPlug				groupPlug = nodeFn.findPlug("instObjGroups");
+
+						//MPlug				groupPlug = plug;
+						MPlug				groupPlug = dFn.findPlug("instObjGroups");
+#ifdef _DEBUG
+						MGlobal::displayInfo(groupPlug.name());
+#endif
+						if (groupPlug.numConnectedElements() > 0)
+						{
+							MPlugArray	groupConnections;
+							groupPlug
+								.connectionByPhysicalIndex(0)
+								.connectedTo(groupConnections, false, true);
+
+							//
+							// If we're connected to a shadingEngine node, then we're done.
+							//
+							if (groupConnections.length() > 0)
+							{
+								for(unsigned int i = 0; i < groupConnections.length(); i++)
+								{
+									MObject ashader = groupConnections[i].node();
+				
+									if (ashader.hasFn(MFn::kShadingEngine))
+									{
+										shader = ashader;
+#ifdef _DEBUG
+										MGlobal::displayInfo("shader found...");
+#endif
+										break;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			///////////////////////////////
+
+			MPlug stackIdxPlug = dFn1.findPlug("stackIndex");
+			MPlugArray	connections1;
+			stackIdxPlug.connectedTo(connections1, false, true);
+			if(connections1.length() > 0)
+			{
+#ifdef _DEBUG
+				MGlobal::displayInfo(connections1[0].name());
+#endif
+				MObject vrayNode = connections1[0].node();
+				MFnDependencyNode dFn2(vrayNode);
+				MPlug outputPlug = dFn2.findPlug("output");
+				MPlugArray	connections2;
+				outputPlug.connectedTo(connections2, false, true);
+				if(connections2.length() > 0)
+				{
+#ifdef _DEBUG
+					MGlobal::displayInfo(connections2[0].name());
+#endif
+					MObject polyShape = connections2[0].node();
+					MFnDependencyNode destNode(polyShape);
+					MFnDependencyNode shaderFn(shader);
+#ifdef _DEBUG
+					MGlobal::displayInfo("shader name " + shaderFn.name());
+#endif
+
+					MPlug instGroups = destNode.findPlug("instObjGroups"); 
+					if(!instGroups.isNull())
+					{
+										
+						MPlug instGroups0 = instGroups.elementByPhysicalIndex(0);
+						if(!instGroups0.isNull())
+						{
+							if(instGroups0.isConnected())
+							{
+								MPlugArray groupsTo;
+								instGroups0.connectedTo(groupsTo,false,true);
+								for(unsigned int k = 0; k < groupsTo.length(); k++)
+								{
+									MGlobal::executeCommand("disconnectAttr " +instGroups.name() + " " + groupsTo[k].name() + ";");
+								}
+							}
+
+							MPlug dagSetPlug = shaderFn.findPlug("dagSetMembers");
+							if(!dagSetPlug.isNull())
+							{
+								MPlug dagSetPlugK;
+								for(int oo = 0; oo < 100000; oo++)
+								{
+									dagSetPlugK = dagSetPlug.elementByLogicalIndex(oo);
+									if(!dagSetPlugK.isConnected())
+										break;
+								}
+#ifdef _DEBUG
+								MGlobal::displayInfo("connectAttr " + instGroups0.name() + " " + dagSetPlugK.name() + ";");
+#endif
+								MGlobal::executeCommand("connectAttr " + instGroups0.name() + " " + dagSetPlugK.name() + ";");
+							}
+							else
+								MGlobal::displayError("shaveVrayShaderChangeCbk: can not find 'dagSetMembers'.");
+						}
+						else
+							MGlobal::displayError("shaveVrayShaderChangeCbk: can not find 'instObjGroups0' plug.");
+					}
+					else
+						MGlobal::displayError("shaveVrayShaderChangeCbk: can not find 'instObjGroups' plug.");
+				}
+									
+			}
+
+#if 0
+			//works but create a lot of dumb looping
+			MGlobal::executeCommand("shaveVrayShader -delete -all");
+			MGlobal::executeCommand("shaveVrayShader -create -all");
+#endif
+		}
+
+	}
+}
+
+#if 0
+bool shaveVrayCmd::registerLayersCallback()
+{
+	 MObjectArray lm;
+	 FindNodesByApiType(MFn::kRenderLayerManager,lm);
+	 if(lm.length() > 0)
+	 {
+		MStatus stat;
+		assert(layerCbkId==0);
+		layerCbkId = MNodeMessage::addAttributeChangedCallback (lm[0], shaveVrayLayerCbk, NULL, &stat);
+		if(stat!=MStatus::kSuccess)
+		{
+			MGlobal::displayError("shaveVrayCmd: can not register layer callback.");
+			return false;
+		}
+		return true;
+	 }
+	 return false;
+}
+
+bool shaveVrayCmd::deregisterLayersCallack()
+{
+	if(layerCbkId!=0)
+	{
+		 MStatus stat = MNodeMessage::removeCallback(layerCbkId);
+		 layerCbkId = 0;
+		 if(stat != MStatus::kSuccess)
+		 {
+			MGlobal::displayError("shaveVrayCmd: can not deregister layer callback.");
+			
+			return false;
+		 }
+		 return true;
+	}
+	return false;
+}
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~ callback ~~~~~~~~~~~~~~~~~~~~~~~~*/
+
+void shaveVrayLayerCbk(MNodeMessage::AttributeMessage msg, MPlug &plug, MPlug &otherPlug, void *clientData)
+{
+	//crap, correct shader is connected but it like 
+	//we a step backward
+	 if( msg & MNodeMessage::kAttributeSet )
+	 {
+		//this is called in time
+#ifdef _DEBUG
+		MGlobal::displayInfo("shaveVrayLayerCbk");
+#endif
+		int v;
+		plug.getValue(v);
+#ifdef _DEBUG
+		MGlobal::displayInfo(plug.name() + " value " + v);
+#endif	
+		MObjectArray layers;
+		MFnRenderLayer::listAllRenderLayers(layers);
+		MFnDependencyNode dFn(layers[v]);
+#ifdef _DEBUG
+		MGlobal::displayInfo("Layer " + dFn.name());
+#endif 
+		
+		//MGlobal::executeCommand("editRenderLayerGlobals -currentRenderLayer "+dFn.name());	//is it essencial?
+		//if se do it on the place incorrect mtls are fetched becuse connections were not updated yet	
+		//if we do on idle correct materials are recived but we are too late
+		MGlobal::executeCommandOnIdle("shaveVrayShader -delete -all");
+		MGlobal::executeCommandOnIdle("shaveVrayShader -create -all");
+	 }
+}
+#endif
+
+#endif