void cubeLocatorDrawOverride::draw (const MHWRender::MDrawContext &context, const MUserData *data) {
MPointArray vertices =cubeLocator::vertices () ;
// get cached data
float color [3] ={ 0.0f, 1.0f, 0.0f } ;
float multiplier =1.0f ;
const cubeLocatorData *cubeData =dynamic_cast<const cubeLocatorData *>(data) ;
if ( cubeData )
multiplier =cubeData->multiplier ;
// get state data
MStatus status ;
const MMatrix transform =context.getMatrix (MHWRender::MDrawContext::kWorldViewMtx, &status) ;
if ( status != MStatus::kSuccess )
return ;
const MMatrix projection =context.getMatrix (MHWRender::MDrawContext::kProjectionMtx, &status) ;
if ( status != MStatus::kSuccess )
return ;
const int displayStyle =context.getDisplayStyle () ;
// get renderer
MHWRender::MRenderer *theRenderer =MHWRender::MRenderer::theRenderer () ;
if ( !theRenderer )
return ;
// GL Draw
if ( theRenderer->drawAPIIsOpenGL () ) {
// set colour
glColor3fv (color) ;
// set world matrix
glMatrixMode (GL_MODELVIEW) ;
glPushMatrix () ;
glLoadMatrixd (transform.matrix [0]) ;
// set projection matrix
glMatrixMode (GL_PROJECTION) ;
glPushMatrix () ;
glLoadMatrixd (projection.matrix [0]) ;
if ( displayStyle & MHWRender::MDrawContext::kGouraudShaded ) {
// See myShadedDraw
glPushAttrib (GL_CURRENT_BIT) ;
glBegin (GL_QUADS) ;
for ( int i =0 ; i < vertices.length () - 3 ; i +=4 ) {
glVertex3f (vertices [i].x * multiplier, vertices [i].y * multiplier, vertices [i].z * multiplier) ;
glVertex3f (vertices [i + 1].x * multiplier, vertices [i + 1].y * multiplier, vertices [i + 1].z * multiplier) ;
glVertex3f (vertices [i + 2].x * multiplier, vertices [i + 2].y * multiplier, vertices [i + 2].z * multiplier) ;
glVertex3f (vertices [i + 3].x * multiplier, vertices [i + 3].y * multiplier, vertices [i + 3].z * multiplier) ;
}
glEnd () ;
glPopAttrib () ;
}
if ( displayStyle & MHWRender::MDrawContext::kWireFrame ) {
// See myWireFrameDraw
for ( int i =0 ; i < vertices.length () - 3 ; i +=4 ) {
glBegin (GL_LINE_LOOP) ;
glVertex3f (vertices [i].x * multiplier, vertices [i].y * multiplier, vertices [i].z * multiplier) ;
glVertex3f (vertices [i + 1].x * multiplier, vertices [i + 1].y * multiplier, vertices [i + 1].z * multiplier) ;
glVertex3f (vertices [i + 2].x * multiplier, vertices [i + 2].y * multiplier, vertices [i + 2].z * multiplier) ;
glVertex3f (vertices [i + 3].x * multiplier, vertices [i + 3].y * multiplier, vertices [i + 3].z * multiplier) ;
glEnd () ;
}
}
glPopMatrix () ;
glMatrixMode (GL_MODELVIEW) ;
glPopMatrix () ;
}
}
void AppleseedRenderer::createMesh(mtap_MayaObject *obj, asr::MeshObjectArray& meshArray, bool& isProxyArray)
{
// If the mesh has an attribute called "mtap_standin_path" and it contains a valid entry, then try to read the
// content from the path.
// The other way is to have a standInMeshNode which is connected to the inMesh of the mesh node.
// In this case, get the standin node, read the path of the binmesh file and load it.
MObject meshObject = obj->mobject;
MFnMeshData smoothMeshData;
MObject smoothMesh = this->checkSmoothMesh(meshObject, smoothMeshData);
//if( smoothMesh != MObject::kNullObj)
// meshObject = smoothMesh;
MStatus stat = MStatus::kSuccess;
MFnMesh meshFn(meshObject, &stat);
CHECK_MSTATUS(stat);
// check for standin_path attribute
MString proxyFile("");
if( getString(MString("mtap_standin_path"), meshFn, proxyFile))
{
// we need at least .obj == 4 chars - maybe replace by a useful file check
if( proxyFile.length() > 4 )
{
isProxyArray = true;
createMeshFromFile(obj, proxyFile, meshArray);
return;
}
}
// check for standInNode connection
MObjectArray connectedElements;
logger.debug(MString("findConnectedNodeTypes ") + meshFn.name());
findConnectedNodeTypes(MTAP_MESH_STANDIN_ID, meshObject, connectedElements, false);
if( connectedElements.length() > 0)
{
if( connectedElements.length() > 1)
{
logger.warning(MString("Found more than 1 standin elements:"));
for( uint i = 0; i < connectedElements.length(); i++)
{
logger.warning(MString("Standin element: ") + getObjectName(connectedElements[i]));
}
logger.warning(MString("Using element: ") + getObjectName(connectedElements[0]));
}
MFnDependencyNode depFn(connectedElements[0]);
if(getString(MString("binMeshFile"), depFn, proxyFile))
{
logger.debug(MString("Reading binarymesh from file: ") + proxyFile);
isProxyArray = true;
createMeshFromFile(obj, proxyFile, meshArray);
return;
}
}
isProxyArray = false;
// no standin --- we have a normal mesh here
MItMeshPolygon faceIt(meshObject, &stat);
CHECK_MSTATUS(stat);
MPointArray points;
meshFn.getPoints(points);
MFloatVectorArray normals;
meshFn.getNormals( normals, MSpace::kWorld );
MFloatArray uArray, vArray;
meshFn.getUVs(uArray, vArray);
logger.debug(MString("Translating mesh object ") + meshFn.name().asChar());
MString meshFullName = makeGoodString(meshFn.fullPathName());
// Create a new mesh object.
//asf::auto_release_ptr<asr::MeshObject> mesh = asr::MeshObjectFactory::create(meshFullName.asChar(), asr::ParamArray());
meshArray.push_back(asr::MeshObjectFactory::create(meshFullName.asChar(), asr::ParamArray()).release());
asr::MeshObject *mesh = meshArray[0];
// add vertices
// Vertices.
//object->push_vertex(GVector3(552.8f, 0.0f, 0.0f));
for( uint vtxId = 0; vtxId < points.length(); vtxId++)
{
asr::GVector3 vtx((float)points[vtxId].x, (float)points[vtxId].y, (float)points[vtxId].z);
mesh->push_vertex(vtx);
}
// add normals
// Vertex normals.
//object->push_vertex_normal(GVector3(0.0f, 1.0f, 0.0f));
for( uint nId = 0; nId < normals.length(); nId++)
{
asr::GVector3 vtx((float)normals[nId].x, (float)normals[nId].y, (float)normals[nId].z);
mesh->push_vertex_normal(vtx);
}
for( uint tId = 0; tId < uArray.length(); tId++)
{
asr::GVector2 vtx((float)uArray[tId], (float)vArray[tId]);
mesh->push_tex_coords(vtx);
}
MPointArray triPoints;
MIntArray triVtxIds;
MIntArray faceVtxIds;
MIntArray faceNormalIds;
mesh->reserve_material_slots(obj->shadingGroups.length());
for( uint sgId = 0; sgId < obj->shadingGroups.length(); sgId++)
{
MString slotName = MString("slot_") + sgId;
mesh->push_material_slot(slotName.asChar());
}
for(faceIt.reset(); !faceIt.isDone(); faceIt.next())
{
int faceId = faceIt.index();
int numTris;
faceIt.numTriangles(numTris);
faceIt.getVertices(faceVtxIds);
MIntArray faceUVIndices;
faceNormalIds.clear();
for( uint vtxId = 0; vtxId < faceVtxIds.length(); vtxId++)
{
faceNormalIds.append(faceIt.normalIndex(vtxId));
int uvIndex;
faceIt.getUVIndex(vtxId, uvIndex);
faceUVIndices.append(uvIndex);
}
int perFaceShadingGroup = 0;
if( obj->perFaceAssignments.length() > 0)
perFaceShadingGroup = obj->perFaceAssignments[faceId];
//logger.info(MString("Face ") + faceId + " will receive SG " + perFaceShadingGroup);
for( int triId = 0; triId < numTris; triId++)
{
int faceRelIds[3];
faceIt.getTriangle(triId, triPoints, triVtxIds);
for( uint triVtxId = 0; triVtxId < 3; triVtxId++)
{
for(uint faceVtxId = 0; faceVtxId < faceVtxIds.length(); faceVtxId++)
{
if( faceVtxIds[faceVtxId] == triVtxIds[triVtxId])
{
faceRelIds[triVtxId] = faceVtxId;
}
}
}
uint vtxId0 = faceVtxIds[faceRelIds[0]];
uint vtxId1 = faceVtxIds[faceRelIds[1]];
uint vtxId2 = faceVtxIds[faceRelIds[2]];
uint normalId0 = faceNormalIds[faceRelIds[0]];
uint normalId1 = faceNormalIds[faceRelIds[1]];
uint normalId2 = faceNormalIds[faceRelIds[2]];
uint uvId0 = faceUVIndices[faceRelIds[0]];
uint uvId1 = faceUVIndices[faceRelIds[1]];
uint uvId2 = faceUVIndices[faceRelIds[2]];
mesh->push_triangle(asr::Triangle(vtxId0, vtxId1, vtxId2, normalId0, normalId1, normalId2, uvId0, uvId1, uvId2, perFaceShadingGroup));
}
}
obj->perFaceAssignments.clear();
}
IECore::PrimitivePtr FromMayaCurveConverter::doPrimitiveConversion( MFnNurbsCurve &fnCurve ) const
{
// decide on the basis and periodicity
int mDegree = fnCurve.degree();
IECore::CubicBasisf basis = IECore::CubicBasisf::linear();
if( m_linearParameter->getTypedValue()==false && mDegree==3 )
{
basis = IECore::CubicBasisf::bSpline();
}
bool periodic = false;
if( fnCurve.form()==MFnNurbsCurve::kPeriodic )
{
periodic = true;
}
// get the points and convert them
MPointArray mPoints;
fnCurve.getCVs( mPoints, space() );
if( periodic )
{
// maya duplicates the first points at the end, whereas we just wrap around.
// remove the duplicates.
mPoints.setLength( mPoints.length() - mDegree );
}
bool duplicateEnds = false;
if( !periodic && mDegree==3 )
{
// there's an implicit duplication of the end points that we need to make explicit
duplicateEnds = true;
}
IECore::V3fVectorDataPtr pointsData = new IECore::V3fVectorData;
std::vector<Imath::V3f> &points = pointsData->writable();
std::vector<Imath::V3f>::iterator transformDst;
if( duplicateEnds )
{
points.resize( mPoints.length() + 4 );
transformDst = points.begin();
*transformDst++ = IECore::convert<Imath::V3f>( mPoints[0] );
*transformDst++ = IECore::convert<Imath::V3f>( mPoints[0] );
}
else
{
points.resize( mPoints.length() );
transformDst = points.begin();
}
std::transform( MArrayIter<MPointArray>::begin( mPoints ), MArrayIter<MPointArray>::end( mPoints ), transformDst, IECore::VecConvert<MPoint, V3f>() );
if( duplicateEnds )
{
points[points.size()-1] = IECore::convert<Imath::V3f>( mPoints[mPoints.length()-1] );
points[points.size()-2] = IECore::convert<Imath::V3f>( mPoints[mPoints.length()-1] );
}
// make and return the curve
IECore::IntVectorDataPtr vertsPerCurve = new IECore::IntVectorData;
vertsPerCurve->writable().push_back( points.size() );
return new IECore::CurvesPrimitive( vertsPerCurve, basis, periodic, pointsData );
}
void extractPolygons(Model* model) {
MStatus stat;
MItDag dagIter(MItDag::kBreadthFirst, MFn::kInvalid);
for (; !dagIter.isDone(); dagIter.next()) {
MDagPath dagPath;
stat = dagIter.getPath(dagPath);
if (!stat) { continue; };
MFnDagNode dagNode(dagPath, &stat);
if (dagNode.isIntermediateObject()) continue;
if (!dagPath.hasFn( MFn::kMesh )) continue;
if (dagPath.hasFn( MFn::kTransform)) continue;
if (!dagPath.isVisible()) continue;
MFnMesh fnMesh(dagPath);
MStringArray UVSets;
stat = fnMesh.getUVSetNames( UVSets );
// Get all UVs for the first UV set.
MFloatArray u, v;
fnMesh.getUVs(u, v, &UVSets[0]);
MPointArray vertexList;
fnMesh.getPoints(vertexList, MSpace::kObject);
MFloatVectorArray meshNormals;
fnMesh.getNormals(meshNormals);
unsigned instanceNumber = dagPath.instanceNumber();
MObjectArray sets;
MObjectArray comps;
fnMesh.getConnectedSetsAndMembers( instanceNumber, sets, comps, true );
//printMaterials(dagPath);
unsigned int comlength = comps.length();
for (unsigned int compi = 0; compi < comlength; compi++) {
SubMesh submesh;
MItMeshPolygon itPolygon(dagPath, comps[compi]);
unsigned int polyCount = 0;
for (; !itPolygon.isDone(); itPolygon.next()) {
polyCount++;
MIntArray polygonVertices;
itPolygon.getVertices(polygonVertices);
int count;
itPolygon.numTriangles(count);
for (; count > -1; count--) {
MPointArray nonTweaked;
MIntArray triangleVertices;
MIntArray localIndex;
MStatus status;
status = itPolygon.getTriangle(count, nonTweaked, triangleVertices, MSpace::kObject);
if (status == MS::kSuccess) {
VertexDefinition vertex1;
VertexDefinition vertex2;
VertexDefinition vertex3;
{ // vertices
int vertexCount = vertexList.length();
{
int vertexIndex0 = triangleVertices[0];
MPoint point0 = vertexList[vertexIndex0];
vertex1.vertex.x = (float)point0.x;
vertex1.vertex.y = (float)point0.y;
vertex1.vertex.z = (float)point0.z;
}
{
int vertexIndex0 = triangleVertices[1];
MPoint point0 = vertexList[vertexIndex0];
vertex2.vertex.x = (float)point0.x;
vertex2.vertex.y = (float)point0.y;
vertex2.vertex.z = (float)point0.z;
}
{
int vertexIndex0 = triangleVertices[2];
MPoint point0 = vertexList[vertexIndex0];
vertex3.vertex.x = (float)point0.x;
vertex3.vertex.y = (float)point0.y;
vertex3.vertex.z = (float)point0.z;
}
}
{ // normals
// Get face-relative vertex indices for this triangle
localIndex = GetLocalIndex(polygonVertices, triangleVertices);
{
int index0 = itPolygon.normalIndex(localIndex[0]);
MPoint point0 = meshNormals[index0];
vertex1.normal.x = (float)point0.x;
vertex1.normal.y = (float)point0.y;
vertex1.normal.z = (float)point0.z;
}
{
int index0 = itPolygon.normalIndex(localIndex[1]);
MPoint point0 = meshNormals[index0];
vertex2.normal.x = (float)point0.x;
vertex2.normal.y = (float)point0.y;
vertex2.normal.z = (float)point0.z;
}
{
int index0 = itPolygon.normalIndex(localIndex[2]);
MPoint point0 = meshNormals[index0];
vertex3.normal.x = (float)point0.x;
vertex3.normal.y = (float)point0.y;
vertex3.normal.z = (float)point0.z;
}
}
{ // uvs
int uvID[3];
MStatus uvFetchStatus;
for (unsigned int vtxInPolygon = 0; vtxInPolygon < 3; vtxInPolygon++) {
uvFetchStatus = itPolygon.getUVIndex(localIndex[vtxInPolygon], uvID[vtxInPolygon]);
}
if (uvFetchStatus == MStatus::kSuccess) {
{
int index0 = uvID[0];
float uvu = u[index0];
float uvv = v[index0];
vertex1.uv.x = uvu;
vertex1.uv.y = 1.0f - uvv;
}
{
int index0 = uvID[1];
float uvu = u[index0];
float uvv = v[index0];
vertex2.uv.x = uvu;
vertex2.uv.y = 1.0f - uvv;
}
{
int index0 = uvID[2];
float uvu = u[index0];
float uvv = v[index0];
vertex3.uv.x = uvu;
vertex3.uv.y = 1.0f - uvv; // directx
}
}
}
submesh.addVertex(vertex1);
submesh.addVertex(vertex2);
submesh.addVertex(vertex3);
}
}
}
{
Material material;
{
MObjectArray shaders;
MIntArray indices;
fnMesh.getConnectedShaders(0, shaders, indices);
unsigned int shaderCount = shaders.length();
MPlugArray connections;
MFnDependencyNode shaderGroup(shaders[compi]);
MPlug shaderPlug = shaderGroup.findPlug("surfaceShader");
shaderPlug.connectedTo(connections, true, false);
for(unsigned int u = 0; u < connections.length(); u++) {
if(connections[u].node().hasFn(MFn::kLambert)) {
MFnLambertShader lambertShader(connections[u].node());
MPlugArray plugs;
lambertShader.findPlug("color").connectedTo(plugs, true, false);
for (unsigned int p = 0; p < plugs.length(); p++) {
MPlug object = plugs[p];
if (!object.isNull()) {
MObject node = object.node();
if (node.hasFn(MFn::kFileTexture)) {
MFnDependencyNode* diffuseMapNode = new MFnDependencyNode(node);
MPlug filenamePlug = diffuseMapNode->findPlug ("fileTextureName");
MString mayaFileName;
filenamePlug.getValue (mayaFileName);
std::string diffuseMapFileName = mayaFileName.asChar();
std::string diffuseMapAssetPath = extractAssetPath(diffuseMapFileName);
material.addTexture("ColorMap", diffuseMapAssetPath);
}
}
}
MColor color = lambertShader.color();
MString materialNameRaw = lambertShader.name();
std::string materialName = materialNameRaw.asChar();
material.setName(materialName);
Vector4MaterialParameter* diffuseColorParameter = new Vector4MaterialParameter("DiffuseColor");
diffuseColorParameter->value.x = color.r;
diffuseColorParameter->value.y = color.g;
diffuseColorParameter->value.z = color.b;
diffuseColorParameter->value.w = color.a;
material.addParameter(diffuseColorParameter);
}
}
}
{
if (material.hasTextures()) {
material.setEffect("shaders/deferred_render_colormap_normal_depth.cg");
}
else {
material.setEffect("shaders/deferred_render_color_normal_depth.cg");
}
}
{
FloatMaterialParameter* specularPowerParameter = new FloatMaterialParameter("SpecularPower");
specularPowerParameter->value = 1.0;
material.addParameter(specularPowerParameter);
}
{
FloatMaterialParameter* specularIntensityParameter = new FloatMaterialParameter("SpecularIntensity");
specularIntensityParameter->value = 1.0f;
material.addParameter(specularIntensityParameter);
}
{
FloatMaterialParameter* diffusePowerParameter = new FloatMaterialParameter("DiffusePower");
diffusePowerParameter->value = 1.0f;
material.addParameter(diffusePowerParameter);
}
submesh.setMaterial(material);
}
model->addSubMesh(submesh);
}
}
}
MStatus splatDeformer::compute(const MPlug& plug, MDataBlock& data)
{
// do this if we are using an OpenMP implementation that is not the same as Maya's.
// Even if it is the same, it does no harm to make this call.
MThreadUtils::syncNumOpenMPThreads();
MStatus status = MStatus::kUnknownParameter;
if (plug.attribute() != outputGeom) {
return status;
}
unsigned int index = plug.logicalIndex();
MObject thisNode = this->thisMObject();
// get input value
MPlug inPlug(thisNode,input);
inPlug.selectAncestorLogicalIndex(index,input);
MDataHandle hInput = data.inputValue(inPlug, &status);
MCheckStatus(status, "ERROR getting input mesh\n");
// get the input geometry
MDataHandle inputData = hInput.child(inputGeom);
if (inputData.type() != MFnData::kMesh) {
printf("Incorrect input geometry type\n");
return MStatus::kFailure;
}
// get the input groupId - ignored for now...
MDataHandle hGroup = inputData.child(groupId);
unsigned int groupId = hGroup.asLong();
// get deforming mesh
MDataHandle deformData = data.inputValue(deformingMesh, &status);
MCheckStatus(status, "ERROR getting deforming mesh\n");
if (deformData.type() != MFnData::kMesh) {
printf("Incorrect deformer geometry type %d\n", deformData.type());
return MStatus::kFailure;
}
MObject dSurf = deformData.asMeshTransformed();
MFnMesh fnDeformingMesh;
fnDeformingMesh.setObject( dSurf ) ;
MDataHandle outputData = data.outputValue(plug);
outputData.copy(inputData);
if (outputData.type() != MFnData::kMesh) {
printf("Incorrect output mesh type\n");
return MStatus::kFailure;
}
MItGeometry iter(outputData, groupId, false);
// create fast intersector structure
MMeshIntersector intersector;
intersector.create(dSurf);
// get all points at once. Faster to query, and also better for
// threading than using iterator
MPointArray verts;
iter.allPositions(verts);
int nPoints = verts.length();
// use bool variable as lightweight object for failure check in loop below
bool failed = false;
MTimer timer; timer.beginTimer();
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(int i=0; i<nPoints; i++) {
// Cannot break out of an OpenMP loop, so if one of the
// intersections failed, skip the rest
if(failed) continue;
// mesh point object must be in loop-local scope to avoid race conditions
MPointOnMesh meshPoint;
// Do intersection. Need to use per-thread status value as
// MStatus has internal state and may trigger race conditions
// if set from multiple threads. Probably benign in this case,
// but worth being careful.
MStatus localStatus = intersector.getClosestPoint(verts[i], meshPoint);
if(localStatus != MStatus::kSuccess) {
// NOTE - we cannot break out of an OpenMP region, so set
// bad status and skip remaining iterations
failed = true;
continue;
}
// default OpenMP scheduling breaks traversal into large
// chunks, so low risk of false sharing here in array write.
verts[i] = meshPoint.getPoint();
}
timer.endTimer(); printf("Runtime for threaded loop %f\n", timer.elapsedTime());
// write values back onto output using fast set method on iterator
iter.setAllPositions(verts);
if(failed) {
printf("Closest point failed\n");
return MStatus::kFailure;
}
return status;
}
MStatus boingRbCmd::redoIt()
{
if (argParser->isFlagSet("help") || argParser->isFlagSet("h"))
{
MString helpMsg = "boingRB - command : Boing - bullet plugin by Risto Puukko\n";
helpMsg += "---------------------------------------------------------\n";
helpMsg += "boingRB [flag] [args] \n";
helpMsg += "\n";
helpMsg += "flags :\n";
helpMsg += " -getAttr [name.attr]\n";
helpMsg += " example : boingRb -getAttr (\"boingRb1.velocity\");\n" ;
helpMsg += "\n";
helpMsg += " -getAttr [*.attr]\n";
helpMsg += " example : boingRb -getAttr (\"*.name\");\n" ;
helpMsg += "\n";
helpMsg += " -setAttr [name.attr] -value [float float float ]\n";
helpMsg += " example : boingRb -setAttr (\"boingRb1.velocity\") -value 0 4 3 ;\n" ;
helpMsg += "\n";
helpMsg += " -addAttr [name.attr] -type [int/double/string/vector]\n";
helpMsg += " example : boingRb -addAttr \"sampleRb.IntAttribute\" -type \"int\";\n" ;
helpMsg += " example : boingRb -addAttr \"sampleRb.VectorAttribute\" -type \"vector\";\n" ;
helpMsg += "\n";
helpMsg += " -create [ ( \"name=string;geo=string;velocity/vel=float,float,float;position/pos=float,float,float\" )]\n";
helpMsg += " example : boingRb -create (\"name=sampleRb;geo=pCubeShape1;pos=0,4,0\");\n";
helpMsg += "\n";
helpMsg += " -exists [name]\n";
helpMsg += " example : boingRb -exists \"sampleRb\";\n" ;
helpMsg += "\n";
helpMsg += " -delete [name]\n";
helpMsg += " example : boingRb -delete \"sampleRb\";\n";
helpMsg += "\n";
helpMsg += "---------------------------------------------------------\n";
MGlobal::displayInfo(helpMsg);
return MS::kSuccess;
}
isSetAttr = argParser->isFlagSet("-setAttr");
isGetAttr = argParser->isFlagSet("-getAttr");
isAddAttr = argParser->isFlagSet("-addAttr");
isType = argParser->isFlagSet("-type");
isExists = argParser->isFlagSet("-exists");
isAttributeExist = argParser->isFlagSet("-attributeExist");
isCreate = argParser->isFlagSet("-create");
isDelete = argParser->isFlagSet("-delete");
isValue = argParser->isFlagSet("-value");
//std::cout<<"argsList : "<<*argsList<<std::endl;
//unsigned i;
//MStatus stat;
//MVector res;
// Parse the arguments.
/*
for (i = 0; i <argsList->length (); i++) {
//MString arg = argsList->asString(i, &stat);
//if (MS::kSuccess == stat) std::cout<<"arg["<<i<<"] : "<<arg<<std::endl;
if (
MString ("-setAttr") == argsList->asString(i, &stat) &&
MString ("-value") == argsList->asString(i+2, &stat) &&
MS::kSuccess == stat
) {
for (unsigned j=3; j!=6; ++j)
res[j-3 ] = argsList->asDouble (j, &stat);
}
}
std::cout<<"res : "<<res<<std::endl;
*/
if (isSetAttr && isValue) {
MString sAttr;
argParser->getFlagArgument("setAttr", 0, sAttr);
//std::cout<<sAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(sAttr, ".");
MString rbName = jobArgsArray[0];
MString attr = checkAttribute(jobArgsArray[1]);
//std::cout<<"attr : "<<attr<<std::endl;
if ( attr == "custom" ) {
MString customAttr = jobArgsArray[1];
//char * custAttr = (char*)customAttr.asChar();
//std::cout<<"customAttr : "<<customAttr<<std::endl;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(rbName);
//std::cout<<"data : "<<data<<std::endl;
if (!data) return MS::kFailure;
//std::cout<<"data->m_int_data : "<<data->m_int_data<<std::endl;
MString type = b_solv->getAttrType(data, customAttr);
//std::cout<<"attrype : "<<type<<std::endl;
if (type == "string") {
//std::cout<<"saving custom string : "<<customAttr<<std::endl;
MString value;
value = argsList->asString(3);
data->m_string_data.append(value);
b_solv->set_custom_data_string(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//char * chars = (char *)value.asChar();
//void * char_ptr = (void *)chars;
//b_solv->set_custom_data(customAttr, char_ptr);
} else if (type == "double") {
//std::cout<<"saving custom double : "<<customAttr<<std::endl;
double value;
value = argsList->asDouble(3);
data->m_double_data.append(value);
b_solv->set_custom_data_double(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//void *val = &value;
//b_solv->set_custom_data(customAttr, val);
} else if (type == "int") {
//std::cout<<"saving custom int : "<<customAttr<<std::endl;
int value;
value = argsList->asInt(3);
//std::cout<<"argsList->get(3, value) -> value : "<<value<<std::endl;
data->m_int_data.append(value);
b_solv->set_custom_data_int(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//std::cout<<"data->m_int_data : "<<data->m_int_data<<std::endl;
//void *val = &value;
//b_solv->set_custom_data(customAttr, val);
//std::cout<<"b_solv->set_custom_data,static_cast<void*>(&value)) DONE!!!"<<std::endl;
} else if (type == "vector") {
//std::cout<<"saving custom vector : "<<customAttr<<std::endl;
MVector value = MVector();
value.x = argsList->asDouble(3);
value.y = argsList->asDouble(4);
value.z = argsList->asDouble(5);
data->m_vector_data.append(value);
b_solv->set_custom_data_vector(data, customAttr, value);
//data->m_attr_type.append(customAttr);
//MVector *MVecPtr = &value;
//void * vec_ptr = static_cast<void*const>(MVecPtr);
//b_solv->set_custom_data(customAttr, vec_ptr);
}
} else {
if (attr == "velocity" ||
attr == "position" ||
attr == "angularVelocity")
{
MVector value;
value.x = argsList->asDouble(3);
value.y = argsList->asDouble(4);
value.z = argsList->asDouble(5);
//std::cout<<"vector argument : "<<value<<std::endl;
setBulletVectorAttribute(rbName, attr, value);
}
}
//cout<<value<<endl;
setResult(MS::kSuccess);
} else if ( isAttributeExist ) {
MString exAttr;
bool result = false;
argParser->getFlagArgument("attributeExist", 0, exAttr);
//std::cout<<"exAttr : "<<exAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(exAttr, ".");
MString rbname = jobArgsArray[0];
//std::cout<<"rbname : "<<rbname<<std::endl;
MString attrToQuery = jobArgsArray[1];
//std::cout<<"attrToQuery : "<<attrToQuery<<std::endl;
MString attr = checkAttribute(attrToQuery);
//std::cout<<"attr : "<<attr<<std::endl;
if ( attr == "custom" ){ // here we check if user attribute by the name attrToQuery exists
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
//char * queryAttr = (char*)attrToQuery.asChar();
MString attrResult = b_solv->getAttrType(b_solv->getdata(rbname), attrToQuery);
if (attrResult != "")
//if (b_solv->attribute_exists(attrToQuery))
result = true;
//std::cout<<result<<std::endl;;
setResult(result);
}
} else if ( isAddAttr && isType ) {
MString aAttr;
argParser->getFlagArgument("addAttr", 0, aAttr);
//std::cout<<"aAttr : "<<aAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(aAttr, ".");
//std::cout<<"jobArgsArray : "<<jobArgsArray<<std::endl;
MString rbname = jobArgsArray[0];
MString attrAdded = jobArgsArray[1];
//char *added = (char *)attrAdded.asChar();
MString attrType;
argParser->getFlagArgument("-type", 0, attrType);
//char *type = (char *)attrType.asChar();
//std::cout<<"attrType : "<<attrType<<std::endl;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
data->m_attr_name.append(attrAdded);
data->m_attr_type.append(attrType);
b_solv->saveAttrType(data, attrAdded, attrType);
//std::cout<<"attr "<<aAttr<<" added"<<std::endl;
//std::cout<<"data->m_attr_type : "<<data->m_attr_type<<std::endl;
//std::cout<<"data->m_attr_name : "<<data->m_attr_name<<std::endl;
} else if ( isGetAttr) {
MString gAttr;
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
argParser->getFlagArgument("getAttr", 0, gAttr);
//std::cout<<gAttr<<std::endl;
MStringArray jobArgsArray = parseArguments(gAttr, ".");
MString rbname = jobArgsArray[0];
//std::cout<<"name : "<<rbname<<std::endl;
if ( rbname == "" ) {
MString errorMsg = "ERROR ! boing -getAttr must provide a rigid body name!";
displayWarning(errorMsg, true);
return MS::kFailure;
}
MString attr = checkAttribute(jobArgsArray[1]);
//std::cout<<"attr = "<<attr<<std::endl;
if ( attr=="velocity" || attr=="position" || attr=="angularVelocity" ) {
//MVector result =
MDoubleArray dResult = getBulletVectorAttribute(rbname, attr);
setResult(dResult);
} else if (attr == "contactPositions") {
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
MDoubleArray d_points = MDoubleArray();
if ( data->m_contact_count > 0 ) {
MPointArray points = data->m_contact_positions;
for (int i=0; i<points.length();i++) {
d_points.append(points[i].x);
d_points.append(points[i].y);
d_points.append(points[i].z);
}
}
setResult(d_points);
} else if (attr == "contactGeos") {
MStringArray contact_objects = MStringArray();
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
if ( data->m_contact_count > 0 ) {
MStringArray contact_objects = data->m_contact_objects;
}
setResult(contact_objects);
} else if (attr == "contactCount") {
bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
int contact_count = data->m_contact_count;
setResult(contact_count);
} else if (attr == "name") {
MStringArray result;
MStringArray names = b_solv->get_all_keys();
//std::cout<<"names : "<<names<<std::endl;
//std::cout<<"b_solv->getdatalength() : "<<b_solv->getdatalength()<<std::endl;
for(int i=0; i < names.length(); i++) {
bSolverNode::m_custom_data *data = b_solv->getdata(names[i]);
if ( NULL != data) {
//std::cout<<"data->name : "<<data->name<<std::endl;
//std::cout<<"data->m_initial_position: "<<data->m_initial_position<<std::endl;
result.append(data->name);
}
}
setResult(result);
} else if ( attr == "" ) {
MString errorMsg = "ERROR ! boing -getAttr must provide an attribute name to query!";
displayWarning(errorMsg, true);
return MS::kFailure;
} else if ( attr == "custom" ){ // here we handle user attributes
MString customAttr = jobArgsArray[1];
//char * custAttr = (char*)customAttr.asChar();
//std::cout<<"customAttr : "<<customAttr<<std::endl;
MString type = b_solv->getAttrType(b_solv->getdata(rbname), customAttr);
//bSolverNode::m_custom_data *data = b_solv->getdata(rbname);
std::cout<<" type : "<<type<<std::endl;
if (type == "string") {
//char * result = static_cast<char*>(b_solv->get_custom_data(customAttr));
MString result = b_solv->get_custom_data_string(b_solv->getdata(rbname), customAttr);
if (result != NULL) {
//std::cout<<"result : "<<result<<std::endl;
MString value(result);
setResult(value);
} else {
displayError(MString("Error getting b_solv->get_custom_data_string(\"" + customAttr + "\")"));
}
} else if (type == "double") {
//double *value = static_cast<double*>(b_solv->get_custom_data(customAttr));
double value = b_solv->get_custom_data_double(b_solv->getdata(rbname), customAttr);
setResult(value);
} else if (type == "int") {
//int *value = static_cast<int*>(b_solv->get_custom_data(customAttr));
int value = b_solv->get_custom_data_int(b_solv->getdata(rbname), customAttr);
setResult(value);
} else if (type == "vector") {
//void * result = b_solv->get_custom_data(customAttr);
//MVector *vec_res = (MVector*)result;
MVector result = b_solv->get_custom_data_vector(b_solv->getdata(rbname), customAttr);
MDoubleArray value;
value.append(result.x);
value.append(result.y);
value.append(result.z);
setResult(value);
}
}
} else if ( isCreate ) {
MString aArgument;
argParser->getFlagArgument("-create", 0, aArgument);
MStringArray createArgs = parseArguments(aArgument,";");
int size = createArgs.length();
MString inputShape;
MString rbname = "dummyRb";
MVector av;
MVector vel;
MVector pos;
MVector rot;
for (int i=0; i!=size; ++i) {
MStringArray singleArg = parseArguments(createArgs[i],"=");
//std::cout<<"singleArg : "<<singleArg<<std::endl;
if (singleArg[0] == "name") {
rbname = singleArg[1];
} else if (singleArg[0] == "geo") {
//geo
inputShape = singleArg[1];
//std::cout<<"geo = "<<inputShape<<std::endl;
} else if (singleArg[0] == "vel") {
//initialvelocity
MStringArray velArray = parseArguments(singleArg[1], ",");
vel = MVector(velArray[0].asDouble(),
velArray[1].asDouble(),
velArray[2].asDouble()
);
//std::cout<<"velocity = "<<vel<<std::endl;
} else if (singleArg[0] == "pos") {
//initialposition
MStringArray posArray = parseArguments(singleArg[1], ",");
pos = MVector(posArray[0].asDouble(),
posArray[1].asDouble(),
posArray[2].asDouble()
);
//std::cout<<"position = "<<pos<<std::endl;
} else if (singleArg[0] == "rot") {
//initialrotation
MStringArray rotArray = parseArguments(singleArg[1], ",");
rot = MVector(rotArray[0].asDouble(),
rotArray[1].asDouble(),
rotArray[2].asDouble()
);
//std::cout<<"rotation = "<<rot<<std::endl;
} else if (singleArg[0] == "av") {
//initialAngularVelocity
MStringArray avArray = parseArguments(singleArg[1], ",");
av = MVector(avArray[0].asDouble(),
avArray[1].asDouble(),
avArray[2].asDouble()
);
//std::cout<<"initialAngularVelocity = "<<av<<std::endl;
} else {
std::cout<<"Unrecognized parameter : "<<singleArg[0]<<std::endl;
}
}
// create boing node
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
MObject node = nameToNode(inputShape);
float mass = 1.0f;
MString tname = "boing";
MStatus stat = b_solv->createNode(node, rbname, tname, pos, vel, rot, av, mass);
if (MS::kSuccess == stat) {
setResult(rbname);
} else {
MGlobal::displayError(MString("Something went wrong when trying to create rigidbody : " + rbname + " ."));
}
} else if ( isDelete ) {
MString aArgument;
argParser->getFlagArgument("-delete", 0, aArgument);
//std::cout<<"delete aArgument "<<aArgument<<std::endl;
if (aArgument != "") {
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
b_solv->deletedata(aArgument);
MStatus stat = b_solv->delete_key(aArgument, -1);
if (stat != MS::kSuccess) {
std::cerr<<"error occurred deleting "<<aArgument<<" ."<<std::endl;
setResult(1);
}
}
} else if ( isExists ) {
MString exArg;
argParser->getFlagArgument("-exists", 0, exArg);
//std::cout<<"exArg : "<<exArg<<std::endl;
if (exArg != "") {
shared_ptr<bSolverNode> b_solv = bSolverNode::get_bsolver_node();
bSolverNode::m_custom_data *data = b_solv->getdata(exArg);
int result = false;
if ( NULL != data ) {
//setResult ( data->name );
result = true;
}
setResult(result);
}
}
return MS::kSuccess;
}
MStatus probeDeformerARAPNode::deform( MDataBlock& data, MItGeometry& itGeo, const MMatrix &localToWorldMatrix, unsigned int mIndex )
{
MObject thisNode = thisMObject();
MStatus status;
MThreadUtils::syncNumOpenMPThreads(); // for OpenMP
bool worldMode = data.inputValue( aWorldMode ).asBool();
bool areaWeighted = data.inputValue( aAreaWeighted ).asBool();
short stiffnessMode = data.inputValue( aStiffness ).asShort();
short blendMode = data.inputValue( aBlendMode ).asShort();
short tetMode = data.inputValue( aTetMode ).asShort();
short numIter = data.inputValue( aIteration ).asShort();
short constraintMode = data.inputValue( aConstraintMode ).asShort();
short visualisationMode = data.inputValue( aVisualisationMode ).asShort();
mesh.transWeight = data.inputValue( aTransWeight ).asDouble();
double constraintWeight = data.inputValue( aConstraintWeight ).asDouble();
double normExponent = data.inputValue( aNormExponent ).asDouble();
double visualisationMultiplier = data.inputValue(aVisualisationMultiplier).asDouble();
MArrayDataHandle hMatrixArray = data.inputArrayValue(aMatrix);
MArrayDataHandle hInitMatrixArray = data.inputArrayValue(aInitMatrix);
// check connection
if(hMatrixArray.elementCount() > hInitMatrixArray.elementCount() || hMatrixArray.elementCount() == 0 || blendMode == BM_OFF){
return MS::kSuccess;
}else if(hMatrixArray.elementCount() < hInitMatrixArray.elementCount()){
std::set<int> indices;
for(int i=0;i<hInitMatrixArray.elementCount();i++){
hInitMatrixArray.jumpToArrayElement(i);
indices.insert(hInitMatrixArray.elementIndex());
}
for(int i=0;i<hMatrixArray.elementCount();i++){
hMatrixArray.jumpToArrayElement(i);
indices.erase(hMatrixArray.elementIndex());
}
deleteAttr(data, aInitMatrix, indices);
deleteAttr(data, aProbeConstraintRadius, indices);
deleteAttr(data, aProbeWeight, indices);
}
bool isNumProbeChanged = (numPrb != hMatrixArray.elementCount());
numPrb = hMatrixArray.elementCount();
B.setNum(numPrb);
// read matrices from probes
std::vector<Matrix4d> initMatrix(numPrb), matrix(numPrb);
readMatrixArray(hInitMatrixArray, initMatrix);
readMatrixArray(hMatrixArray, matrix);
// read vertex positions
MPointArray Mpts;
itGeo.allPositions(Mpts);
int numPts = Mpts.length();
// compute distance
if(!data.isClean(aARAP) || !data.isClean(aComputeWeight) || isNumProbeChanged){
// load points list
if(worldMode){
for(int j=0; j<numPts; j++ )
Mpts[j] *= localToWorldMatrix;
}
pts.resize(numPts);
for(int i=0;i<numPts;i++){
pts[i] << Mpts[i].x, Mpts[i].y, Mpts[i].z;
}
// make tetrahedral structure
getMeshData(data, input, inputGeom, mIndex, tetMode, pts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix, mesh.tetWeight);
mesh.dim = removeDegenerate(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix);
makeTetMatrix(tetMode, pts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix, mesh.tetWeight);
makeTetCenterList(tetMode, pts, mesh.tetList, tetCenter);
mesh.numTet = (int)mesh.tetList.size()/4;
mesh.computeTetMatrixInverse();
// initial probe position
for(int i=0;i<numPrb;i++){
B.centre[i] = transPart(initMatrix[i]);
}
// compute distance between probe and tetrahedra
D.setNum(numPrb, numPts, mesh.numTet);
D.computeDistTet(tetCenter, B.centre);
D.findClosestTet();
D.computeDistPts(pts, B.centre);
D.findClosestPts();
if(!areaWeighted){
mesh.tetWeight.clear();
mesh.tetWeight.resize(mesh.numTet,1.0);
}
}
// (re)compute ARAP
if(!data.isClean(aARAP) || isNumProbeChanged){
// load painted weights
if(stiffnessMode == SM_PAINT) {
VectorXd ptsWeight(numPts);
for (int i=0; !itGeo.isDone(); itGeo.next()){
double w=weightValue(data, mIndex, itGeo.index());
ptsWeight[i++] = (w>EPSILON) ? w : EPSILON;
}
makeTetWeightList(tetMode, mesh.tetList, faceList, edgeList, vertexList, ptsWeight, mesh.tetWeight);
}else if(stiffnessMode == SM_LEARN) {
std::vector<double> tetEnergy(mesh.numTet,0);
MArrayDataHandle hSupervisedMesh = data.inputArrayValue(aSupervisedMesh);
int numSupervisedMesh = hSupervisedMesh.elementCount();
for(int j=0;j<numSupervisedMesh;j++){
hSupervisedMesh.jumpToElement(j);
MFnMesh ex_mesh(hSupervisedMesh.inputValue().asMesh());
MPointArray Mspts;
ex_mesh.getPoints( Mspts );
if(numPts != Mspts.length()){
MGlobal::displayInfo("incompatible mesh");
return MS::kFailure;
}
std::vector<Vector3d> spts(numPts);
for(int i=0;i<numPts;i++){
spts[i] << Mspts[i].x, Mspts[i].y, Mspts[i].z;
}
std::vector<double> dummy_weight;
makeTetMatrix(tetMode, spts, mesh.tetList, faceList, edgeList, vertexList, Q, dummy_weight);
Matrix3d S,R;
for(int i=0;i<mesh.numTet;i++) {
polarHigham((mesh.tetMatrixInverse[i]*Q[i]).block(0,0,3,3), S, R);
tetEnergy[i] += (S-Matrix3d::Identity()).squaredNorm();
}
}
// compute weight (stiffness)
double max_energy = *std::max_element(tetEnergy.begin(), tetEnergy.end());
for(int i=0;i<mesh.numTet;i++) {
double w = 1.0 - tetEnergy[i]/(max_energy+EPSILON);
mesh.tetWeight[i] *= w*w;
}
}
// find constraint points
constraint.resize(3*numPrb);
for(int i=0;i<numPrb;i++){
constraint[3*i] = T(i,mesh.tetList[4*D.closestTet[i]],constraintWeight);
constraint[3*i+1] = T(i,mesh.tetList[4*D.closestTet[i]+1],constraintWeight);
constraint[3*i+2] = T(i,mesh.tetList[4*D.closestTet[i]+2],constraintWeight);
}
if( constraintMode == CONSTRAINT_NEIGHBOUR ){
std::vector<double> probeConstraintRadius(numPrb);
MArrayDataHandle handle = data.inputArrayValue(aProbeConstraintRadius);
if(handle.elementCount() != numPrb){
MGlobal::displayInfo("# of Probes and probeConstraintRadius are different");
return MS::kFailure;
}
for(int i=0;i<numPrb;i++){
handle.jumpToArrayElement(i);
probeConstraintRadius[i]=handle.inputValue().asDouble();
}
double constraintRadius = data.inputValue( aConstraintRadius ).asDouble();
for(int i=0;i<numPrb;i++){
double r = constraintRadius * probeConstraintRadius[i];
for(int j=0;j<numPts;j++){
if(D.distPts[i][j]<r){
constraint.push_back(T(i,j,constraintWeight * pow((r-D.distPts[i][j])/r,normExponent)));
}
}
}
}
int numConstraint=constraint.size();
mesh.constraintWeight.resize(numConstraint);
mesh.constraintVal.resize(numConstraint,numPrb);
for(int cur=0;cur<numConstraint;cur++){
mesh.constraintWeight[cur] = std::make_pair(constraint[cur].col(), constraint[cur].value());
}
//
isError = mesh.ARAPprecompute();
status = data.setClean(aARAP);
} // END of ARAP precomputation
if(isError>0){
return MS::kFailure;
}
// probe weight computation
if(!data.isClean(aComputeWeight) || isNumProbeChanged){
// load probe weights
MArrayDataHandle handle = data.inputArrayValue(aProbeWeight);
if(handle.elementCount() != numPrb){
MGlobal::displayInfo("# of Probes and probeWeight are different");
isError = ERROR_ATTR;
return MS::kFailure;
}
double effectRadius = data.inputValue( aEffectRadius ).asDouble();
std::vector<double> probeWeight(numPrb), probeRadius(numPrb);
for(int i=0;i<numPrb;i++){
handle.jumpToArrayElement(i);
probeWeight[i] = handle.inputValue().asDouble();
probeRadius[i] = probeWeight[i] * effectRadius;
}
wr.resize(mesh.numTet);ws.resize(mesh.numTet);wl.resize(mesh.numTet);
for(int j=0;j<mesh.numTet;j++){
wr[j].resize(numPrb); ws[j].resize(numPrb); wl[j].resize(numPrb);
}
short weightMode = data.inputValue( aWeightMode ).asShort();
if (weightMode == WM_INV_DISTANCE){
for(int j=0;j<mesh.numTet;j++){
double sum=0.0;
std::vector<double> idist(numPrb);
for (int i = 0; i<numPrb; i++){
idist[i] = probeRadius[i] / pow(D.distTet[i][j], normExponent);
sum += idist[i];
}
for (int i = 0; i<numPrb; i++){
wr[j][i] = ws[j][i] = wl[j][i] = sum > 0 ? idist[i] / sum : 0.0;
}
}
}
else if (weightMode == WM_CUTOFF_DISTANCE){
for(int j=0;j<mesh.numTet;j++){
for (int i = 0; i<numPrb; i++){
wr[j][i] = ws[j][i] = wl[j][i] = (D.distTet[i][j] > probeRadius[i])
? 0 : pow((probeRadius[i] - D.distTet[i][j]) / probeRadius[i], normExponent);
}
}
}else if (weightMode == WM_DRAW){
float val;
MRampAttribute rWeightCurveR( thisNode, aWeightCurveR, &status );
MRampAttribute rWeightCurveS( thisNode, aWeightCurveS, &status );
MRampAttribute rWeightCurveL( thisNode, aWeightCurveL, &status );
for(int j=0;j<mesh.numTet;j++){
for (int i = 0; i < numPrb; i++){
rWeightCurveR.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
wr[j][i] = val;
rWeightCurveS.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
ws[j][i] = val;
rWeightCurveL.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
wl[j][i] = val;
}
}
}else if(weightMode & WM_HARMONIC){
Laplacian harmonicWeighting;
makeFaceTet(data, input, inputGeom, mIndex, pts, harmonicWeighting.tetList, harmonicWeighting.tetMatrix, harmonicWeighting.tetWeight);
harmonicWeighting.numTet = (int)harmonicWeighting.tetList.size()/4;
std::vector<T> weightConstraint(numPrb);
// the vertex closest to the probe is given probeWeight
for(int i=0;i<numPrb;i++){
weightConstraint[i]=T(i,D.closestPts[i],probeWeight[i]);
}
// vertices within effectRadius are given probeWeight
if( data.inputValue( aNeighbourWeighting ).asBool() ){
for(int i=0;i<numPrb;i++){
for(int j=0;j<numPts;j++){
if(D.distPts[i][j]<probeRadius[i]){
weightConstraint.push_back(T(i,j,probeWeight[i]));
}
}
}
}
// set boundary condition for weight computation
int numConstraint=weightConstraint.size();
harmonicWeighting.constraintWeight.resize(numConstraint);
harmonicWeighting.constraintVal.resize(numConstraint,numPrb);
harmonicWeighting.constraintVal.setZero();
for(int i=0;i<numConstraint;i++){
harmonicWeighting.constraintVal(i,weightConstraint[i].row())=weightConstraint[i].value();
harmonicWeighting.constraintWeight[i] = std::make_pair(weightConstraint[i].col(), weightConstraint[i].value());
}
// clear tetWeight
if(!areaWeighted){
harmonicWeighting.tetWeight.clear();
harmonicWeighting.tetWeight.resize(harmonicWeighting.numTet,1.0);
}
// solve the laplace equation
if( weightMode == WM_HARMONIC_ARAP){
harmonicWeighting.computeTetMatrixInverse();
harmonicWeighting.dim = numPts + harmonicWeighting.numTet;
isError = harmonicWeighting.ARAPprecompute();
}else if(weightMode == WM_HARMONIC_COTAN){
harmonicWeighting.dim = numPts;
isError = harmonicWeighting.cotanPrecompute();
}
if(isError>0) return MS::kFailure;
std::vector< std::vector<double> > w_tet(numPrb);
harmonicWeighting.harmonicSolve();
for(int i=0;i<numPrb;i++){
makeTetWeightList(tetMode, mesh.tetList, faceList, edgeList, vertexList, harmonicWeighting.Sol.col(i), w_tet[i]);
for(int j=0;j<mesh.numTet; j++){
wr[j][i] = ws[j][i] = wl[j][i] = w_tet[i][j];
}
}
}
// normalise weights
short normaliseWeightMode = data.inputValue( aNormaliseWeight ).asShort();
for(int j=0;j<mesh.numTet;j++){
D.normaliseWeight(normaliseWeightMode, wr[j]);
D.normaliseWeight(normaliseWeightMode, ws[j]);
D.normaliseWeight(normaliseWeightMode, wl[j]);
}
status = data.setClean(aComputeWeight);
} // END of weight computation
// setting up transformation matrix
B.rotationConsistency = data.inputValue( aRotationConsistency ).asBool();
bool frechetSum = data.inputValue( aFrechetSum ).asBool();
blendedSE.resize(mesh.numTet); blendedR.resize(mesh.numTet); blendedS.resize(mesh.numTet); blendedL.resize(mesh.numTet);A.resize(mesh.numTet);
for(int i=0;i<numPrb;i++){
B.Aff[i]=initMatrix[i].inverse()*matrix[i];
}
B.parametrise(blendMode);
// prepare transform matrix for each simplex
#pragma omp parallel for
for (int j = 0; j < mesh.numTet; j++){
// blend matrix
if (blendMode == BM_SRL){
blendedS[j] = expSym(blendMat(B.logS, ws[j]));
Vector3d l = blendMat(B.L, wl[j]);
blendedR[j] = frechetSum ? frechetSO(B.R, wr[j]) : expSO(blendMat(B.logR, wr[j]));
A[j] = pad(blendedS[j]*blendedR[j], l);
}
else if (blendMode == BM_SSE){
blendedS[j] = expSym(blendMat(B.logS, ws[j]));
blendedSE[j] = expSE(blendMat(B.logSE, wr[j]));
A[j] = pad(blendedS[j], Vector3d::Zero()) * blendedSE[j];
}
else if (blendMode == BM_LOG3){
blendedR[j] = blendMat(B.logGL, wr[j]).exp();
Vector3d l = blendMat(B.L, wl[j]);
A[j] = pad(blendedR[j], l);
}
else if (blendMode == BM_LOG4){
A[j] = blendMat(B.logAff, wr[j]).exp();
}
else if (blendMode == BM_SQL){
Vector4d q = blendQuat(B.quat, wr[j]);
Vector3d l = blendMat(B.L, wl[j]);
blendedS[j] = blendMatLin(B.S, ws[j]);
Quaternion<double> RQ(q);
blendedR[j] = RQ.matrix().transpose();
A[j] = pad(blendedS[j]*blendedR[j], l);
}
else if (blendMode == BM_AFF){
A[j] = blendMatLin(B.Aff, wr[j]);
}
}
// compute target vertices position
tetEnergy.resize(mesh.numTet);
// set constraint
int numConstraints = constraint.size();
mesh.constraintVal.resize(numConstraints,3);
RowVector4d cv;
for(int cur=0;cur<numConstraints;cur++){
cv = pad(pts[constraint[cur].col()]) * B.Aff[constraint[cur].row()];
mesh.constraintVal(cur,0) = cv[0];
mesh.constraintVal(cur,1) = cv[1];
mesh.constraintVal(cur,2) = cv[2];
}
// iterate to determine vertices position
for(int k=0;k<numIter;k++){
// solve ARAP
mesh.ARAPSolve(A);
// set new vertices position
new_pts.resize(numPts);
for(int i=0;i<numPts;i++){
new_pts[i][0]=mesh.Sol(i,0);
new_pts[i][1]=mesh.Sol(i,1);
new_pts[i][2]=mesh.Sol(i,2);
}
// if iteration continues
if(k+1<numIter || visualisationMode == VM_ENERGY){
std::vector<double> dummy_weight;
makeTetMatrix(tetMode, new_pts, mesh.tetList, faceList, edgeList, vertexList, Q, dummy_weight);
Matrix3d S,R,newS,newR;
if(blendMode == BM_AFF || blendMode == BM_LOG4 || blendMode == BM_LOG3){
for(int i=0;i<mesh.numTet;i++){
polarHigham(A[i].block(0,0,3,3), blendedS[i], blendedR[i]);
}
}
#pragma omp parallel for
for(int i=0;i<mesh.numTet;i++){
polarHigham((mesh.tetMatrixInverse[i]*Q[i]).block(0,0,3,3), newS, newR);
tetEnergy[i] = (newS-blendedS[i]).squaredNorm();
A[i].block(0,0,3,3) = blendedS[i]*newR;
// polarHigham((A[i].transpose()*PI[i]*Q[i]).block(0,0,3,3), newS, newR);
// A[i].block(0,0,3,3) *= newR;
}
}
}
for(int i=0;i<numPts;i++){
Mpts[i].x=mesh.Sol(i,0);
Mpts[i].y=mesh.Sol(i,1);
Mpts[i].z=mesh.Sol(i,2);
}
if(worldMode){
for(int i=0;i<numPts;i++)
Mpts[i] *= localToWorldMatrix.inverse();
}
itGeo.setAllPositions(Mpts);
// set vertex colour
if(visualisationMode != VM_OFF){
std::vector<double> ptsColour(numPts, 0.0);
if(visualisationMode == VM_ENERGY){
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, tetEnergy, ptsColour);
for(int i=0;i<numPts;i++){
ptsColour[i] *= visualisationMultiplier;
}
}else if(visualisationMode == VM_STIFFNESS){
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetWeight, ptsColour);
double maxval = *std::max_element(ptsColour.begin(), ptsColour.end());
for(int i=0;i<numPts;i++){
ptsColour[i] = 1.0 - ptsColour[i]/maxval;
}
}else if(visualisationMode == VM_CONSTRAINT){
for(int i=0;i<constraint.size();i++){
ptsColour[constraint[i].col()] += constraint[i].value();
}
}else if(visualisationMode == VM_EFFECT){
std:vector<double> wsum(mesh.numTet);
for(int j=0;j<mesh.numTet;j++){
//wsum[j] = std::accumulate(wr[j].begin(), wr[j].end(), 0.0);
wsum[j]= visualisationMultiplier * wr[j][numPrb-1];
}
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, wsum, ptsColour);
}
visualise(data, outputGeom, ptsColour);
}
return MS::kSuccess;
}
void NifMeshExporterSkyrim::ExportMesh( MObject dagNode ) {
//out << "NifTranslator::ExportMesh {";
ComplexShape cs;
MStatus stat;
MObject mesh;
//Find Mesh child of given transform object
MFnDagNode nodeFn(dagNode);
cs.SetName(this->translatorUtils->MakeNifName(nodeFn.name()));
for (int i = 0; i != nodeFn.childCount(); ++i) {
// get a handle to the child
if (nodeFn.child(i).hasFn(MFn::kMesh)) {
MFnMesh tempFn(nodeFn.child(i));
//No history items
if (!tempFn.isIntermediateObject()) {
//out << "Found a mesh child." << endl;
mesh = nodeFn.child(i);
break;
}
}
}
MFnMesh visibleMeshFn(mesh, &stat);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to create visibleMeshFn.");
}
//out << visibleMeshFn.name().asChar() << ") {" << endl;
MFnMesh meshFn;
MObject dataObj;
MPlugArray inMeshPlugArray;
MPlug childPlug;
MPlug geomPlug;
MPlug inputPlug;
// this will hold the returned vertex positions
MPointArray vts;
//For now always use the visible mesh
meshFn.setObject(mesh);
//out << "Use the function set to get the points" << endl;
// use the function set to get the points
stat = meshFn.getPoints(vts);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get points.");
}
//Maya won't store any information about objects with no vertices. Just skip it.
if (vts.length() == 0) {
MGlobal::displayWarning("An object in this scene has no vertices. Nothing will be exported.");
return;
}
vector<WeightedVertex> nif_vts(vts.length());
for (int i = 0; i != vts.length(); ++i) {
nif_vts[i].position.x = float(vts[i].x);
nif_vts[i].position.y = float(vts[i].y);
nif_vts[i].position.z = float(vts[i].z);
}
//Set vertex info later since it includes skin weights
//cs.SetVertices( nif_vts );
//out << "Use the function set to get the colors" << endl;
MColorArray myColors;
meshFn.getFaceVertexColors(myColors);
//out << "Prepare NIF color vector" << endl;
vector<Color4> niColors(myColors.length());
for (unsigned int i = 0; i < myColors.length(); ++i) {
niColors[i] = Color4(myColors[i].r, myColors[i].g, myColors[i].b, myColors[i].a);
}
cs.SetColors(niColors);
// this will hold the returned vertex positions
MFloatVectorArray nmls;
//out << "Use the function set to get the normals" << endl;
// use the function set to get the normals
stat = meshFn.getNormals(nmls, MSpace::kTransform);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get normals");
}
//out << "Prepare NIF normal vector" << endl;
vector<Vector3> nif_nmls(nmls.length());
for (int i = 0; i != nmls.length(); ++i) {
nif_nmls[i].x = float(nmls[i].x);
nif_nmls[i].y = float(nmls[i].y);
nif_nmls[i].z = float(nmls[i].z);
}
cs.SetNormals(nif_nmls);
//out << "Use the function set to get the UV set names" << endl;
MStringArray uvSetNames;
MString baseUVSet;
MFloatArray myUCoords;
MFloatArray myVCoords;
bool has_uvs = false;
// get the names of the uv sets on the mesh
meshFn.getUVSetNames(uvSetNames);
vector<TexCoordSet> nif_uvs;
//Record assotiation between name and uv set index for later
map<string, int> uvSetNums;
int set_num = 0;
for (unsigned int i = 0; i < uvSetNames.length(); ++i) {
if (meshFn.numUVs(uvSetNames[i]) > 0) {
TexType tt;
string set_name = uvSetNames[i].asChar();
if (set_name == "base" || set_name == "map1") {
tt = BASE_MAP;
}
else if (set_name == "dark") {
tt = DARK_MAP;
}
else if (set_name == "detail") {
tt = DETAIL_MAP;
}
else if (set_name == "gloss") {
tt = GLOSS_MAP;
}
else if (set_name == "glow") {
tt = GLOW_MAP;
}
else if (set_name == "bump") {
tt = BUMP_MAP;
}
else if (set_name == "decal0") {
tt = DECAL_0_MAP;
}
else if (set_name == "decal1") {
tt = DECAL_1_MAP;
}
else {
tt = BASE_MAP;
}
//Record the assotiation
uvSetNums[set_name] = set_num;
//Get the UVs
meshFn.getUVs(myUCoords, myVCoords, &uvSetNames[i]);
//Make sure this set actually has some UVs in it. Maya sometimes returns empty UV sets.
if (myUCoords.length() == 0) {
continue;
}
//Store the data
TexCoordSet tcs;
tcs.texType = tt;
tcs.texCoords.resize(myUCoords.length());
for (unsigned int j = 0; j < myUCoords.length(); ++j) {
tcs.texCoords[j].u = myUCoords[j];
//Flip the V coords
tcs.texCoords[j].v = 1.0f - myVCoords[j];
}
nif_uvs.push_back(tcs);
baseUVSet = uvSetNames[i];
has_uvs = true;
set_num++;
}
}
cs.SetTexCoordSets(nif_uvs);
// this will hold references to the shaders used on the meshes
MObjectArray Shaders;
// this is used to hold indices to the materials returned in the object array
MIntArray FaceIndices;
//out << "Get the connected shaders" << endl;
// get the shaders used by the i'th mesh instance
// Assume this is not instanced for now
// TODO support instancing properly
stat = visibleMeshFn.getConnectedShaders(0, Shaders, FaceIndices);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get connected shader list.");
}
vector<ComplexFace> nif_faces;
//Add shaders to propGroup array
vector< vector<NiPropertyRef> > propGroups;
for (unsigned int shader_num = 0; shader_num < Shaders.length(); ++shader_num) {
//Maya sometimes lists shaders that are not actually attached to any face. Disregard them.
bool shader_is_used = false;
for (size_t f = 0; f < FaceIndices.length(); ++f) {
if (FaceIndices[f] == shader_num) {
shader_is_used = true;
break;
}
}
if (shader_is_used == false) {
//Shader isn't actually used, so continue to the next one.
continue;
}
//out << "Found attached shader: ";
//Attach all properties previously associated with this shader to
//this NiTriShape
MFnDependencyNode fnDep(Shaders[shader_num]);
//Find the shader that this shading group connects to
MPlug p = fnDep.findPlug("surfaceShader");
MPlugArray plugs;
p.connectedTo(plugs, true, false);
for (unsigned int i = 0; i < plugs.length(); ++i) {
if (plugs[i].node().hasFn(MFn::kLambert)) {
fnDep.setObject(plugs[i].node());
break;
}
}
//out << fnDep.name().asChar() << endl;
vector<NiPropertyRef> niProps = this->translatorData->shaders[fnDep.name().asChar()];
propGroups.push_back(niProps);
}
cs.SetPropGroups(propGroups);
//out << "Export vertex and normal data" << endl;
// attach an iterator to the mesh
MItMeshPolygon itPoly(mesh, &stat);
if (stat != MS::kSuccess) {
throw runtime_error("Failed to create polygon iterator.");
}
// Create a list of faces with vertex IDs, and duplicate normals so they have the same ID
for (; !itPoly.isDone(); itPoly.next()) {
int poly_vert_count = itPoly.polygonVertexCount(&stat);
if (stat != MS::kSuccess) {
throw runtime_error("Failed to get vertex count.");
}
//Ignore polygons with less than 3 vertices
if (poly_vert_count < 3) {
continue;
}
ComplexFace cf;
//Assume all faces use material 0 for now
cf.propGroupIndex = 0;
for (int i = 0; i < poly_vert_count; ++i) {
ComplexPoint cp;
cp.vertexIndex = itPoly.vertexIndex(i);
cp.normalIndex = itPoly.normalIndex(i);
if (niColors.size() > 0) {
int color_index;
stat = meshFn.getFaceVertexColorIndex(itPoly.index(), i, color_index);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get vertex color.");
}
cp.colorIndex = color_index;
}
//Get the UV set names used by this particular vertex
MStringArray vertUvSetNames;
itPoly.getUVSetNames(vertUvSetNames);
for (unsigned int j = 0; j < vertUvSetNames.length(); ++j) {
TexCoordIndex tci;
tci.texCoordSetIndex = uvSetNums[vertUvSetNames[j].asChar()];
int uv_index;
itPoly.getUVIndex(i, uv_index, &vertUvSetNames[j]);
tci.texCoordIndex = uv_index;
cp.texCoordIndices.push_back(tci);
}
cf.points.push_back(cp);
}
nif_faces.push_back(cf);
}
//Set shader/face association
if (nif_faces.size() != FaceIndices.length()) {
throw runtime_error("Num faces found do not match num faces reported.");
}
for (unsigned int face_index = 0; face_index < nif_faces.size(); ++face_index) {
nif_faces[face_index].propGroupIndex = FaceIndices[face_index];
}
cs.SetFaces(nif_faces);
//--Skin Processing--//
//Look up any skin clusters
if (this->translatorData->meshClusters.find(visibleMeshFn.fullPathName().asChar()) != this->translatorData->meshClusters.end()) {
const vector<MObject> & clusters = this->translatorData->meshClusters[visibleMeshFn.fullPathName().asChar()];
if (clusters.size() > 1) {
throw runtime_error("Objects with multiple skin clusters affecting them are not currently supported. Try deleting the history and re-binding them.");
}
vector<MObject>::const_iterator cluster = clusters.begin();
if (cluster->isNull() != true) {
MFnSkinCluster clusterFn(*cluster);
//out << "Processing skin..." << endl;
//Get path to visible mesh
MDagPath meshPath;
visibleMeshFn.getPath(meshPath);
//out << "Getting a list of all verticies in this mesh" << endl;
//Get a list of all vertices in this mesh
MFnSingleIndexedComponent compFn;
MObject vertices = compFn.create(MFn::kMeshVertComponent);
MItGeometry gIt(meshPath);
MIntArray vertex_indices(gIt.count());
for (int vert_index = 0; vert_index < gIt.count(); ++vert_index) {
vertex_indices[vert_index] = vert_index;
}
compFn.addElements(vertex_indices);
//out << "Getting Influences" << endl;
//Get influences
MDagPathArray myBones;
clusterFn.influenceObjects(myBones, &stat);
//out << "Creating a list of NiNodeRefs of influences." << endl;
//Create list of NiNodeRefs of influences
vector<NiNodeRef> niBones(myBones.length());
for (unsigned int bone_index = 0; bone_index < niBones.size(); ++bone_index) {
const char* boneName = myBones[bone_index].fullPathName().asChar();
if (this->translatorData->nodes.find(myBones[bone_index].fullPathName().asChar()) == this->translatorData->nodes.end()) {
//There is a problem; one of the joints was not exported. Abort.
throw runtime_error("One of the joints necessary to export a bound skin was not exported.");
}
niBones[bone_index] = this->translatorData->nodes[myBones[bone_index].fullPathName().asChar()];
}
//out << "Getting weights from Maya" << endl;
//Get weights from Maya
MDoubleArray myWeights;
unsigned int bone_count = myBones.length();
stat = clusterFn.getWeights(meshPath, vertices, myWeights, bone_count);
if (stat != MS::kSuccess) {
//out << stat.errorString().asChar() << endl;
throw runtime_error("Failed to get vertex weights.");
}
//out << "Setting skin influence list in ComplexShape" << endl;
//Set skin information in ComplexShape
cs.SetSkinInfluences(niBones);
//out << "Adding weights to ComplexShape vertices" << endl;
//out << "Number of weights: " << myWeights.length() << endl;
//out << "Number of bones: " << myBones.length() << endl;
//out << "Number of Maya vertices: " << gIt.count() << endl;
//out << "Number of NIF vertices: " << int(nif_vts.size()) << endl;
unsigned int weight_index = 0;
SkinInfluence sk;
for (unsigned int vert_index = 0; vert_index < nif_vts.size(); ++vert_index) {
for (unsigned int bone_index = 0; bone_index < myBones.length(); ++bone_index) {
//out << "vert_index: " << vert_index << " bone_index: " << bone_index << " weight_index: " << weight_index << endl;
// Only bother with weights that are significant
if (myWeights[weight_index] > 0.0f) {
sk.influenceIndex = bone_index;
sk.weight = float(myWeights[weight_index]);
nif_vts[vert_index].weights.push_back(sk);
}
++weight_index;
}
}
}
MPlugArray connected_dismember_plugs;
MObjectArray dismember_nodes;
meshFn.findPlug("message").connectedTo(connected_dismember_plugs, false, true);
bool has_valid_dismemember_partitions = true;
int faces_count = cs.GetFaces().size();
int current_face_index;
vector<BodyPartList> body_parts_list;
vector<uint> dismember_faces(faces_count, 0);
for (int x = 0; x < connected_dismember_plugs.length(); x++) {
MFnDependencyNode dependency_node(connected_dismember_plugs[x].node());
if (dependency_node.typeName() == "nifDismemberPartition") {
dismember_nodes.append(dependency_node.object());
}
}
if (dismember_nodes.length() == 0) {
has_valid_dismemember_partitions = false;
}
else {
int blind_data_id;
int blind_data_value;
MStatus status;
MPlug target_faces_plug;
MItMeshPolygon it_polygons(meshFn.object());
MString mel_command;
MStringArray current_body_parts_flags;
MFnDependencyNode current_dismember_node;
MFnDependencyNode current_blind_data_node;
//Naive sort here, there is no reason and is extremely undesirable and not recommended to have more
//than 10-20 dismember partitions out of many reasons, so it's okay here
//as it makes the code easier to understand
vector<int> dismember_nodes_id(dismember_nodes.length(), -1);
for (int x = 0; x < dismember_nodes.length(); x++) {
current_dismember_node.setObject(dismember_nodes[x]);
connected_dismember_plugs.clear();
current_dismember_node.findPlug("targetFaces").connectedTo(connected_dismember_plugs, true, false);
if (connected_dismember_plugs.length() == 0) {
has_valid_dismemember_partitions = false;
break;
}
current_blind_data_node.setObject(connected_dismember_plugs[0].node());
dismember_nodes_id[x] = current_blind_data_node.findPlug("typeId").asInt();
}
for (int x = 0; x < dismember_nodes.length() - 1; x++) {
for (int y = x + 1; y < dismember_nodes.length(); y++) {
if (dismember_nodes_id[x] > dismember_nodes_id[y]) {
MObject aux = dismember_nodes[x];
blind_data_id = dismember_nodes_id[x];
dismember_nodes[x] = dismember_nodes[y];
dismember_nodes_id[x] = dismember_nodes_id[y];
dismember_nodes[y] = aux;
dismember_nodes_id[y] = blind_data_id;
}
}
}
for (int x = 0; x < dismember_nodes.length(); x++) {
current_dismember_node.setObject(dismember_nodes[x]);
target_faces_plug = current_dismember_node.findPlug("targetFaces");
connected_dismember_plugs.clear();
target_faces_plug.connectedTo(connected_dismember_plugs, true, false);
if (connected_dismember_plugs.length() > 0) {
current_blind_data_node.setObject(connected_dismember_plugs[0].node());
current_face_index = 0;
blind_data_id = current_blind_data_node.findPlug("typeId").asInt();
for (it_polygons.reset(); !it_polygons.isDone(); it_polygons.next()) {
if (it_polygons.polygonVertexCount() >= 3) {
status = meshFn.getIntBlindData(it_polygons.index(), MFn::Type::kMeshPolygonComponent, blind_data_id, "dismemberValue", blind_data_value);
if (status == MStatus::kSuccess && blind_data_value == 1 &&
meshFn.hasBlindDataComponentId(it_polygons.index(), MFn::Type::kMeshPolygonComponent, blind_data_id)) {
dismember_faces[current_face_index] = x;
}
current_face_index++;
}
}
}
else {
has_valid_dismemember_partitions = false;
break;
}
mel_command = "getAttr ";
mel_command += current_dismember_node.name();
mel_command += ".bodyPartsFlags";
status = MGlobal::executeCommand(mel_command, current_body_parts_flags);
BSDismemberBodyPartType body_part_type = NifDismemberPartition::stringArrayToBodyPartType(current_body_parts_flags);
current_body_parts_flags.clear();
mel_command = "getAttr ";
mel_command += current_dismember_node.name();
mel_command += ".partsFlags";
status = MGlobal::executeCommand(mel_command, current_body_parts_flags);
BSPartFlag part_type = NifDismemberPartition::stringArrayToPart(current_body_parts_flags);
current_body_parts_flags.clear();
BodyPartList body_part;
body_part.bodyPart = body_part_type;
body_part.partFlag = part_type;
body_parts_list.push_back(body_part);
}
}
if (has_valid_dismemember_partitions == false) {
MGlobal::displayWarning("No proper dismember partitions, generating default ones for " + meshFn.name());
for (int x = 0; x < dismember_faces.size(); x++) {
dismember_faces[x] = 0;
}
BodyPartList body_part;
body_part.bodyPart = (BSDismemberBodyPartType)0;
body_part.partFlag = (BSPartFlag)(PF_EDITOR_VISIBLE | PF_START_NET_BONESET);
body_parts_list.clear();
body_parts_list.push_back(body_part);
}
cs.SetDismemberPartitionsBodyParts(body_parts_list);
cs.SetDismemberPartitionsFaces(dismember_faces);
}
//out << "Setting vertex info" << endl;
//Set vertex info now that any skins have been processed
cs.SetVertices(nif_vts);
//ComplexShape is now complete, so split it
//Get parent
NiNodeRef parNode = this->translatorUtils->GetDAGParent(dagNode);
Matrix44 transform = Matrix44::IDENTITY;
vector<NiNodeRef> influences = cs.GetSkinInfluences();
if (influences.size() > 0) {
//This is a skin, so we use the common ancestor of all influences
//as the parent
vector<NiAVObjectRef> objects;
for (size_t i = 0; i < influences.size(); ++i) {
objects.push_back(StaticCast<NiAVObject>(influences[i]));
}
//Get world transform of existing parent
Matrix44 oldParWorld = parNode->GetWorldTransform();
//Set new parent node
parNode = FindCommonAncestor(objects);
transform = oldParWorld * parNode->GetWorldTransform().Inverse();
}
//Get transform using temporary NiAVObject
NiAVObjectRef tempAV = new NiAVObject;
this->nodeExporter->ExportAV(tempAV, dagNode);
NiAVObjectRef avObj;
if (this->translatorOptions->exportTangentSpace == "falloutskyrimtangentspace") {
//out << "Split ComplexShape from " << meshFn.name().asChar() << endl;
avObj = cs.Split(parNode, tempAV->GetLocalTransform() * transform, this->translatorOptions->exportBonesPerSkinPartition,
this->translatorOptions->exportAsTriStrips, true, this->translatorOptions->exportMinimumVertexWeight, 16);
}
else {
avObj = cs.Split(parNode, tempAV->GetLocalTransform() * transform, this->translatorOptions->exportBonesPerSkinPartition,
this->translatorOptions->exportAsTriStrips, false, this->translatorOptions->exportMinimumVertexWeight);
}
//out << "Get the NiAVObject portion of the root of the split" <<endl;
//Get the NiAVObject portion of the root of the split
avObj->SetName(tempAV->GetName());
avObj->SetVisibility(tempAV->GetVisibility());
avObj->SetFlags(tempAV->GetFlags());
//If polygon mesh is hidden, hide tri_shape
MPlug vis = visibleMeshFn.findPlug(MString("visibility"));
bool visibility;
vis.getValue(visibility);
NiNodeRef splitRoot = DynamicCast<NiNode>(avObj);
if (splitRoot != NULL) {
//Root is a NiNode with NiTriBasedGeom children.
vector<NiAVObjectRef> children = splitRoot->GetChildren();
for (unsigned c = 0; c < children.size(); ++c) {
//Set the default collision propogation flag to "use triangles"
children[c]->SetFlags(2);
// Make the mesh invisible if necessary
if (visibility == false) {
children[c]->SetVisibility(false);
}
}
}
else {
//Root must be a NiTriBasedGeom. Make it invisible if necessary
if (visibility == false) {
avObj->SetVisibility(false);
}
}
}
// Maps vertex points in uv coordinates (uPoints and vPoints) onto plane and creates a new mesh
// Only works with planes with the local normal along the y-axis for now (default Maya polyplane)
MStatus SplitFromImage::addPlaneSubMesh(MObject &object, MFloatArray uPoints, MFloatArray vPoints, const MFnMesh &planeMesh) {
if(uPoints.length() != vPoints.length())
return MS::kFailure;
MPointArray planePoints;
MIntArray planeVertexCount;
MIntArray planeVertexList;
planeMesh.getPoints(planePoints);
planeMesh.getVertices(planeVertexCount, planeVertexList);
cout << "planeVertexCount: " << planeVertexCount.length() << endl;
cout << "planeVertexList: " << planeVertexList.length() << endl;
double minX, minZ, maxX, maxZ;
minX = minZ = 100000;
maxX = maxZ = -100000;
// Find min and max points of the plane
for(unsigned int i = 0; i < planePoints.length(); i++) {
double x = planePoints[i].x;
double z = planePoints[i].z;
if(planePoints[i].x < minX)
minX = x;
if(planePoints[i].x > maxX)
maxX = x;
if(planePoints[i].z < minZ)
minZ = x;
if(planePoints[i].z > maxZ)
maxZ = z;
}
// Set plane's corner pos and width and height
double planeX = minX;
double planeY = minZ;
double planeWidth = maxX - minX;
double planeHeight = maxZ - minZ;
// Prepare stuff for MFnMesh
int numVertices = uPoints.length();
int numPolygons = 1;
MPointArray pointArray;
int polygon_counts[1] = {numVertices};
MIntArray polygonCounts(polygon_counts, 1);
int *polygon_connects = new int[numVertices];
for(int i = 0; i < numVertices; i++) {
polygon_connects[i] = i;
MPoint point(planeX + planeWidth * uPoints[i], 0, planeY + planeHeight * vPoints[i]);
pointArray.append(point);
}
MIntArray polygonConnects(polygon_connects, numVertices);
delete[] polygon_connects;
// cout << "numVertices: " << numVertices << endl
// << "numPolygons: " << numPolygons << endl
// << "pointArray: " << pointArray << endl
// << "polygonCounts: " << polygonCounts << endl
// << "polygonConnects: " << polygonConnects << endl
// << "planeX: " << planeX << endl
// << "planeY: " << planeY << endl
// << "planeWidth: " << planeWidth << endl
// << "planeHeight: " << planeHeight << endl;
for (int i = 0; i < vPoints.length(); i++){
vPoints[i] = 1.0 - vPoints[i];
}
MFnMesh mesh;
object = mesh.create(numVertices, numPolygons, pointArray, polygonCounts, polygonConnects, uPoints, vPoints);
mesh.assignUVs(polygonCounts, polygonConnects);
return MS::kSuccess;
}
MStatus meshRemapTool::resolveMapping()
{
// Get the list of selected items
MGlobal::getActiveSelectionList( fSelectionList );
if( fSelectionList.length() != 2)
{
reset();
helpStateHasChanged();
return MStatus::kFailure;
}
MDagPath dagPath;
MObject component;
if( fSelectionList.getDagPath(0, dagPath, component) != MStatus::kSuccess)
{
MGlobal::displayError(" Invalid source mesh");
return MStatus::kFailure;
}
dagPath.extendToShape();
// Repeat this 3 times one for each vertex
fSelectedPathSrc.append(dagPath);
fSelectedPathSrc.append(dagPath);
fSelectedPathSrc.append(dagPath);
if( fSelectionList.getDagPath(1, dagPath, component) != MStatus::kSuccess)
{
MGlobal::displayError(" Invalid destination mesh");
return MStatus::kFailure;
}
dagPath.extendToShape();
// Repeat this 3 times one for each vertex
fSelectedPathDst.append(dagPath);
fSelectedPathDst.append(dagPath);
fSelectedPathDst.append(dagPath);
// Find the vertices in Object Space of the first polygon
MPointArray srcPts;
MIntArray srcVertIds, dstVertIds;
MItMeshPolygon faceIterSrc(fSelectedPathSrc[0]);
unsigned srcFaceId = faceIterSrc.index();
faceIterSrc.getPoints(srcPts, MSpace::kObject);
faceIterSrc.getVertices(srcVertIds);
// Tranfrom the vertices to dst World Space
unsigned i, j;
MMatrix m = fSelectedPathDst[0].inclusiveMatrix();
for(i = 0; i < srcPts.length(); i++)
{
srcPts[i] = srcPts[i] * m;
}
MItMeshPolygon faceIterDst(fSelectedPathDst[0]);
while (!faceIterDst.isDone())
{
MPointArray dstPts;
faceIterDst.getPoints(dstPts, MSpace::kWorld);
if (arePointsOverlap(srcPts, dstPts))
{
// Set face and vertex indices
fSelectedFaceSrc = srcFaceId;
fSelectedFaceDst = faceIterDst.index();
fSelectVtxSrc.append(srcVertIds[0]);
fSelectVtxSrc.append(srcVertIds[1]);
fSelectVtxSrc.append(srcVertIds[2]);
faceIterDst.getVertices(dstVertIds);
for (j = 0; j < dstPts.length(); j++)
{
MVector v = dstPts[j] - srcPts[0];
if (v * v < epsilon)
{
fSelectVtxDst.append(dstVertIds[j]);
break;
}
}
for (j = 0; j < dstPts.length(); j++)
{
MVector v = dstPts[j] - srcPts[1];
if (v * v < epsilon)
{
fSelectVtxDst.append(dstVertIds[j]);
break;
}
}
for (j = 0; j < dstPts.length(); j++)
{
MVector v = dstPts[j] - srcPts[2];
if (v * v < epsilon)
{
fSelectVtxDst.append(dstVertIds[j]);
break;
}
}
return MStatus::kSuccess;
}
faceIterDst.next();
}
return MStatus::kFailure;
}
MStatus particlePathsCmd::doIt( const MArgList& args )
{
MStatus stat = parseArgs( args );
if( stat != MS::kSuccess )
{
return stat;
}
MFnParticleSystem cloud( particleNode );
if( ! cloud.isValid() )
{
MGlobal::displayError( "The function set is invalid!" );
return MS::kFailure;
}
//
// Create curves from the particle system in two stages. First, sample
// all particle positions from the start time to the end time. Then,
// use the data that was collected to create curves.
//
// Create the particle hash table at a fixed size. This should work fine
// for small particle systems, but may become inefficient for larger ones.
// If the plugin is running very slow, increase the size. The value should
// be roughly the number of particles that are expected to be emitted
// within the time period.
//
ParticleIdHash hash(1024);
MIntArray idList;
//
// Stage 1
//
MVectorArray positions;
MIntArray ids;
int i = 0;
for (double time = start; time <= finish + TOLERANCE; time += increment)
{
MTime timeSeconds(time,MTime::kSeconds);
// It is necessary to query the worldPosition attribute to force the
// particle positions to update.
//
cloud.evaluateDynamics(timeSeconds,false);
// MGlobal::executeCommand(MString("getAttr ") + cloud.name() +
// MString(".worldPosition"));
if (!cloud.isValid())
{
MGlobal::displayError( "Particle system has become invalid." );
return MS::kFailure;
}
MGlobal::displayInfo( MString("Received ") + (int)(cloud.count()) +
" particles, at time " + time);
// Request position and ID data for particles
//
cloud.position( positions );
cloud.particleIds( ids );
if (ids.length() != cloud.count() || positions.length() != cloud.count())
{
MGlobal::displayError( "Invalid array sizes." );
return MS::kFailure;
}
for (int j = 0; j < (int)cloud.count(); j++)
{
// Uncomment to show particle positions as the plugin accumulates
// samples.
/*
MGlobal::displayInfo(MString("(") + (positions[j])[0] + MString(",") +
(positions[j])[1] + MString(",") + (positions[j])[2] + MString(")"));
*/
MPoint pt(positions[j]);
if (hash.getPoints(ids[j]).length() == 0)
{
idList.append(ids[j]);
}
hash.insert(ids[j],pt);
}
i++;
}
//
// Stage 2
//
for (i = 0; i < (int)(idList.length()); i++)
{
MPointArray points = hash.getPoints(idList[i]);
// Don't bother with single samples
if (points.length() <= 1)
{
continue;
}
// Add two additional points, so that the curve covers all sampled
// values.
//
MPoint p1 = points[0]*2 - points[1];
MPoint p2 = points[points.length()-1]*2 - points[points.length()-2];
points.insert(p1,0);
points.append(p2);
// Uncomment to show information about the generated curves
/*
MGlobal::displayInfo( MString("ID ") + (int)(idList[i]) + " has " + (int)(points.length()) + " curve points.");
for (int j = 0; j < (int)(points.length()); j++)
{
MGlobal::displayInfo(MString("(") + points[j][0] + MString(",") + points[j][1] + MString(",") + points[j][2] + MString(")"));
}
*/
MDoubleArray knots;
knots.insert(0.0,0);
for (int j = 0; j < (int)(points.length()); j++)
{
knots.append((double)j);
}
knots.append(points.length()-1);
MStatus status;
MObject dummy;
MFnNurbsCurve curve;
curve.create(points,knots,3,MFnNurbsCurve::kOpen,false,false,dummy,&status);
if (!status)
{
MGlobal::displayError("Failed to create nurbs curve.");
return MS::kFailure;
}
}
return MS::kSuccess;
}
void CoronaRenderer::defineMesh(mtco_MayaObject *obj)
{
MObject meshObject = obj->mobject;
MStatus stat = MStatus::kSuccess;
bool hasDisplacement = false;
Corona::Abstract::Map *displacementMap = NULL;
float displacementMin = 0.0f;
float displacementMax = 0.01f;
// I do it here for displacement mapping, maybe we should to another place
getObjectShadingGroups(obj->dagPath, obj->perFaceAssignments, obj->shadingGroups);
if( obj->shadingGroups.length() > 0)
{
MFnDependencyNode shadingGroup(obj->shadingGroups[0]);
MString sgn = shadingGroup.name();
MObject displacementObj = getConnectedInNode(obj->shadingGroups[0], "displacementShader");
MString doo = getObjectName(displacementObj);
if( (displacementObj != MObject::kNullObj) && (displacementObj.hasFn(MFn::kDisplacementShader)))
{
MObject displacementMapObj = getConnectedInNode(displacementObj, "displacement");
if( (displacementMapObj != MObject::kNullObj) && (displacementMapObj.hasFn(MFn::kFileTexture)))
{
MFnDependencyNode displacmentMapNode(displacementObj);
getFloat("mtco_displacementMin", displacmentMapNode, displacementMin);
getFloat("mtco_displacementMax", displacmentMapNode, displacementMax);
MString fileTexturePath = getConnectedFileTexturePath(MString("displacement"), displacmentMapNode);
if( fileTexturePath != "")
{
MapLoader loader;
displacementMap = loader.loadBitmap(fileTexturePath.asChar());
hasDisplacement = true;
}
}
}
}
MFnMesh meshFn(meshObject, &stat);
CHECK_MSTATUS(stat);
MItMeshPolygon faceIt(meshObject, &stat);
CHECK_MSTATUS(stat);
MPointArray points;
meshFn.getPoints(points);
MFloatVectorArray normals;
meshFn.getNormals( normals, MSpace::kWorld );
MFloatArray uArray, vArray;
meshFn.getUVs(uArray, vArray);
//logger.debug(MString("Translating mesh object ") + meshFn.name().asChar());
MString meshFullName = makeGoodString(meshFn.fullPathName());
Corona::TriangleData td;
Corona::IGeometryGroup* geom = NULL;
geom = this->context.scene->addGeomGroup();
obj->geom = geom;
for( uint vtxId = 0; vtxId < points.length(); vtxId++)
{
geom->getVertices().push(Corona::Pos(points[vtxId].x,points[vtxId].y,points[vtxId].z));
}
for( uint nId = 0; nId < normals.length(); nId++)
{
geom->getNormals().push(Corona::Dir(normals[nId].x,normals[nId].y,normals[nId].z));
}
for( uint tId = 0; tId < uArray.length(); tId++)
{
geom->getMapCoords().push(Corona::Pos(uArray[tId],vArray[tId],0.0f));
geom->getMapCoordIndices().push(geom->getMapCoordIndices().size());
}
MPointArray triPoints;
MIntArray triVtxIds;
MIntArray faceVtxIds;
MIntArray faceNormalIds;
for(faceIt.reset(); !faceIt.isDone(); faceIt.next())
{
int faceId = faceIt.index();
int numTris;
faceIt.numTriangles(numTris);
faceIt.getVertices(faceVtxIds);
MIntArray faceUVIndices;
faceNormalIds.clear();
for( uint vtxId = 0; vtxId < faceVtxIds.length(); vtxId++)
{
faceNormalIds.append(faceIt.normalIndex(vtxId));
int uvIndex;
faceIt.getUVIndex(vtxId, uvIndex);
faceUVIndices.append(uvIndex);
}
for( int triId = 0; triId < numTris; triId++)
{
int faceRelIds[3];
faceIt.getTriangle(triId, triPoints, triVtxIds);
for( uint triVtxId = 0; triVtxId < 3; triVtxId++)
{
for(uint faceVtxId = 0; faceVtxId < faceVtxIds.length(); faceVtxId++)
{
if( faceVtxIds[faceVtxId] == triVtxIds[triVtxId])
{
faceRelIds[triVtxId] = faceVtxId;
}
}
}
uint vtxId0 = faceVtxIds[faceRelIds[0]];
uint vtxId1 = faceVtxIds[faceRelIds[1]];
uint vtxId2 = faceVtxIds[faceRelIds[2]];
uint normalId0 = faceNormalIds[faceRelIds[0]];
uint normalId1 = faceNormalIds[faceRelIds[1]];
uint normalId2 = faceNormalIds[faceRelIds[2]];
uint uvId0 = faceUVIndices[faceRelIds[0]];
uint uvId1 = faceUVIndices[faceRelIds[1]];
uint uvId2 = faceUVIndices[faceRelIds[2]];
if( hasDisplacement )
{
Corona::DisplacedTriangleData tri;
tri.displacement.map = displacementMap;
MPoint p0 = points[vtxId0];
MPoint p1 = points[vtxId1];
MPoint p2 = points[vtxId2];
tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
MVector n0 = normals[normalId0];
MVector n1 = normals[normalId1];
MVector n2 = normals[normalId2];
Corona::Dir dir0(n0.x, n0.y, n0.z);
Corona::Dir dir1(n1.x, n1.y, n1.z);
Corona::Dir dir2(n2.x, n2.y, n2.z);
tri.n[0] = Corona::AnimatedDir(dir0);
tri.n[1] = Corona::AnimatedDir(dir1);
tri.n[2] = Corona::AnimatedDir(dir2);
Corona::Pos uv0(uArray[uvId0],vArray[uvId0],0.0);
Corona::Pos uv1(uArray[uvId1],vArray[uvId1],0.0);
Corona::Pos uv2(uArray[uvId2],vArray[uvId2],0.0);
Corona::StaticArray<Corona::Pos, 3> uvp;
uvp[0] = uv0;
uvp[1] = uv1;
uvp[2] = uv2;
tri.t.push(uvp);
tri.materialId = 0;
tri.displacement.min = displacementMin;
tri.displacement.max = displacementMax;
geom->addPrimitive(tri);
}else{
Corona::TriangleData tri;
tri.v = Corona::AnimatedPosI3(vtxId0, vtxId1, vtxId2);
tri.n = Corona::AnimatedDirI3(normalId0, normalId1, normalId2);
tri.t[0] = uvId0;
tri.t[1] = uvId1;
tri.t[2] = uvId2;
tri.materialId = 0;
geom->addPrimitive(tri);
}
}
}
}
MStatus multiCurve::compute( const MPlug& plug, MDataBlock& data )
{
MStatus stat;
if ( plug == outputCurves )
{
MDataHandle numCurvesHandle = data.inputValue(numCurves, &stat);
PERRORfail(stat, "multiCurve::compute getting numCurves");
int num = numCurvesHandle.asLong();
MDataHandle curveOffsetHandle = data.inputValue(curveOffset, &stat);
PERRORfail(stat, "multiCurve::compute getting curveOffset");
double baseOffset = curveOffsetHandle.asDouble();
MDataHandle inputCurveHandle = data.inputValue(inputCurve, &stat);
PERRORfail(stat, "multiCurve::compute getting inputCurve");
MObject inputCurveObject ( inputCurveHandle.asNurbsCurveTransformed() );
MFnNurbsCurve inCurveFS ( inputCurveObject );
MArrayDataHandle outputArray = data.outputArrayValue(outputCurves,
&stat);
PERRORfail(stat, "multiCurve::compute getting output data handle");
// Create an array data build that is preallocated to hold just
// the number of curves we plan on creating. When this builder
// is set in to the MArrayDataHandle at the end of the compute
// method, the new array will replace the existing array in the
// scene.
//
// If the number of elements of the multi does not change between
// compute cycles, then one can reuse the space allocated on a
// previous cycle by extracting the existing builder from the
// MArrayDataHandle:
// MArrayDataBuilder builder( outputArray.builder(&stat) );
// this later form of the builder will allow you to rewrite elements
// of the array, and to grow it, but the array can only be shrunk by
// explicitly removing elements with the method
// MArrayDataBuilder::removeElement(unsigned index);
//
MArrayDataBuilder builder(outputCurves, num, &stat);
PERRORfail(stat, "multiCurve::compute creating builder");
for (int curveNum = 0; curveNum < num; curveNum++) {
MDataHandle outHandle = builder.addElement(curveNum);
MFnNurbsCurveData dataCreator;
MObject outCurveData = dataCreator.create();
MObject outputCurve = inCurveFS.copy(inputCurveObject,
outCurveData, &stat);
PERRORfail(stat, "multiCurve::compute copying curve");
MFnNurbsCurve outCurveFS ( outputCurve );
MPointArray cvs;
double offset = baseOffset * (curveNum+1);
outCurveFS.getCVs ( cvs, MSpace::kWorld );
int numCVs = cvs.length();
for (int i = 0; i < numCVs; i++) {
cvs[i].x += offset;
}
outCurveFS.setCVs ( cvs );
outHandle.set(outCurveData);
}
// Set the builder back into the output array. This statement
// is always required, no matter what constructor was used to
// create the builder.
stat = outputArray.set(builder);
PERRORfail(stat, "multiCurve::compute setting the builder");
// Since we compute all the elements of the array, instead of
// just marking the plug we were asked to compute as clean, mark
// every element of the array as clean to prevent further calls
// to this compute method during this DG evaluation cycle.
stat = outputArray.setAllClean();
PERRORfail(stat, "multiCurve::compute cleaning outputCurves");
} else {
return MS::kUnknownParameter;
}
return stat;
}
bool SargassoNode::creatRestShape(const MObject & m)
{
MStatus stat;
MFnMesh fmesh(m, &stat);
if(!stat) {
MGlobal::displayInfo("val is not mesh");
return false;
}
MObject thisObj = thisMObject();
MPlug pnv(thisObj, atargetNv);
const int restNv = pnv.asInt();
if(restNv != fmesh.numVertices()) {
MGlobal::displayInfo("target nv not match");
return false;
}
MPlug pntriv(thisObj, atargetNt);
const int restNtriv = pntriv.asInt();
MIntArray triangleCounts, triangleVertices;
fmesh.getTriangles(triangleCounts, triangleVertices);
if(restNtriv != triangleVertices.length()) {
MGlobal::displayInfo("target ntri not match");
return false;
}
m_mesh->create(restNv, restNtriv/3);
MPlug prestp(thisObj, atargetRestP);
MObject orestp;
prestp.getValue(orestp);
MFnPointArrayData frestp(orestp);
MPointArray restPArray = frestp.array();
if(restPArray.length() != restNv) {
MGlobal::displayInfo("cached target nv not match");
return false;
}
Vector3F * p = m_mesh->points();
unsigned i=0;
for(;i<restNv;i++) p[i].set(restPArray[i].x, restPArray[i].y, restPArray[i].z);
MPlug presttri(thisObj, atargetTri);
MObject oresttri;
presttri.getValue(oresttri);
MFnIntArrayData fresttri(oresttri);
MIntArray restTriArray = fresttri.array();
if(restTriArray.length() != restNtriv) {
MGlobal::displayInfo("cached target ntri not match");
return false;
}
unsigned * ind = m_mesh->indices();
for(i=0;i<restNtriv;i++) ind[i] = restTriArray[i];
const BoundingBox box = ((AGenericMesh *)m_mesh)->calculateBBox();
AHelper::Info<BoundingBox>("target mesh box", box);
m_diff = new TriangleDifference(m_mesh);
MPlug ptargetbind(thisObj, atargetBind);
MObject otargetbind;
ptargetbind.getValue(otargetbind);
MFnIntArrayData ftargetbind(otargetbind);
MIntArray targetBindArray = ftargetbind.array();
const unsigned nbind = targetBindArray.length();
AHelper::Info<unsigned>("n binded triangles", nbind);
std::vector<unsigned> vbind;
for(i=0;i<nbind;i++) vbind.push_back(targetBindArray[i]);
m_diff->requireQ(vbind);
vbind.clear();
MPlug pobjLocal(thisObj, aobjLocal);
MObject oobjLocal;
pobjLocal.getValue(oobjLocal);
MFnVectorArrayData fobjLocal(oobjLocal);
MVectorArray localPArray = fobjLocal.array();
m_numObjects = localPArray.length();
AHelper::Info<unsigned>("n constrained objects", m_numObjects);
m_localP->create(m_numObjects * 12);
Vector3F * lp = localP();
for(i=0;i<m_numObjects;i++) lp[i].set(localPArray[i].x, localPArray[i].y, localPArray[i].z);
m_triId->create(m_numObjects * 4);
MPlug pobjtri(thisObj, aobjTri);
MObject oobjtri;
pobjtri.getValue(oobjtri);
MFnIntArrayData fobjtri(oobjtri);
MIntArray objtriArray = fobjtri.array();
unsigned * tri = objectTriangleInd();
for(i=0;i<m_numObjects;i++) tri[i] = objtriArray[i];
return true;
}
MStatus CXRayObjectExport::ExportPart(CEditableObject* O, MDagPath& mdagPath, MObject& mComponent)
{
MStatus stat = MS::kSuccess;
MSpace::Space space = MSpace::kWorld;
MFnMesh fnMesh( mdagPath, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in MFnMesh initialization.\n");
return MS::kFailure;
}
MString mdagPathNodeName = fnMesh.name();
MFnDagNode dagNode1(mdagPath);
u32 pc = dagNode1.parentCount();
for(u32 ip=0;ip<pc;++ip)
{
MObject object_parent = dagNode1.parent(ip, &stat);
if(object_parent.hasFn(MFn::kTransform))
{
MFnTransform parent_transform(object_parent,&stat);
if ( MS::kSuccess == stat)
{
mdagPathNodeName = parent_transform.name();
break;
}
}
}
MItMeshPolygon meshPoly( mdagPath, mComponent, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in MItMeshPolygon initialization.\n");
return MS::kFailure;
}
MItMeshVertex vtxIter( mdagPath, mComponent, &stat );
if ( MS::kSuccess != stat) {
fprintf(stderr,"Failure in MItMeshVertex initialization.\n");
return MS::kFailure;
}
// If the shape is instanced then we need to determine which
// instance this path refers to.
//
int instanceNum = 0;
if (mdagPath.isInstanced())
instanceNum = mdagPath.instanceNumber();
// Get a list of all shaders attached to this mesh
MObjectArray rgShaders;
MIntArray texMap;
MStatus status;
status = fnMesh.getConnectedShaders (instanceNum, rgShaders, texMap);
if (status == MStatus::kFailure)
{
Log("! Unable to load shaders for mesh");
return (MStatus::kFailure);
}
XRShaderDataVec xr_data;
{
for ( int i=0; i<(int)rgShaders.length(); i++ ) {
MObject shader = rgShaders[i];
xr_data.push_back(SXRShaderData());
SXRShaderData& D = xr_data.back();
status = parseShader(shader, D);
if (status == MStatus::kFailure) {
status.perror ("Unable to retrieve filename of texture");
continue;
}
}
}
CEditableMesh* MESH = new CEditableMesh(O);
MESH->SetName(mdagPathNodeName.asChar());
O->AppendMesh(MESH);
int objectIdx, length;
// Find i such that objectGroupsTablePtr[i] corresponds to the
// object node pointed to by mdagPath
length = objectNodeNamesArray.length();
{
for( int i=0; i<length; i++ ) {
if( objectNodeNamesArray[i] == mdagPathNodeName ) {
objectIdx = i;
break;
}
}
}
// Reserve uv table
{
VMapVec& _vmaps = MESH->m_VMaps;
_vmaps.resize (1);
st_VMap*& VM = _vmaps.back();
VM = new st_VMap("Texture",vmtUV,false);
}
// write faces
{
using FaceVec = xr_vector<st_Face>;
using FaceIt = FaceVec::iterator;
VMapVec& _vmaps = MESH->m_VMaps;
SurfFaces& _surf_faces = MESH->m_SurfFaces;
VMRefsVec& _vmrefs = MESH->m_VMRefs;
// temp variables
FvectorVec _points;
FaceVec _faces;
U32Vec _sgs;
int f_cnt = fnMesh.numPolygons();
_sgs.reserve (f_cnt);
_faces.reserve (f_cnt);
_vmrefs.reserve (f_cnt*3);
// int lastSmoothingGroup = INITIALIZE_SMOOTHING;
MPointArray rgpt;
MIntArray rgint;
PtLookupMap ptMap;
CSurface* surf = 0;
for ( ; !meshPoly.isDone(); meshPoly.next()){
// Write out the smoothing group that this polygon belongs to
// We only write out the smoothing group if it is different
// from the last polygon.
//
int compIdx = meshPoly.index();
int smoothingGroup = polySmoothingGroups[ compIdx ];
// for each polygon, first setup the reverse mapping
// between object-relative vertex indices and face-relative
// vertex indices
ptMap.clear();
for (int i=0; i<(int)meshPoly.polygonVertexCount(); i++)
ptMap.insert (PtLookupMap::value_type(meshPoly.vertexIndex(i), i) );
// verify polygon zero area
if (meshPoly.zeroArea()){
status = MS::kFailure;
Log("! polygon have zero area:",meshPoly.index());
return status;
}
// verify polygon zero UV area
/* if (meshPoly.zeroUVArea()){
status = MS::kFailure;
Log("! polygon have zero UV area:",meshPoly.index());
return status;
}
*/
// verify polygon has UV information
if (!meshPoly.hasUVs (&status)) {
status = MS::kFailure;
Log("! polygon is missing UV information:",meshPoly.index());
return status;
}
int cTri;
// now iterate through each triangle on this polygon and create a triangle object in our list
status = meshPoly.numTriangles (cTri);
if (!status) {
Log("! can't getting triangle count");
return status;
}
for (int i=0; i < cTri; i++) {
// for each triangle, first get the triangle data
rgpt.clear();//triangle vertices
rgint.clear();//triangle vertex indices
// triangles that come from object are retrieved in world space
status = meshPoly.getTriangle (i, rgpt, rgint, MSpace::kWorld);
if (!status) {
Log("! can't getting triangle for mesh poly");
return status;
}
if ((rgpt.length() != 3) || (rgint.length() != 3)) {
Msg("! 3 points not returned for triangle");
return MS::kFailure;
}
// Write out vertex/uv index information
//
R_ASSERT2(fnMesh.numUVs()>0,"Can't find uvmaps.");
_faces.push_back(st_Face());
_sgs.push_back(smoothingGroup);
//set_smooth
set_smoth_flags( _sgs.back(), rgint );
st_Face& f_it = _faces.back();
for ( int vtx=0; vtx<3; vtx++ ) {
// get face-relative vertex
PtLookupMap::iterator mapIt;
int vtLocal, vtUV;
int vt = rgint[vtx];
mapIt = ptMap.find(vt);
Fvector2 uv;
if (mapIt == ptMap.end()){
Msg("! Can't find local index.");
return MS::kFailure;
}
vtLocal = (*mapIt).second;
status = meshPoly.getUVIndex (vtLocal, vtUV, uv.x, uv.y);
if (!status) {
Msg("! error getting UV Index for local vertex '%d' and object vertex '%d'",vtLocal,vt);
return status;
}
// flip v-part
uv.y=1.f-uv.y;
f_it.pv[2-vtx].pindex = AppendVertex(_points,rgpt[vtx]);
f_it.pv[2-vtx].vmref = _vmrefs.size();
_vmrefs.push_back (st_VMapPtLst());
st_VMapPtLst& vm_lst = _vmrefs.back();
vm_lst.count = 1;
vm_lst.pts = xr_alloc<st_VMapPt>(vm_lst.count);
vm_lst.pts[0].vmap_index= 0;
vm_lst.pts[0].index = AppendUV(_vmaps.back(),uv);
}
// out face material
int iTexture = texMap[meshPoly.index()];
if (iTexture<0)
xrDebug::Fatal(DEBUG_INFO,"Can't find material for polygon: %d",meshPoly.index());
SXRShaderData& D= xr_data[iTexture];
int compIdx = meshPoly.index();
surf = MESH->Parent()->CreateSurface(getMaterialName(mdagPath, compIdx, objectIdx),D);
if (!surf) return MStatus::kFailure;
_surf_faces[surf].push_back(_faces.size()-1);
}
}
{
// copy from temp
MESH->m_VertCount = _points.size();
MESH->m_FaceCount = _faces.size();
MESH->m_Vertices = xr_alloc<Fvector>(MESH->m_VertCount);
Memory.mem_copy (MESH->m_Vertices,&*_points.begin(),MESH->m_VertCount*sizeof(Fvector));
MESH->m_Faces = xr_alloc<st_Face>(MESH->m_FaceCount);
Memory.mem_copy (MESH->m_Faces,&*_faces.begin(),MESH->m_FaceCount*sizeof(st_Face));
MESH->m_SmoothGroups = xr_alloc<u32>(MESH->m_FaceCount);
Memory.mem_copy (MESH->m_SmoothGroups,&*_sgs.begin(),MESH->m_FaceCount*sizeof(u32));
MESH->RecomputeBBox ();
}
if ((MESH->GetVertexCount()<4)||(MESH->GetFaceCount()<2))
{
Log ("! Invalid mesh: '%s'. Faces<2 or Verts<4",*MESH->Name());
return MS::kFailure;
}
}
return stat;
}
MStatus finalproject::compute(const MPlug& plug, MDataBlock& data)
{
// do this if we are using an OpenMP implementation that is not the same as Maya's.
// Even if it is the same, it does no harm to make this call.
MThreadUtils::syncNumOpenMPThreads();
MStatus status = MStatus::kUnknownParameter;
if (plug.attribute() != outputGeom) {
return status;
}
unsigned int index = plug.logicalIndex();
MObject thisNode = this->thisMObject();
// get input value
MPlug inPlug(thisNode,input);
inPlug.selectAncestorLogicalIndex(index,input);
MDataHandle hInput = data.inputValue(inPlug, &status);
MCheckStatus(status, "ERROR getting input mesh\n");
// get the input geometry
MDataHandle inputData = hInput.child(inputGeom);
if (inputData.type() != MFnData::kMesh) {
printf("Incorrect input geometry type\n");
return MStatus::kFailure;
}
// get the input groupId - ignored for now...
MDataHandle hGroup = inputData.child(groupId);
unsigned int groupId = hGroup.asLong();
// get deforming mesh
MDataHandle deformData = data.inputValue(deformingMesh, &status);
MCheckStatus(status, "ERROR getting deforming mesh\n");
if (deformData.type() != MFnData::kMesh) {
printf("Incorrect deformer geometry type %d\n", deformData.type());
return MStatus::kFailure;
}
MDataHandle offloadData = data.inputValue(offload, &status);
//gathers world space positions of the object and the magnet
MObject dSurf = deformData.asMeshTransformed();
MObject iSurf = inputData.asMeshTransformed();
MFnMesh fnDeformingMesh, fnInputMesh;
fnDeformingMesh.setObject( dSurf ) ;
fnInputMesh.setObject( iSurf ) ;
MDataHandle outputData = data.outputValue(plug);
outputData.copy(inputData);
if (outputData.type() != MFnData::kMesh) {
printf("Incorrect output mesh type\n");
return MStatus::kFailure;
}
MItGeometry iter(outputData, groupId, false);
// get all points at once. Faster to query, and also better for
// threading than using iterator
MPointArray objVerts;
iter.allPositions(objVerts);
int objNumPoints = objVerts.length();
MPointArray magVerts, tempverts;
fnDeformingMesh.getPoints(magVerts);
fnInputMesh.getPoints(tempverts);
int magNumPoints = magVerts.length();
double min = DBL_MAX, max = -DBL_MAX;
//finds min and max z-coordinate values to determine middle point (choice of z-axis was ours)
for (int i = 0; i < magNumPoints; i++) {
min = magVerts[i].z < min ? magVerts[i].z : min;
max = magVerts[i].z > max ? magVerts[i].z : max;
}
double middle = (min + max) / 2;
double polarity[magNumPoints];
//assigns polarity based on middle point of mesh
for (int i = 0; i < magNumPoints; i++) {
polarity[i] = magVerts[i].z > middle ? max / magVerts[i].z : -min / magVerts[i].z;
}
double* objdVerts = (double *)malloc(sizeof(double) * objNumPoints * 3);
double* magdVerts = (double *)malloc(sizeof(double) * magNumPoints * 3);
//creates handles to use attribute data
MDataHandle vecX = data.inputValue(transX, &status);
MDataHandle vecY = data.inputValue(transY, &status);
MDataHandle vecZ = data.inputValue(transZ, &status);
//gathers previously stored coordinates of the center of the object
double moveX = vecX.asFloat();
double moveY = vecY.asFloat();
double moveZ = vecZ.asFloat();
//translates object based on the position stored in the attribute values
for (int i=0; i<objNumPoints; i++) {
objdVerts[i * 3] = tempverts[i].x + moveX;
objdVerts[i * 3 + 1] = tempverts[i].y + moveY;
objdVerts[i * 3 + 2] = tempverts[i].z + moveZ;
}
for (int i=0; i<magNumPoints; i++) {
magdVerts[i * 3] = magVerts[i].x;
magdVerts[i * 3 + 1] = magVerts[i].y;
magdVerts[i * 3 + 2] = magVerts[i].z;
}
double teslaData = data.inputValue(tesla, &status).asDouble();
MDataHandle posiData = data.inputValue(positivelycharged, &status);
double pivot[6] = {DBL_MAX, -DBL_MAX, DBL_MAX, -DBL_MAX, DBL_MAX, -DBL_MAX};
//finds the pivot point of the object in world space prior to being affected by the magnet
for (int i = 0; i < tempverts.length(); i++) {
pivot[0] = tempverts[i].x < pivot[0] ? tempverts[i].x : pivot[0];
pivot[1] = tempverts[i].x > pivot[1] ? tempverts[i].x : pivot[1];
pivot[2] = tempverts[i].y < pivot[2] ? tempverts[i].y : pivot[2];
pivot[3] = tempverts[i].y > pivot[3] ? tempverts[i].y : pivot[3];
pivot[4] = tempverts[i].z < pivot[4] ? tempverts[i].z : pivot[4];
pivot[5] = tempverts[i].z > pivot[5] ? tempverts[i].z : pivot[5];
}
MTimer timer; timer.beginTimer();
//main function call
magnetForce(magNumPoints, objNumPoints, teslaData, magdVerts,
objdVerts, polarity, posiData.asBool(), offloadData.asBool());
timer.endTimer(); printf("Runtime for threaded loop %f\n", timer.elapsedTime());
for (int i=0; i<objNumPoints; i++) {
objVerts[i].x = objdVerts[i * 3 + 0];
objVerts[i].y = objdVerts[i * 3 + 1];
objVerts[i].z = objdVerts[i * 3 + 2];
}
//finds the pivot point of object in world space after being affected by the magnet
double objCenter[6] = {DBL_MAX, -DBL_MAX, DBL_MAX, -DBL_MAX, DBL_MAX, -DBL_MAX};
for (int i = 0; i < tempverts.length(); i++) {
objCenter[0] = objVerts[i].x < objCenter[0] ? objVerts[i].x : objCenter[0];
objCenter[1] = objVerts[i].x > objCenter[1] ? objVerts[i].x : objCenter[1];
objCenter[2] = objVerts[i].y < objCenter[2] ? objVerts[i].y : objCenter[2];
objCenter[3] = objVerts[i].y > objCenter[3] ? objVerts[i].y : objCenter[3];
objCenter[4] = objVerts[i].z < objCenter[4] ? objVerts[i].z : objCenter[4];
objCenter[5] = objVerts[i].z > objCenter[5] ? objVerts[i].z : objCenter[5];
}
//creates vector based on the two calculated pivot points
moveX = (objCenter[0] + objCenter[1]) / 2 - (pivot[0] + pivot[1]) / 2;
moveY = (objCenter[2] + objCenter[3]) / 2 - (pivot[2] + pivot[3]) / 2;
moveZ = (objCenter[4] + objCenter[5]) / 2 - (pivot[4] + pivot[5]) / 2;
//stores pivot vector for next computation
if (teslaData) {
vecX.setFloat(moveX);
vecY.setFloat(moveY);
vecZ.setFloat(moveZ);
}
// write values back onto output using fast set method on iterator
iter.setAllPositions(objVerts, MSpace::kWorld);
free(objdVerts);
free(magdVerts);
return status;
}
