LightMaterialOverride::LightMaterialOverride(const MObject& obj)
: MPxSurfaceShadingNodeOverride(obj)
{
	MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
	if (theRenderer)
	{
		MHWRender::MFragmentManager* fragmentMgr = theRenderer->getFragmentManager();
		if (fragmentMgr)
		{
			for (uint i = 0; i < MayaTo::getWorldPtr()->shaderSearchPath.length(); i++)
				fragmentMgr->addFragmentPath(MayaTo::getWorldPtr()->shaderSearchPath[i]);

			MString fragment = "CoronaLight";
			bool fragAdded = fragmentMgr->hasFragment(fragment);
			if (!fragAdded)
			{
				fragAdded = (fragment == fragmentMgr->addShadeFragmentFromFile(fragment + ".xml", false));
				if (fragAdded)
				{
					MGlobal::displayInfo(MString("Successfully loaded fragment ") + fragment + ".xml");
				}
				else{
					MGlobal::displayInfo(MString("Could not load fragment ") + fragment + ".xml");
				}
			}
		}
	}
}
MStatus simpleNoiseShaderOverride::deregisterFragments()
{
	// Get fragment manager for deregistration
	MHWRender::MFragmentManager* fragmentMgr =
		MHWRender::MRenderer::theRenderer()
			? MHWRender::MRenderer::theRenderer()->getFragmentManager()
			: NULL;
	// No fragment manager, fail
	if (!fragmentMgr) return MS::kFailure;

	// Remove fragments from library on plugin unload
	if (!fragmentMgr->removeFragment("simpleNoiseOutput")) return MS::kFailure;
	if (!fragmentMgr->removeFragment("simpleNoiseBase")) return MS::kFailure;
	if (!fragmentMgr->removeFragment(sFinalFragmentGraphName)) return MS::kFailure;

	return MS::kSuccess;
}
Esempio n. 3
0
CheckerNodeOverride::CheckerNodeOverride(const MObject& obj)
: MPxShadingNodeOverride(obj)
, fFragmentName("")
{
	// Fragments are defined in separate XML files, add the checker node
	// directory to the search path and load from the files.
	static const MString sFragmentName("checkerNodePluginFragment");
	static const MString sFragmentOutputName("checkerNodePluginFragmentOutput");
	static const MString sFragmentGraphName("checkerNodePluginGraph");
	MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
	if (theRenderer)
	{
		MHWRender::MFragmentManager* fragmentMgr =
			theRenderer->getFragmentManager();
		if (fragmentMgr)
		{
			// Add search path (once only)
			static bool sAdded = false;
			if (!sAdded)
			{
				MString location;
				if( ! MGlobal::executeCommand(MString("getModulePath -moduleName \"devkit\""), location, false) ) {
					location = MString(getenv("MAYA_LOCATION")) + MString("/devkit");
				} 
				location += "/plug-ins/checkerShader";
				fragmentMgr->addFragmentPath(location);
				sAdded = true;
			}

			// Add fragments if needed
			bool fragAdded = fragmentMgr->hasFragment(sFragmentName);
			bool structAdded = fragmentMgr->hasFragment(sFragmentOutputName);
			bool graphAdded = fragmentMgr->hasFragment(sFragmentGraphName);
			if (!fragAdded)
			{
				fragAdded = (sFragmentName == fragmentMgr->addShadeFragmentFromFile(sFragmentName + ".xml", false));
			}
			if (!structAdded)
			{
				structAdded = (sFragmentOutputName == fragmentMgr->addShadeFragmentFromFile(sFragmentOutputName + ".xml", false));
			}
			if (!graphAdded)
			{
				graphAdded = (sFragmentGraphName == fragmentMgr->addFragmentGraphFromFile(sFragmentGraphName + ".xml"));
			}

			// If we have them all, use the final graph for the override
			if (fragAdded && structAdded && graphAdded)
			{
				fFragmentName = sFragmentGraphName;
			}
		}
	}
}
Esempio n. 4
0
depthShaderOverride::depthShaderOverride(const MObject& obj)
: MPxSurfaceShadingNodeOverride(obj)
, fFragmentName("")
{
	// Define fragments needed for VP2 version of shader, this could also be
	// defined in a separate XML file
	//
	// Define the input and output parameter names to match the input and
	// output attribute names so that the values are automatically populated
	// on the shader.
	//
	// Define a separate fragment for computing the camera space position so
	// that the operation can be done in the vertex shader rather than the
	// pixel shader. Then connect the two fragments together in a graph.
	static const MString sFragmentName("depthShaderPluginFragment");
	static const char* sFragmentBody =
		"<fragment uiName=\"depthShaderPluginFragment\" name=\"depthShaderPluginFragment\" type=\"plumbing\" class=\"ShadeFragment\" version=\"1.0\">"
		"	<description><![CDATA[Depth shader fragment]]></description>"
		"	<properties>"
		"		<float name=\"depthValue\" />"
		"		<float3 name=\"color\" />"
		"		<float3 name=\"colorFar\" />"
		"		<float name=\"near\" />"
		"		<float name=\"far\" />"
		"	</properties>"
		"	<values>"
		"		<float name=\"depthValue\" value=\"0.0\" />"
		"		<float3 name=\"color\" value=\"0.0,1.0,0.0\" />"
		"		<float3 name=\"colorFar\" value=\"0.0,0.0,1.0\" />"
		"		<float name=\"near\" value=\"0.0\" />"
		"		<float name=\"far\" value=\"2.0\" />"
		"	</values>"
		"	<outputs>"
		"		<float3 name=\"outColor\" />"
		"	</outputs>"
		"	<implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"Cg\" lang_version=\"2.1\">"
		"		<function_name val=\"depthShaderPluginFragment\" />"
		"		<source><![CDATA["
		"float3 depthShaderPluginFragment(float depthValue, float3 cNear, float3 cFar, float nearClip, float farClip) \n"
		"{ \n"
		"	float ratio = (farClip + depthValue)/(farClip - nearClip); \n"
		"	return cNear*ratio + cFar*(1.0f - ratio); \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"HLSL\" lang_version=\"11.0\">"
		"		<function_name val=\"depthShaderPluginFragment\" />"
		"		<source><![CDATA["
		"float3 depthShaderPluginFragment(float depthValue, float3 cNear, float3 cFar, float nearClip, float farClip) \n"
		"{ \n"
		"	float ratio = (farClip + depthValue)/(farClip - nearClip); \n"
		"	return cNear*ratio + cFar*(1.0f - ratio); \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"GLSL\" lang_version=\"3.0\">"
		"		<function_name val=\"depthShaderPluginFragment\" />"
		"		<source><![CDATA["
		"vec3 depthShaderPluginFragment(float depthValue, vec3 cNear, vec3 cFar, float nearClip, float farClip) \n"
		"{ \n"
		"	float ratio = (farClip + depthValue)/(farClip - nearClip); \n"
		"	return cNear*ratio + cFar*(1.0f - ratio); \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	</implementation>"
		"</fragment>";

	static const MString sVertexFragmentName("depthShaderPluginInterpolantFragment");
	static const char* sVertexFragmentBody =
		"<fragment uiName=\"depthShaderPluginInterpolantFragment\" name=\"depthShaderPluginInterpolantFragment\" type=\"interpolant\" class=\"ShadeFragment\" version=\"1.0\">"
		"	<description><![CDATA[Depth shader vertex fragment]]></description>"
		"	<properties>"
		"		<float3 name=\"Pm\" semantic=\"Pm\" flags=\"varyingInputParam\" />"
		"		<float4x4 name=\"worldViewProj\" semantic=\"worldviewprojection\" />"
		"	</properties>"
		"	<values>"
		"	</values>"
		"	<outputs>"
		"		<float name=\"outDepthValue\" ^1s/>"
		"	</outputs>"
		"	<implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"Cg\" lang_version=\"2.1\">"
		"		<function_name val=\"depthShaderPluginInterpolantFragment\" />"
		"		<source><![CDATA["
		"float depthShaderPluginInterpolantFragment(float depthValue) \n"
		"{ \n"
		"	return depthValue; \n"
		"} \n]]>"
		"		</source>"
		"		<vertex_source><![CDATA["
		"float idepthShaderPluginInterpolantFragment(float3 Pm, float4x4 worldViewProj) \n"
		"{ \n"
		"	float4 pCamera = mul(worldViewProj, float4(Pm, 1.0f)); \n"
		"	return (pCamera.z - pCamera.w*2.0f); \n"
		"} \n]]>"
		"		</vertex_source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"HLSL\" lang_version=\"11.0\">"
		"		<function_name val=\"depthShaderPluginInterpolantFragment\" />"
		"		<source><![CDATA["
		"float depthShaderPluginInterpolantFragment(float depthValue) \n"
		"{ \n"
		"	return depthValue; \n"
		"} \n]]>"
		"		</source>"
		"		<vertex_source><![CDATA["
		"float idepthShaderPluginInterpolantFragment(float3 Pm, float4x4 worldViewProj) \n"
		"{ \n"
		"	float4 pCamera = mul(float4(Pm, 1.0f), worldViewProj); \n"
		"	return (pCamera.z - pCamera.w*2.0f); \n"
		"} \n]]>"
		"		</vertex_source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"GLSL\" lang_version=\"3.0\">"
		"		<function_name val=\"depthShaderPluginInterpolantFragment\" />"
		"		<source><![CDATA["
		"float depthShaderPluginInterpolantFragment(float depthValue) \n"
		"{ \n"
		"	return depthValue; \n"
		"} \n]]>"
		"		</source>"
		"		<vertex_source><![CDATA["
		"float idepthShaderPluginInterpolantFragment(vec3 Pm, mat4 worldViewProj) \n"
		"{ \n"
		"	vec4 pCamera = worldViewProj * vec4(Pm, 1.0f); \n"
		"	return (pCamera.z - pCamera.w*2.0f); \n"
		"} \n]]>"
		"		</vertex_source>"
		"	</implementation>"
		"	</implementation>"
		"</fragment>";

	static const MString sFragmentGraphName("depthShaderPluginGraph");
	static const char* sFragmentGraphBody =
		"<fragment_graph name=\"depthShaderPluginGraph\" ref=\"depthShaderPluginGraph\" class=\"FragmentGraph\" version=\"1.0\">"
		"	<fragments>"
		"			<fragment_ref name=\"depthShaderPluginFragment\" ref=\"depthShaderPluginFragment\" />"
		"			<fragment_ref name=\"depthShaderPluginInterpolantFragment\" ref=\"depthShaderPluginInterpolantFragment\" />"
		"	</fragments>"
		"	<connections>"
		"		<connect from=\"depthShaderPluginInterpolantFragment.outDepthValue\" to=\"depthShaderPluginFragment.depthValue\" />"
		"	</connections>"
		"	<properties>"
        "		<float3 name=\"Pm\" ref=\"depthShaderPluginInterpolantFragment.Pm\" semantic=\"Pm\" flags=\"varyingInputParam\" />"
        "		<float4x4 name=\"worldViewProj\" ref=\"depthShaderPluginInterpolantFragment.worldViewProj\" semantic=\"worldviewprojection\" />"
		"		<float3 name=\"color\" ref=\"depthShaderPluginFragment.color\" />"
		"		<float3 name=\"colorFar\" ref=\"depthShaderPluginFragment.colorFar\" />"
		"		<float name=\"near\" ref=\"depthShaderPluginFragment.near\" />"
		"		<float name=\"far\" ref=\"depthShaderPluginFragment.far\" />"
		"	</properties>"
		"	<values>"
		"		<float3 name=\"color\" value=\"0.0,1.0,0.0\" />"
		"		<float3 name=\"colorFar\" value=\"0.0,0.0,1.0\" />"
		"		<float name=\"near\" value=\"0.0\" />"
		"		<float name=\"far\" value=\"2.0\" />"
		"	</values>"
		"	<outputs>"
		"		<float3 name=\"outColor\" ref=\"depthShaderPluginFragment.outColor\" />"
		"	</outputs>"
		"</fragment_graph>";

	// Register fragments with the manager if needed
	MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
	if (theRenderer)
	{
		MHWRender::MFragmentManager* fragmentMgr =
			theRenderer->getFragmentManager();
		if (fragmentMgr)
		{
			// Add fragments if needed
			bool fragAdded = fragmentMgr->hasFragment(sFragmentName);
			bool vertFragAdded = fragmentMgr->hasFragment(sVertexFragmentName);
			bool graphAdded = fragmentMgr->hasFragment(sFragmentGraphName);
			if (!fragAdded)
			{
				fragAdded = (sFragmentName == fragmentMgr->addShadeFragmentFromBuffer(sFragmentBody, false));
			}
			if (!vertFragAdded)
			{
				// In DirectX, need to specify a semantic for the output of the vertex shader
				MString vertBody;
				if (theRenderer->drawAPI() == MHWRender::kDirectX11)
				{
					vertBody.format(MString(sVertexFragmentBody), MString("semantic=\"extraDepth\" "));
				}
				else
				{
					vertBody.format(MString(sVertexFragmentBody), MString(" "));
				}
				vertFragAdded = (sVertexFragmentName == fragmentMgr->addShadeFragmentFromBuffer(vertBody.asChar(), false));
			}
			if (!graphAdded)
			{
				graphAdded = (sFragmentGraphName == fragmentMgr->addFragmentGraphFromBuffer(sFragmentGraphBody));
			}

			// If we have them all, use the final graph for the override
			if (fragAdded && vertFragAdded && graphAdded)
			{
				fFragmentName = sFragmentGraphName;
			}
		}
	}
}
Esempio n. 5
0
GammaOverride::GammaOverride(const MObject& obj)
: MPxShadingNodeOverride(obj)
, fFragmentName("")
{
	// Define fragments needed for VP2 version of shader, this could also be
	// defined in a separate XML file
	//
	// Define the input and output parameter names to match the input and
	// output attribute names so that the values are automatically populated
	// on the shader.
	static const MString sFragmentName("gammaShaderPluginFragment");
	static const char* sFragmentBody =
		"<fragment uiName=\"gammaShaderPluginFragment\" name=\"gammaShaderPluginFragment\" type=\"plumbing\" class=\"ShadeFragment\" version=\"1.0\">"
		"	<description><![CDATA[Gamma utility fragment]]></description>"
		"	<properties>"
		"		<float3 name=\"color\" />"
		"		<float3 name=\"gamma\" />"
		"	</properties>"
		"	<values>"
		"		<float3 name=\"color\" value=\"0.5,0.5,0.5\" />"
		"		<float3 name=\"gamma\" value=\"1.0,1.0,1.0\" />"
		"	</values>"
		"	<outputs>"
		"		<float3 name=\"outColor\" />"
		"	</outputs>"
		"	<implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"Cg\" lang_version=\"2.1\">"
		"		<function_name val=\"gammaShaderPluginFragment\" />"
		"		<source><![CDATA["
		"float3 gammaShaderPluginFragment(float3 icol, float3 igam) \n"
		"{ \n"
		"	float3 result; \n"
		"	result.r = pow(icol.r, 1.0f/igam.r); \n"
		"	result.g = pow(icol.g, 1.0f/igam.g); \n"
		"	result.b = pow(icol.b, 1.0f/igam.b); \n"
		"	return result; \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"HLSL\" lang_version=\"11.0\">"
		"		<function_name val=\"gammaShaderPluginFragment\" />"
		"		<source><![CDATA["
		"float3 gammaShaderPluginFragment(float3 icol, float3 igam) \n"
		"{ \n"
		"	float3 result; \n"
		"	result.r = pow(icol.r, 1.0f/igam.r); \n"
		"	result.g = pow(icol.g, 1.0f/igam.g); \n"
		"	result.b = pow(icol.b, 1.0f/igam.b); \n"
		"	return result; \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	<implementation render=\"OGSRenderer\" language=\"GLSL\" lang_version=\"3.0\">"
		"		<function_name val=\"gammaShaderPluginFragment\" />"
		"		<source><![CDATA["
		"vec3 gammaShaderPluginFragment(vec3 icol, vec3 igam) \n"
		"{ \n"
		"	vec3 result; \n"
		"	result.r = pow(icol.r, 1.0f/igam.r); \n"
		"	result.g = pow(icol.g, 1.0f/igam.g); \n"
		"	result.b = pow(icol.b, 1.0f/igam.b); \n"
		"	return result; \n"
		"} \n]]>"
		"		</source>"
		"	</implementation>"
		"	</implementation>"
		"</fragment>";

	// Register fragments with the manager if needed
	MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
	if (theRenderer)
	{
		MHWRender::MFragmentManager* fragmentMgr =
			theRenderer->getFragmentManager();
		if (fragmentMgr)
		{
			// Add fragments if needed
			bool fragAdded = fragmentMgr->hasFragment(sFragmentName);
			if (!fragAdded)
			{
				fragAdded = (sFragmentName == fragmentMgr->addShadeFragmentFromBuffer(sFragmentBody, false));
			}

			// Use the fragment on successful add
			if (fragAdded)
			{
				fFragmentName = sFragmentName;
			}
		}
	}
}
// Static fragment registration/deregistration methods called from plugin
// init/unint functions. Only need to be called once.
MStatus simpleNoiseShaderOverride::registerFragments()
{
	// Get fragment manager for registration
	MHWRender::MFragmentManager* fragmentMgr =
		MHWRender::MRenderer::theRenderer()
			? MHWRender::MRenderer::theRenderer()->getFragmentManager()
			: NULL;
	// No fragment manager, fail
	if (!fragmentMgr) return MS::kFailure;
	// Fragments are already registered, return success
	if (fragmentMgr->hasFragment(sFinalFragmentGraphName)) return MS::kSuccess;

	MString fragmentName;
	char* fragmentBody = NULL;

	// ------------------------------------------------------------------------
	// Struct declaration fragment. This fragment provides the declaration of
	// the output structure of the simple noise fragment graph giving support
	// for multiple outputs. The struct fragment must be a part of the final
	// fragment graph in order to ensure that the fragment system includes
	// the declaration of the struct in the final effect.
	//
	fragmentName = "simpleNoiseOutput";
	fragmentBody =
		"<fragment uiName=\"simpleNoiseOutput\" name=\"simpleNoiseOutput\" type=\"structure\" class=\"ShadeFragment\" version=\"1.0\"> \r\n"
		"	<description><![CDATA[Struct output for simple noise shader]]></description> \r\n"
		"	<properties> \r\n"
		"		<struct name=\"simpleNoiseOutput\" struct_name=\"simpleNoiseOutput\" /> \r\n"
		"	</properties> \r\n"
		"	<values> \r\n"
		"	</values> \r\n"
		"	<outputs> \r\n"
		"		<alias name=\"simpleNoiseOutput\" struct_name=\"simpleNoiseOutput\" /> \r\n"
		"		<float3 name=\"outColor\" /> \r\n"
		"		<float name=\"outAlpha\" /> \r\n"
		"	</outputs> \r\n"
		"	<implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"Cg\" lang_version=\"2.1\"> \r\n"
		"		<function_name val=\"\" /> \r\n"
		"		<declaration name=\"simpleNoiseOutput\"><![CDATA[ \r\n"
		"struct simpleNoiseOutput \r\n"
		"{ \r\n"
		"	float3 outColor; \r\n"
		"	float outAlpha; \r\n"
		"}; \r\n"
		"		]]></declaration> \r\n"
		"	</implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"HLSL\" lang_version=\"11.0\"> \r\n"
		"		<function_name val=\"\" /> \r\n"
		"		<declaration name=\"simpleNoiseOutput\"><![CDATA[ \r\n"
		"struct simpleNoiseOutput \r\n"
		"{ \r\n"
		"	float3 outColor; \r\n"
		"	float outAlpha; \r\n"
		"}; \r\n"
		"		]]></declaration> \r\n"
		"	</implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"GLSL\" lang_version=\"3.0\"> \r\n"
		"		<function_name val=\"\" /> \r\n"
		"		<declaration name=\"simpleNoiseOutput\"><![CDATA[ \r\n"
		"struct simpleNoiseOutput \r\n"
		"{ \r\n"
		"	vec3 outColor; \r\n"
		"	float outAlpha; \r\n"
		"}; \r\n"
		"		]]></declaration> \r\n"
		"	</implementation> \r\n"
		"	</implementation> \r\n"
		"</fragment> \r\n";
	if (fragmentName != fragmentMgr->addShadeFragmentFromBuffer(fragmentBody, false)) return MS::kFailure;

	// ------------------------------------------------------------------------
	// Actual noise computation fragment. Based on Maya's "wave" noise type
	// from the 2d procedural noise texture node. Computes a struct output
	// containing both color and alpha to match the outputs of the DG node.
	// Uses a 3D texture loaded with the entire Maya noise table for generating
	// results consistent with the compute() method of the associated node.
	//
	fragmentName = "simpleNoiseBase";
	fragmentBody =
		"<fragment uiName=\"simpleNoiseBase\" name=\"simpleNoiseBase\" type=\"plumbing\" class=\"ShadeFragment\" version=\"1.0\"> \r\n"
		"	<description><![CDATA[Computes simple 2D procedural noise]]></description> \r\n"
		"	<properties> \r\n"
		"		<float2 name=\"uvCoord\" semantic=\"mayaUvCoordSemantic\" flags=\"varyingInputParam\" /> \r\n"
		"		<texture3 name=\"noiseLookupMap\" /> \r\n"
		"		<sampler name=\"noiseLookupMapSampler\" /> \r\n"
		"		<float name=\"amplitude\" /> \r\n"
		"		<float name=\"ratio\" /> \r\n"
		"		<int name=\"depthMax\" /> \r\n"
		"		<float name=\"frequency\" /> \r\n"
		"		<float name=\"frequencyRatio\" /> \r\n"
		"		<float name=\"time\" /> \r\n"
		"		<int name=\"numWaves\" /> \r\n"
		"	</properties> \r\n"
		"	<values> \r\n"
		"		<float name=\"amplitude\" value=\"1.0\" /> \r\n"
		"		<float name=\"ratio\" value=\"0.707000\" /> \r\n"
		"		<int name=\"depthMax\" value=\"3\" /> \r\n"
		"		<float name=\"frequency\" value=\"8.0\" /> \r\n"
		"		<float name=\"frequencyRatio\" value=\"2.0\" /> \r\n"
		"		<float name=\"time\" value=\"0.0\" /> \r\n"
		"		<int name=\"numWaves\" value=\"5\" /> \r\n"
		"	</values> \r\n"
		"	<outputs> \r\n"
		"		<struct name=\"simpleNoiseBase\" struct_name=\"simpleNoiseOutput\" /> \r\n"
		"	</outputs> \r\n"
		"	<implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"Cg\" lang_version=\"2.1\"> \r\n"
		"		<function_name val=\"simpleNoise\" /> \r\n"
		"		<source><![CDATA[ \r\n"
		"float simpleNoise_RawNoiseLookup( \r\n"
		"	int index, \r\n"
		"	texture3D noiseLookupMap, \r\n"
		"	sampler3D noiseLookupMapSampler) \r\n"
		"{ \r\n"
		"	int3 index3; \r\n"
		"	index3.x = index; \r\n"
		"	index3.y = (index>> 5); \r\n"
		"	index3.z = (index>> 10); \r\n"
		"	index3 &= 31; \r\n"
		"	float3 uvw = float3(index3) / 32.0f; \r\n"
		"	return (tex3D(noiseLookupMapSampler, uvw).r * 2.0f) - 1.0f; \r\n"
		"} \r\n"
		"simpleNoiseOutput simpleNoise( \r\n"
		"	float2 uv, \r\n"
		"	texture3D noiseLookupMap, \r\n"
		"	sampler3D noiseLookupMapSampler, \r\n"
		"	float amplitude, \r\n"
		"	float ratio, \r\n"
		"	int depthMax, \r\n"
		"	float frequency, \r\n"
		"	float frequencyRatio, \r\n"
		"	float time, \r\n"
		"	int numWaves) \r\n"
		"{ \r\n"
		"	const float M_PI = 3.1415926535897f; \r\n"
		"	const float M_2PI = 2.0f*M_PI; \r\n"
		"	simpleNoiseOutput finalResult; \r\n"
		"	float timeRatio = sqrt(frequencyRatio); \r\n"
		"	uv *= frequency; \r\n"
		"	float cosine = 0.0f; \r\n"
		"	float noise = 0.0f; \r\n"
		"	int depthId = 0; \r\n"
		"	int waveId = 0; \r\n"
		"	int seedOffset = 0; \r\n"
		"	while (depthId<depthMax && waveId<numWaves) { \r\n"
		"		int step = depthId; \r\n"
		"		int seed = 50*step; \r\n"
		"		float2 dir = float2( \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler), \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler)); \r\n"
		"		float norm = length(dir); \r\n"
		"		if (norm <= 0.0f) continue; \r\n"
		"		dir /= norm; \r\n"
		"		noise += cos(dir.x*uv.x*M_2PI + dir.y*uv.y*M_2PI + M_PI*simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler) + time*M_PI); \r\n"
		"		++waveId; \r\n"
		"		if (waveId < numWaves) continue; \r\n"
		"		noise /= float(numWaves); \r\n"
		"		uv *= frequencyRatio; \r\n"
		"		time *= timeRatio; \r\n"
		"		cosine += amplitude * noise; \r\n"
		"		amplitude *= ratio; \r\n"
		"		noise = 0.0f; \r\n"
		"		waveId = 0; \r\n"
		"		seedOffset = 0; \r\n"
		"		++depthId; \r\n"
		"	} \r\n"
		"	cosine = 0.5f*cosine + 0.5f; \r\n"
		"	float noiseVal = (cosine> 1.0f) ? 1.0f : cosine; \r\n"
		"	finalResult.outColor = float3(noiseVal, noiseVal, noiseVal); \r\n"
		"	finalResult.outAlpha = noiseVal; \r\n"
		"	return finalResult; \r\n"
		"} \r\n"
		"		]]></source> \r\n"
		"	</implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"HLSL\" lang_version=\"11.0\"> \r\n"
		"		<function_name val=\"simpleNoise\" /> \r\n"
		"		<source><![CDATA[ \r\n"
		"float simpleNoise_RawNoiseLookup( \r\n"
		"	int index, \r\n"
		"	Texture3D noiseLookupMap, \r\n"
		"	sampler noiseLookupMapSampler) \r\n"
		"{ \r\n"
		"	int3 index3; \r\n"
		"	index3.x = index; \r\n"
		"	index3.y = (index>> 5); \r\n"
		"	index3.z = (index>> 10); \r\n"
		"	index3 &= 31; \r\n"
		"	float3 uvw = float3(index3) / 32.0f; \r\n"
		"	return (noiseLookupMap.SampleLevel(noiseLookupMapSampler, uvw, 0).r * 2.0f) - 1.0f; \r\n"
		"} \r\n"
		"simpleNoiseOutput simpleNoise( \r\n"
		"	float2 uv, \r\n"
		"	Texture3D noiseLookupMap, \r\n"
		"	sampler noiseLookupMapSampler, \r\n"
		"	float amplitude, \r\n"
		"	float ratio, \r\n"
		"	int depthMax, \r\n"
		"	float frequency, \r\n"
		"	float frequencyRatio, \r\n"
		"	float time, \r\n"
		"	int numWaves) \r\n"
		"{ \r\n"
		"	const float M_PI = 3.1415926535897f; \r\n"
		"	const float M_2PI = 2.0f*M_PI; \r\n"
		"	simpleNoiseOutput finalResult; \r\n"
		"	float timeRatio = sqrt(frequencyRatio); \r\n"
		"	uv *= frequency; \r\n"
		"	float cosine = 0.0f; \r\n"
		"	float noise = 0.0f; \r\n"
		"	int depthId = 0; \r\n"
		"	int waveId = 0; \r\n"
		"	int seedOffset = 0; \r\n"
		"	while (depthId<depthMax && waveId<numWaves) { \r\n"
		"		int step = depthId; \r\n"
		"		int seed = 50*step; \r\n"
		"		float2 dir = float2( \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler), \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler)); \r\n"
		"		float norm = length(dir); \r\n"
		"		if (norm <= 0.0f) continue; \r\n"
		"		dir /= norm; \r\n"
		"		noise += cos(dir.x*uv.x*M_2PI + dir.y*uv.y*M_2PI + M_PI*simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMap, noiseLookupMapSampler) + time*M_PI); \r\n"
		"		++waveId; \r\n"
		"		if (waveId < numWaves) continue; \r\n"
		"		noise /= float(numWaves); \r\n"
		"		uv *= frequencyRatio; \r\n"
		"		time *= timeRatio; \r\n"
		"		cosine += amplitude * noise; \r\n"
		"		amplitude *= ratio; \r\n"
		"		noise = 0.0f; \r\n"
		"		waveId = 0; \r\n"
		"		seedOffset = 0; \r\n"
		"		++depthId; \r\n"
		"	} \r\n"
		"	cosine = 0.5f*cosine + 0.5f; \r\n"
		"	float noiseVal = (cosine> 1.0f) ? 1.0f : cosine; \r\n"
		"	finalResult.outColor = float3(noiseVal, noiseVal, noiseVal); \r\n"
		"	finalResult.outAlpha = noiseVal; \r\n"
		"	return finalResult; \r\n"
		"} \r\n"
		"		]]></source> \r\n"
		"	</implementation> \r\n"
		"	<implementation render=\"OGSRenderer\" language=\"GLSL\" lang_version=\"3.0\"> \r\n"
		"		<function_name val=\"simpleNoise\" /> \r\n"
		"		<source><![CDATA[ \r\n"
		"float simpleNoise_RawNoiseLookup( \r\n"
		"	int index, \r\n"
		"	sampler3D noiseLookupMapSampler) \r\n"
		"{ \r\n"
		"	ivec3 index3; \r\n"
		"	index3.x = index; \r\n"
		"	index3.y = (index >> 5); \r\n"
		"	index3.z = (index >> 10); \r\n"
		"	index3 &= 31; \r\n"
		"	vec3 uvw = vec3(index3) / 32.0f; \r\n"
		"	return (texture(noiseLookupMapSampler, uvw).r * 2.0f) - 1.0f; \r\n"
		"} \r\n"
		"simpleNoiseOutput simpleNoise( \r\n"
		"	vec2 uv, \r\n"
		"	sampler3D noiseLookupMapSampler, \r\n"
		"	float amplitude, \r\n"
		"	float ratio, \r\n"
		"	int depthMax, \r\n"
		"	float frequency, \r\n"
		"	float frequencyRatio, \r\n"
		"	float time, \r\n"
		"	int numWaves) \r\n"
		"{ \r\n"
		"	const float M_PI = 3.1415926535897f; \r\n"
		"	const float M_2PI = 2.0f*M_PI; \r\n"
		"	simpleNoiseOutput finalResult; \r\n"
		"	float timeRatio = sqrt(frequencyRatio); \r\n"
		"	uv *= frequency; \r\n"
		"	float cosine = 0.0f; \r\n"
		"	float noise = 0.0f; \r\n"
		"	int depthId = 0; \r\n"
		"	int waveId = 0; \r\n"
		"	int seedOffset = 0; \r\n"
		"	while (depthId<depthMax && waveId<numWaves) { \r\n"
		"		int step = depthId; \r\n"
		"		int seed = 50*step; \r\n"
		"		vec2 dir = vec2( \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMapSampler), \r\n"
		"			simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMapSampler)); \r\n"
		"		float norm = length(dir); \r\n"
		"		if (norm <= 0.0f) continue; \r\n"
		"		dir /= norm; \r\n"
		"		noise += cos(dir.x*uv.x*M_2PI + dir.y*uv.y*M_2PI + M_PI*simpleNoise_RawNoiseLookup(seed + seedOffset++, noiseLookupMapSampler) + time*M_PI); \r\n"
		"		++waveId; \r\n"
		"		if (waveId < numWaves) continue; \r\n"
		"		noise /= float(numWaves); \r\n"
		"		uv *= frequencyRatio; \r\n"
		"		time *= timeRatio; \r\n"
		"		cosine += amplitude * noise; \r\n"
		"		amplitude *= ratio; \r\n"
		"		noise = 0.0f; \r\n"
		"		waveId = 0; \r\n"
		"		seedOffset = 0; \r\n"
		"		++depthId; \r\n"
		"	} \r\n"
		"	cosine = 0.5f*cosine + 0.5f; \r\n"
		"	float noiseVal = (cosine > 1.0f) ? 1.0f : cosine; \r\n"
		"	finalResult.outColor = vec3(noiseVal, noiseVal, noiseVal); \r\n"
		"	finalResult.outAlpha = noiseVal; \r\n"
		"	return finalResult; \r\n"
		"} \r\n"
		"		]]></source> \r\n"
		"	</implementation> \r\n"
		"	</implementation> \r\n"
		"</fragment> \r\n";
	if (fragmentName != fragmentMgr->addShadeFragmentFromBuffer(fragmentBody, false)) return MS::kFailure;

	// ------------------------------------------------------------------------
	// Full, final graph made up of previously registered fragments. A picture
	// which flows from top to bottom.
	//
	//                         simpleNoiseBase
	//                                |
	//                        simpleNoiseOutput
	//                                |
	//                          <FINAL RESULT>
	//
	// Maya's shader translation system will take this graph and connect UV
	// information where appropriate.
	//
	// From Maya's point of view, this graph is fully representative of the
	// associated shading node in the DG. All inputs and outputs on this graph
	// are matched to inputs and outputs on the DG node. Connections to other
	// nodes (input or output) will be mirrored by connections to other
	// fragments using the matching parameters.
	//
	fragmentName = sFinalFragmentGraphName;
	fragmentBody =
		"<fragment_graph name=\"simpleNoise\" ref=\"simpleNoise\" class=\"FragmentGraph\" version=\"1.0\"> \r\n"
		"	<fragments> \r\n"
		"		<fragment_ref name=\"simpleNoiseBase\" ref=\"simpleNoiseBase\" /> \r\n"
		"		<fragment_ref name=\"simpleNoiseOutput\" ref=\"simpleNoiseOutput\" /> \r\n"
		"	</fragments> \r\n"
		"	<connections> \r\n"
		"		<connect from=\"simpleNoiseBase.simpleNoiseBase\" to=\"simpleNoiseOutput.simpleNoiseOutput\" name=\"simpleNoiseOutput\" /> \r\n"
		"	</connections> \r\n"
		"	<properties> \r\n"
		"		<float2 name=\"uvCoord\" ref=\"simpleNoiseBase.uvCoord\" semantic=\"mayaUvCoordSemantic\" flags=\"varyingInputParam\" /> \r\n"
		"		<texture3 name=\"noiseLookupMap\" ref=\"simpleNoiseBase.noiseLookupMap\" /> \r\n"
		"		<sampler name=\"noiseLookupMapSampler\" ref=\"simpleNoiseBase.noiseLookupMapSampler\" /> \r\n"
		"		<float name=\"amplitude\" ref=\"simpleNoiseBase.amplitude\" /> \r\n"
		"		<float name=\"ratio\" ref=\"simpleNoiseBase.ratio\" /> \r\n"
		"		<int name=\"depthMax\" ref=\"simpleNoiseBase.depthMax\" /> \r\n"
		"		<float name=\"frequency\" ref=\"simpleNoiseBase.frequency\" /> \r\n"
		"		<float name=\"frequencyRatio\" ref=\"simpleNoiseBase.frequencyRatio\" /> \r\n"
		"		<float name=\"time\" ref=\"simpleNoiseBase.time\" /> \r\n"
		"		<int name=\"numWaves\" ref=\"simpleNoiseBase.numWaves\" /> \r\n"
		"	</properties> \r\n"
		"	<values> \r\n"
		"		<float name=\"amplitude\" value=\"1.0\" /> \r\n"
		"		<float name=\"ratio\" value=\"0.707000\" /> \r\n"
		"		<int name=\"depthMax\" value=\"3\" /> \r\n"
		"		<float name=\"frequency\" value=\"8.0\" /> \r\n"
		"		<float name=\"frequencyRatio\" value=\"2.0\" /> \r\n"
		"		<float name=\"time\" value=\"0.0\" /> \r\n"
		"		<int name=\"numWaves\" value=\"5\" /> \r\n"
		"	</values> \r\n"
		"	<outputs> \r\n"
		"		<struct name=\"simpleNoiseOutput\" ref=\"simpleNoiseOutput.simpleNoiseOutput\" /> \r\n"
		"	</outputs> \r\n"
		"</fragment_graph> \r\n";
	if (fragmentName != fragmentMgr->addFragmentGraphFromBuffer(fragmentBody)) return MS::kFailure;

	return MS::kSuccess;
}