//---------------------------------------------------
bool DagHelper::getPlugValue(const MObject& node, const String attributeName, MObject& value)
{
MStatus status;
MPlug plug = MFnDependencyNode(node).findPlug(attributeName.c_str(), &status);
if (!status) return false;
return getPlugValue(plug, value);
}
//---------------------------------------------------
void DagHelper::getPlugValue (
const MObject& node,
const String attributeName,
MStringArray& output,
MStatus* status )
{
MPlug plug = MFnDependencyNode ( node ).findPlug ( attributeName.c_str(), status );
getPlugValue ( plug, output, status );
}
MStatus simulateBoids::doIt( const MArgList& args )
{
// Description: implements the MEL boids command
// Arguments: args - the argument list that was passes to the command from MEL
MStatus status = MS::kSuccess;
/****************************************
* building thread/dll data structure *
****************************************/
InfoCache infoCache;
SimulationParameters simParams;
RulesParameters *applyingRules;
double progressBar=0;
double aov=pi/3;
int i,numberOfDesires=0;
// params retrievement
MSelectionList sel;
MObject node;
MFnDependencyNode nodeFn;
MFnTransform locatorFn;
MPlug plug;
// simulation params
int simulationLengthValue; // [int] in seconds
int framesPerSecondValue; // [int]
int startFrameValue; // [int]
int boidsNumberValue; // [int]
// export params
MString logFilePathValue; // [char *]
MString logFileNameValue; // [char *]
int logFileTypeValue; // 0 = nCache; 1 = log file; 2 = XML;
// locomotion params
int locomotionModeValue; // [int]
double maxSpeedValue; // [double]
double maxForceValue; // [double]
// double mass=1; // [double]
MTime currentTime, maxTime;
MPlug plugX, plugY, plugZ;
double tx, ty, tz;
int frameLength ;
Vector * leader = NULL;
MStatus leaderFound=MStatus::kFailure;
MGlobal::getActiveSelectionList(sel);
for ( MItSelectionList listIter(sel); !listIter.isDone(); listIter.next() )
{
listIter.getDependNode(node);
switch(node.apiType())
{
case MFn::kTransform:
// get locator transform to follow
leaderFound=locatorFn.setObject(node);
cout << locatorFn.name().asChar() << " is selected as locator" << endl;
break;
case MFn::kPluginDependNode:
nodeFn.setObject(node);
cout << nodeFn.name().asChar() << " is selected as brain" << endl;
break;
default:
break;
}
cout<< node.apiTypeStr()<<endl;
}
// rules params
setRuleVariables(alignment);
setRuleVariables(cohesion);
setRuleVariables(separation);
setRuleVariables(follow);
getPlugValue(simulationLength);
getPlugValue(framesPerSecond);
getPlugValue(startFrame);
getPlugValue(boidsNumber);
getPlugValue(logFileType);
getRulePlugValue(alignment);
getRulePlugValue(cohesion);
getRulePlugValue(separation);
getRulePlugValue(follow);
getPlugValue(locomotionMode);
getPlugValue(maxSpeed);
getPlugValue(maxForce);
getTypePlugValue(logFilePath);
getTypePlugValue(logFileName);
// counting active rules number
if(alignmentActiveValue)
numberOfDesires++;
if(cohesionActiveValue)
numberOfDesires++;
if(separationActiveValue)
numberOfDesires++;
if(followActiveValue)
numberOfDesires++;
currentTime = MTime((double)startFrameValue); // MAnimControl::minTime();
maxTime = MTime((double)(startFrameValue + (simulationLengthValue * framesPerSecondValue))); // MAnimControl::maxTime();
cout << "time unit enum (6 is 24 fps): " << currentTime.unit() << endl;
plugX = locatorFn.findPlug( MString( "translateX" ), &status );
plugY = locatorFn.findPlug( MString( "translateY" ), &status );
plugZ = locatorFn.findPlug( MString( "translateZ" ), &status );
frameLength = simulationLengthValue * framesPerSecondValue;
if(leaderFound==MS::kSuccess)
{
leader = new Vector[frameLength];
while ( currentTime < maxTime )
{
{
int index = (int)currentTime.value() - startFrameValue;
/*
MGlobal::viewFrame(currentTime);
pos = locatorFn.getTranslation(MSpace::kWorld);
cout << "pos: " << pos.x << " " << pos.y << " " << pos.z << endl;
*/
status = plugX.getValue( tx, MDGContext(currentTime) );
status = plugY.getValue( ty, MDGContext(currentTime) );
status = plugZ.getValue( tz, MDGContext(currentTime) );
leader[index].x = tx;
leader[index].y = ty;
leader[index].z = tz;
//cout << "pos at time " << currentTime.value() << " has x: " << tx << " y: " << ty << " z: " << tz << endl;
currentTime++;
}
}
}
simParams.fps=framesPerSecondValue;
simParams.lenght=simulationLengthValue;
simParams.numberOfBoids=boidsNumberValue;
simParams.maxAcceleration=maxForceValue;
simParams.maxVelocity=maxSpeedValue;
simParams.simplifiedLocomotion=TRUE;
applyingRules=new RulesParameters[numberOfDesires];
// cache settings
MString saveString;
saveString = logFilePathValue+"/"+logFileNameValue;
infoCache.fileName=new char[saveString.length()+1];
memcpy(infoCache.fileName,saveString.asChar(),sizeof(char)*(saveString.length()+1));
infoCache.cacheFormat=ONEFILE;
infoCache.fps=framesPerSecondValue;
infoCache.start=startFrameValue/framesPerSecondValue;
infoCache.end=simulationLengthValue+infoCache.start;
infoCache.loging=FALSE;
infoCache.option=POSITIONVELOCITY;
infoCache.particleSysName="BoidsNParticles";
infoCache.saveMethod=MAYANCACHE;
for(i=0;i<numberOfDesires;i++)
{
applyingRules[i].enabled=TRUE;
applyingRules[i].precedence=1;
applyingRules[i].aov=aov;
applyingRules[i].visibilityOption=FALSE;
}
if(cohesionActiveValue==0)
applyingRules[COHESIONRULE].enabled=FALSE;
else
{
applyingRules[COHESIONRULE].ruleName=COHESIONRULE;
applyingRules[COHESIONRULE].ruleFactor=cohesionFactorValue;
applyingRules[COHESIONRULE].ruleRadius=cohesionRadiusValue;
applyingRules[COHESIONRULE].ruleWeight=cohesionWeightValue;
}
if(separationActiveValue==0)
applyingRules[SEPARATIONRULE].enabled=FALSE;
else
{
applyingRules[SEPARATIONRULE].ruleName=SEPARATIONRULE;
applyingRules[SEPARATIONRULE].ruleFactor=separationFactorValue;
applyingRules[SEPARATIONRULE].ruleRadius=separationRadiusValue;
applyingRules[SEPARATIONRULE].ruleWeight=separationWeightValue;
}
if(alignmentActiveValue==0)
applyingRules[ALIGNMENTRULE].enabled=FALSE;
else
{
applyingRules[ALIGNMENTRULE].ruleName=ALIGNMENTRULE;
applyingRules[ALIGNMENTRULE].ruleFactor=alignmentFactorValue;
applyingRules[ALIGNMENTRULE].ruleRadius=alignmentRadiusValue;
applyingRules[ALIGNMENTRULE].ruleWeight=alignmentWeightValue;
}
if(followActiveValue==0)
applyingRules[FOLLOWRULE].enabled=FALSE;
else
{
applyingRules[FOLLOWRULE].ruleName=FOLLOWRULE;
applyingRules[FOLLOWRULE].ruleRadius=followRadiusValue;
applyingRules[FOLLOWRULE].ruleFactor=followFactorValue;
applyingRules[FOLLOWRULE].ruleWeight=followWeightValue;
}
// initializing simulation parameters
boidInit(numberOfDesires, applyingRules, simParams , infoCache, leader);
DLLData datadll;
// preparing threads pool
status = MThreadPool::init();
if (status==MStatus::kSuccess)
{
MThreadPool::newParallelRegion(ThreadsCreator, &datadll);
setResult( "Command executed!\n" );
CHECK_MSTATUS(MProgressWindow::endProgress());
MThreadPool::release();
}
switch(datadll.result)
{
case 0:
status=MS::kSuccess;
break;
default:
status=MS::kFailure;
}
MThreadPool::release();
return status;
}
/**
* Get the GLSL Codeblock for a plug
*/
ShadingNode::CodeBlock FlatShader::getCodeBlock( const std::string &plug_name )
{
// Build the GLSL code ...
CodeBlock code_block;
std::string variable_name;
MFnDependencyNode dn(_mayaShadingNode);
std::string maya_surface_shader_name = dn.name().asChar();
hygienizeName( maya_surface_shader_name );
// Check plug name and avoid duplicating code
if ( plug_name == "fragmentOutput" ||
plug_name == "outColor" ||
plug_name == "outTransparency" )
{
variable_name = "sn_flat_" + maya_surface_shader_name + "_output";
// Both color and transparency are stored in "color" variable.
// if it is already declared, we omit all the GLSL code
if ( !variableIsAvailable(variable_name) ) {
// Supported flat shader (SurfaceShader) input channels
// Color
Plug plug_color = getPlug("outColor");
// Transparency
Plug plug_transparency = getPlug("outTransparency");
code_block.declarations = plug_color.codeBlock.declarations +
plug_transparency.codeBlock.declarations;
code_block.functions = plug_color.codeBlock.functions +
plug_transparency.codeBlock.functions;
code_block.computeCode = plug_color.codeBlock.computeCode +
plug_transparency.codeBlock.computeCode +
GLSLUtils::backFaceCullingWithoutNormals(_shadingNetwork.getStateSet());
code_block.computeCode +=
" vec4 " + variable_name + " = vec4( " + getPlugValue(plug_color) + ", 1.0 - " + getPlugValue(plug_transparency) + " );\n";
_computedVariables.insert(variable_name);
}
// Access code
if ( plug_name == "fragmentOutput" ) { // special code for fragment output (RGBA)
code_block.accessCode = variable_name;
}
else if ( plug_name == "outColor" ) {
code_block.accessCode = variable_name + ".rgb";
}
else if ( plug_name == "outTransparency" ) {
code_block.accessCode = "(1.0 - " + variable_name + ".a)";
}
}
else {
std::cerr << "WARNING: Unsupported plug " << plug_name << " in Flat shader " << dn.name().asChar() << std::endl;
// throw exception ??? !!! FIXME!!!
}
return code_block;
}
/**
* Get the GLSL Codeblock for a plug
*/
ShadingNode::CodeBlock Bump2D::getCodeBlock( const std::string &plug_name )
{
CodeBlock code_block;
std::string variable_name;
MFnDependencyNode dn(_mayaShadingNode);
std::string maya_bump_name = dn.name().asChar();
hygienizeName( maya_bump_name );
// Check the plug name. Supported ones: outNormal
if ( plug_name == "outNormal" )
{
variable_name = "sn_bump2d_" + maya_bump_name + "_outNormal";
// If variable not available, we compute them
if ( ! variableIsAvailable(variable_name) ) {
if ( Config::instance()->getRunTimeBumpDepth() ) {
// Bump depth is applied at run time in the GLSL shader
// Bump value
Plug plug_bump_value = getPlug("bumpValue");
// Bump depth
Plug plug_bump_depth = getPlug("bumpDepth");
code_block.declarations = plug_bump_value.codeBlock.declarations
+ plug_bump_depth.codeBlock.declarations;
code_block.functions = plug_bump_value.codeBlock.functions
+ plug_bump_depth.codeBlock.functions;
std::string unperturbed = "sn_bump2d_" + maya_bump_name + "_unperturbed";
std::string delta = "sn_bump2d_" + maya_bump_name + "_delta";
code_block.computeCode = plug_bump_value.codeBlock.computeCode
+ plug_bump_depth.codeBlock.computeCode
+ " vec3 " + unperturbed + " = vec3(0.0, 0.0, 1.0);\n"
+ " vec3 " + delta + " = "
+ "normalize(" + getPlugValue(plug_bump_value) + " - 0.5) - " + unperturbed + ";\n"
+ " vec3 " + variable_name + " = " + unperturbed + " + " + delta + " * "
+ getPlugValue(plug_bump_depth) + ";\n";
}
else {
// Bump depth is not applied at run-time in the shader, because it
// is assumed to be applied off-line when generating the normal map file
// Bump value
Plug plug_bump_value = getPlug("bumpValue");
code_block.declarations = plug_bump_value.codeBlock.declarations;
code_block.functions = plug_bump_value.codeBlock.functions;
code_block.computeCode = plug_bump_value.codeBlock.computeCode
+ " vec3 " + variable_name + " = ( "
+ "normalize(" + getPlugValue(plug_bump_value) + " - 0.5)"
+ " );\n";
}
_computedVariables.insert(variable_name);
}
// Access code
code_block.accessCode = variable_name;
}
else {
std::cerr << "WARNING: Unsupported plug " << plug_name << " in Bump2D shading node " << dn.name().asChar() << std::endl;
// throw exception ??? !!! FIXME!!!
}
return code_block;
}