MStatus OccLightNode::compute( const MPlug& plug, MDataBlock& block )
{
//CM_TRACE_FUNC("SkyLightNode::compute(job="<<plug.name()<<",block)");
// outColor or individual R, G, B channel
if( (plug == aOutColor) || (plug.parent() == aOutColor) ||
(plug == aOutTransparency) || (plug.parent() == aOutTransparency)
)
{
// init shader
MStatus status;
//MFloatVector& icolor = block.inputValue(aicolor).asFloatVector();
//rendering begin (maya software)
MFloatVector resultColor;
resultColor = MFloatVector(1.0f, 1.0f, 1.0f);
//rendering end
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor, &status );
IfMErrorWarn(status);
outColorHandle.asFloatVector() = resultColor;
outColorHandle.setClean();
MDataHandle outTransHandle = block.outputValue( aOutTransparency, &status );
IfMErrorWarn(status);
outTransHandle.asFloatVector() = MFloatVector(0.0, 0.0, 0.0);
outTransHandle.setClean();
}
else {
return MS::kUnknownParameter;
}
return MS::kSuccess;
}
MStatus slopeShaderNode::compute(const MPlug & plug, MDataBlock & block )
//
// Description:
// Computes a color value
// from a surface noraml angle.
//
{
if ((plug != aOutColor) && (plug.parent() != aOutColor))
return MS::kUnknownParameter;
MFloatVector resultColor;
MFloatVector& walkable = block.inputValue( aColor1 ).asFloatVector();
MFloatVector& nonWalkable = block.inputValue( aColor2 ).asFloatVector();
MFloatVector& surfaceNormal = block.inputValue( aTriangleNormalCamera ).asFloatVector();
MFloatMatrix& viewMatrix = block.inputValue( aMatrixEyeToWorld ).asFloatMatrix();
float angle = block.inputValue( aAngle ).asFloat();
// Normalize the view vector
//
surfaceNormal.normalize();
MFloatVector WSVector = surfaceNormal * viewMatrix;
// find dot product
//
float scalarNormal = WSVector * MFloatVector(0, 1, 0);
// take the absolute value
//
if (scalarNormal < 0.0) scalarNormal *= -1.0;
if(cos(angle*AWdegreesToRadians) < scalarNormal)
resultColor = walkable;
else
resultColor = nonWalkable;
// set ouput color attribute
//
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
return MS::kSuccess;
}
MFloatVector convert( const Imath::Color3f &from )
{
return MFloatVector( from[0], from[1], from[2] );
}
/*
Utility method to update shader parameters based on available
lighting information.
*/
static void updateLightShader( MHWRender::MShaderInstance *shaderInstance,
const MHWRender::MDrawContext & context,
const MSelectionList * lightList )
{
if (!shaderInstance)
return;
// Check pass context information to see if we are in a shadow
// map update pass. If so do nothing.
//
const MHWRender::MPassContext & passCtx = context.getPassContext();
const MStringArray & passSem = passCtx.passSemantics();
bool handlePass = true;
for (unsigned int i=0; i<passSem.length() && handlePass; i++)
{
// Handle special pass drawing.
//
if (passSem[i] == MHWRender::MPassContext::kShadowPassSemantic)
{
handlePass = false;
}
}
if (!handlePass) return;
//
// Perform light shader update with lighting information
// If the light list is not empty then use that light's information.
// Otherwise choose the first appropriate light which can cast shadows.
//
// Defaults in case there are no lights
//
bool globalShadowsOn = false;
bool localShadowsOn = false;
bool shadowDirty = false;
MFloatVector direction(0.0f, 0.0f, 1.0f);
float lightIntensity = 0.0f; // If no lights then black out the light
float lightColor[3] = { 0.0f, 0.0f, 0.0f };
MStatus status;
// Scan to find the first N lights that has a direction component in it
// It's possible we find no lights.
//
MHWRender::MDrawContext::LightFilter considerAllSceneLights = MHWRender::MDrawContext::kFilteredIgnoreLightLimit;
unsigned int lightCount = context.numberOfActiveLights(considerAllSceneLights);
if (lightCount)
{
MFloatArray floatVals;
MIntArray intVals;
MHWRender::MTextureAssignment shadowResource;
shadowResource.texture = NULL;
MHWRender::MSamplerStateDesc samplerDesc;
MMatrix shadowViewProj;
float shadowColor[3] = { 0.0f, 0.0f, 0.0f };
unsigned int i=0;
bool foundDirectional = false;
for (i=0; i<lightCount && !foundDirectional ; i++)
{
MHWRender::MLightParameterInformation *lightParam = context.getLightParameterInformation( i, considerAllSceneLights );
if (lightParam)
{
// Prune against light list if any.
if (lightList && lightList->length())
{
if (!lightList->hasItem(lightParam->lightPath()))
continue;
}
MStringArray params;
lightParam->parameterList(params);
for (unsigned int p=0; p<params.length(); p++)
{
MString pname = params[p];
MHWRender::MLightParameterInformation::StockParameterSemantic semantic = lightParam->parameterSemantic( pname );
switch (semantic)
{
// Pick a few light parameters to pick up as an example
case MHWRender::MLightParameterInformation::kWorldDirection:
lightParam->getParameter( pname, floatVals );
direction = MFloatVector( floatVals[0], floatVals[1], floatVals[2] );
foundDirectional = true;
break;
case MHWRender::MLightParameterInformation::kIntensity:
lightParam->getParameter( pname, floatVals );
lightIntensity = floatVals[0];
break;
case MHWRender::MLightParameterInformation::kColor:
lightParam->getParameter( pname, floatVals );
lightColor[0] = floatVals[0];
lightColor[1] = floatVals[1];
lightColor[2] = floatVals[2];
break;
// Pick up shadowing parameters
case MHWRender::MLightParameterInformation::kGlobalShadowOn:
lightParam->getParameter( pname, intVals );
if (intVals.length())
globalShadowsOn = (intVals[0] != 0) ? true : false;
break;
case MHWRender::MLightParameterInformation::kShadowOn:
lightParam->getParameter( pname, intVals );
if (intVals.length())
localShadowsOn = (intVals[0] != 0) ? true : false;
break;
case MHWRender::MLightParameterInformation::kShadowViewProj:
lightParam->getParameter( pname, shadowViewProj);
break;
case MHWRender::MLightParameterInformation::kShadowMap:
lightParam->getParameter( pname, shadowResource );
break;
case MHWRender::MLightParameterInformation::kShadowDirty:
if (intVals.length())
shadowDirty = (intVals[0] != 0) ? true : false;
break;
case MHWRender::MLightParameterInformation::kShadowSamp:
lightParam->getParameter( pname, samplerDesc );
break;
case MHWRender::MLightParameterInformation::kShadowColor:
lightParam->getParameter( pname, floatVals );
shadowColor[0] = floatVals[0];
shadowColor[1] = floatVals[1];
shadowColor[2] = floatVals[2];
break;
default:
break;
}
} /* for params */
}
if (foundDirectional && globalShadowsOn && localShadowsOn && shadowResource.texture)
{
void *resourceHandle = shadowResource.texture->resourceHandle();
if (resourceHandle)
{
static bool debugShadowBindings = false;
status = shaderInstance->setParameter("mayaShadowPCF1_shadowMap", shadowResource );
if (status == MStatus::kSuccess && debugShadowBindings)
fprintf(stderr, "Bound shadow map to shader param mayaShadowPCF1_shadowMap\n");
status = shaderInstance->setParameter("mayaShadowPCF1_shadowViewProj", shadowViewProj );
if (status == MStatus::kSuccess && debugShadowBindings)
fprintf(stderr, "Bound shadow map transform to shader param mayaShadowPCF1_shadowViewProj\n");
status = shaderInstance->setParameter("mayaShadowPCF1_shadowColor", &shadowColor[0] );
if (status == MStatus::kSuccess && debugShadowBindings)
fprintf(stderr, "Bound shadow map color to shader param mayaShadowPCF1_shadowColor\n");
}
MHWRender::MRenderer* renderer = MHWRender::MRenderer::theRenderer();
if (renderer)
{
MHWRender::MTextureManager* textureManager = renderer->getTextureManager();
if (textureManager)
{
textureManager->releaseTexture(shadowResource.texture);
}
}
shadowResource.texture = NULL;
}
}
}
// Set up parameters which should be set regardless of light existence.
status = shaderInstance->setParameter("mayaDirectionalLight_direction", &( direction[0] ));
status = shaderInstance->setParameter("mayaDirectionalLight_intensity", lightIntensity );
status = shaderInstance->setParameter("mayaDirectionalLight_color", &( lightColor[0] ));
status = shaderInstance->setParameter("mayaShadowPCF1_mayaGlobalShadowOn", globalShadowsOn);
status = shaderInstance->setParameter("mayaShadowPCF1_mayaShadowOn", localShadowsOn);
}
MStatus liqSurfaceNode::compute( const MPlug& plug, MDataBlock& block )
{
// outColor or individual R, G, B channel
if( (plug == aOutColor) || (plug.parent() == aOutColor) ||
(plug == aOutTransparency) || (plug.parent() == aOutTransparency)
) {
//cout <<"compute... "<<endl;
// init shader
MStatus status;
MFloatVector theColor( 0.0f, 0.0f, 0.0f );
MFloatVector& cColor = block.inputValue(aColor).asFloatVector();
MFloatVector& cTrans = block.inputValue(aOpacity).asFloatVector();
MFloatVector& ctex = block.inputValue(aGLPreviewTexture).asFloatVector();
// exploit maya's free openGL preview
if ( ctex != MFloatVector( -1.0, -1.0, -1.0 ) ) theColor = ctex;
else theColor = cColor;
MFloatVector resultColor( 0.0, 0.0, 0.0 );
MFloatVector resultTrans( cTrans );
// lambert calc -------------------
bool& ignoreLights = block.inputValue( aMayaIgnoreLights, &status ).asBool();
float& Ka = block.inputValue( aMayaKa, &status ).asFloat();
float& Kd = block.inputValue( aMayaKd, &status ).asFloat();
// get surface normal
MFloatVector& surfaceNormal = block.inputValue( aNormalCamera, &status ).asFloatVector();
CHECK_MSTATUS( status );
if ( ignoreLights ) {
MFloatVector cam( 0.0, 0.0, 1.0 );
float cosln = cam * surfaceNormal;
if ( cosln > 0.0f ) {
float diff = cosln * cosln * Kd + Ka;
resultColor = diff * theColor;
}
} else {
// Get light list
MArrayDataHandle lightData = block.inputArrayValue( aLightData, &status );
CHECK_MSTATUS( status );
int numLights = lightData.elementCount( &status );
CHECK_MSTATUS( status );
// Iterate through light list and get ambient/diffuse values
for( int count=1; count <= numLights; count++ )
{
// Get the current light out of the array
MDataHandle currentLight = lightData.inputValue( &status );
CHECK_MSTATUS( status );
// Get the intensity of that light
MFloatVector& lightIntensity = currentLight.child( aLightIntensity ).asFloatVector();
// Find ambient component
if ( currentLight.child( aLightAmbient ).asBool() ) {
resultColor += lightIntensity;
}
// Find diffuse component
if ( currentLight.child( aLightDiffuse ).asBool() ) {
MFloatVector& lightDirection = currentLight.child( aLightDirection ).asFloatVector();
float cosln = lightDirection * surfaceNormal;
if ( cosln > 0.0f ) resultColor += lightIntensity * cosln * Kd ;
}
// Advance to the next light.
if ( count < numLights ) {
status = lightData.next();
CHECK_MSTATUS( status );
}
}
resultColor[0] *= theColor[0];
resultColor[1] *= theColor[1];
resultColor[2] *= theColor[2];
}
resultTrans[0] = ( 1 - resultTrans[0] );
resultTrans[1] = ( 1 - resultTrans[1] );
resultTrans[2] = ( 1 - resultTrans[2] );
// set ouput color attribute
MDataHandle outColorHandle = block.outputValue( aOutColor );
MFloatVector& outColor = outColorHandle.asFloatVector();
outColor = resultColor;
outColorHandle.setClean();
MDataHandle outTransHandle = block.outputValue( aOutTransparency );
MFloatVector& outTrans = outTransHandle.asFloatVector();
outTrans = resultTrans;
outTransHandle.setClean();
} else return MS::kUnknownParameter;
return MS::kSuccess;
}
