void TestDeformer::_initVertMapping_on_one_mesh( MObject &driver_mesh, MArrayDataBuilder &vertMapOutArrayBuilder, const MPointArray& allPts) { MStatus status; // use vertIter to walk through the vertex of a driver mesh MItMeshVertex vertIter( driver_mesh, &status ); CHECK_MSTATUS(status); CHECK_MSTATUS(vertIter.reset()); // for each vertex of the driver mesh while( !vertIter.isDone(&status) ) { CHECK_MSTATUS(status); // get vertex position MPoint driver_pt; driver_pt = vertIter.position( MSpace::kWorld, &status ); CHECK_MSTATUS(status); //get the closest driven point int closest_pt_index = getClosestPt( driver_pt, allPts );//which one is the closest point(in allPts array) to driver_pt //add the closest driven point MDataHandle snapDataHnd = vertMapOutArrayBuilder.addElement( closest_pt_index, &status ); CHECK_MSTATUS( status ); snapDataHnd.setInt( vertIter.index() ); snapDataHnd.setClean(); CHECK_MSTATUS(vertIter.next()); } }
size_t LineStripGeometry::addLineStrip(const Core::Array<Vector3f> &vertices, const Core::Array<Vector3ub> &rgb, float lineWidth) { if (vertices.empty() || vertices.size() != rgb.size()) return InvalidIndex; size_t result = m_lineStarts.size(); m_lineStarts.push_back(static_cast<unsigned int>(m_vertices.size())); m_lineWidths.push_back(lineWidth); Array<Vector3ub>::const_iterator colorIter(rgb.begin()); Array<Vector3f>::const_iterator vertIter(vertices.begin()); Array<Vector3f>::const_iterator vertEnd(vertices.end()); m_vertices.reserve(m_vertices.size() + vertices.size()); Vector4ub tmpColor(0, 0, 0, m_opacity); while (vertIter != vertEnd) { tmpColor.head<3>() = *(colorIter++); m_vertices.push_back(PackedVertex(*(vertIter++), tmpColor)); } m_dirty = true; return result; }
void VMesh::update() { MStatus status; MItMeshVertex vertIter(pgrow, &status); MPoint cv; for( int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { cv = vertIter.position(MSpace::kWorld); m_v_buf[i] = m_p_buf[i] - cv; m_p_buf[i] = cv; } }
void VMesh::init() { m_p_buf.clear(); m_v_buf.clear(); MStatus status; MItMeshVertex vertIter(pgrow, &status); for( int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { m_p_buf.append( vertIter.position(MSpace::kWorld) ); } m_v_buf.setLength(m_p_buf.length()); for( int i=0; i<m_v_buf.length(); i++ ) { m_v_buf[i] = MVector(0,0,0); } }
static MStatus twistPolygon(MDagPath& objectPath, MObject& component) { MStatus status; MPoint center; MVector toCenter( -center.x, 0.0, -center.y ); double rotFactor = 0.5; MItMeshVertex vertIter( objectPath, component, &status ); if ( status ) { // We successfully created a polygon vertex iterator // for ( ; !vertIter.isDone(); vertIter.next() ) { // Get the location of the vertex // MPoint pnt = vertIter.position( MSpace::kWorld ); pnt = pnt + toCenter; // Calculate rotation in radians about the y-axis // double rotation = pnt.y * rotFactor; MMatrix rotMatrix; // Set matrix to a rotation about the y axis // rotMatrix(0,0) = cos( rotation ); rotMatrix(0,2) = sin( rotation ); rotMatrix(2,0) = -sin( rotation ); rotMatrix(2,2) = cos( rotation ); pnt = ( pnt * rotMatrix ) - toCenter; status = vertIter.setPosition( pnt, MSpace::kWorld ); if ( !status ) { status.perror("MItMeshVertex::MItMeshVertex"); break; } } // Tell maya to redraw the surface with all of our changes // vertIter.updateSurface(); } else status.perror("MItSurfaceCV::MItSurfaceCV"); return status; }
//--------------------------------------------------------------------- void componentConverter::getContainedEdges( MIntArray& vtxIDs, MIntArray& result ) //--------------------------------------------------------------------- { // result.clear(); MFnMesh meshFn(mesh); MItMeshVertex vertIter(mesh); BPT_BA searchArray(meshFn.numEdges()); MIntArray conEdges; unsigned int l = vtxIDs.length(); int indexValue; for(unsigned i = 0;i < l;i++) { vertIter.setIndex(vtxIDs[i],tmp); vertIter.getConnectedEdges(conEdges); for(unsigned int x = 0; x < conEdges.length(); x++) { indexValue = conEdges[x]; if( searchArray[indexValue] ) { result.append(indexValue); } else searchArray.setBitTrue(indexValue); } } }
void VMesh::getBBox(MPoint& corner1, MPoint& corner2) { if(!has_mesh) return; corner1 = MPoint(10e6, 10e6, 10e6); corner2 = MPoint(-10e6, -10e6, -10e6); MStatus status; MItMeshVertex vertIter(pgrow, &status); MPoint S; for(; !vertIter.isDone(); vertIter.next()) { S = vertIter.position(MSpace::kWorld); if( S.x < corner1.x ) corner1.x = S.x; if( S.y < corner1.y ) corner1.y = S.y; if( S.z < corner1.z ) corner1.z = S.z; if( S.x > corner2.x ) corner2.x = S.x; if( S.y > corner2.y ) corner2.y = S.y; if( S.z > corner2.z ) corner2.z = S.z; } }
MStatus BPTfty_NH::doIt() { SPEED(" MACHE NON- TOPO - CHANGE AKTION "); switch(mode) { case 1: { //erstmal alle Edges holen MIntArray allEdges; MIntArray edgeLoops; //enthält die fertige EL auswahl zum anwählen // cout<<"MAIN: "<<"hole alle edgeIndices"<<endl; getAllEdgeIndices(allEdges); // cout<<"MAIN: "<<"finde edgeLoops"<<endl; findEdgeLoops(allEdges,edgeLoops); // cout<<"MAIN: "<<"Wähle Komponenten an"<<endl; selectComponents(edgeLoops,"edges"); switchComponentModeIfNeeded(); break; } //edgeRing auswählen case 2: { MIntArray allEdges; MIntArray edgeRings; // cout<<"MAIN: "<<"hole alle edgeIndices"<<endl; getAllEdgeIndices(allEdges); // cout<<"MAIN: "<<"finde edgeRings"<<endl; findEdgeRings(allEdges,edgeRings); // cout<<"MAIN: "<<"Wähle Komponenten an"<<endl; selectComponents(edgeRings,"edges"); switchComponentModeIfNeeded(); break; } //boundary erstellen case 3: { MStatus status; MItMeshPolygon polyIter(fMesh,&status); convertAllToFaces(polyIDs,vertIDs,edgeIDs); INVIS(if(status == MS::kFailure)) INVIS(cout <<"FEHLER, fMesh ist nicht angekommen in fty"<<endl;) MIntArray EdgeTmp; //invertSelection(polyIDs, polyIter.count(),inverted); faceGetContainedEdgeIndices(polyIDs, EdgeTmp); //faceGetContainedEdgeIndices(inverted, Edge2Tmp); MIntArray outline; helper.memoryPrune(EdgeTmp,outline); //outline finalisieren durch : allEdges - inner edges (in outline momentan) helper.memoryArrayRemove(EdgeTmp,outline); selectComponents(EdgeTmp,"edges"); //selectComponents(memoryMatch(EdgeTmp,Edge2Tmp),"edges"); switchComponentModeIfNeeded(); break; } case 7: { MPRINT("WILL GROWEN") SPEED(" GROWING "); MItMeshVertex vertIter(fMesh); MItMeshPolygon polyIter(fMesh); MItMeshEdge edgeIter(fMesh); if(vertIDs.length() != 0) { growVtxSelection(vertIDs,vertIter,polyIter, true); } else if(edgeIDs.length() != 0) { growEdgeSelection(edgeIDs,edgeIter,0); } else if(polyIDs.length() != 0) {//jetzt muss faceIDs an der reihe sein, da ja eine auswahl vorhanden sein muss, wenn er in fty ist //->diese auswahl koennen aber auch UVs sein growFaceSelection(polyIDs,edgeIter,polyIter.count()); } break; } case 8: { MPRINT("will shrinken") SPEED(" SHRINKING "); MItMeshVertex vertIter(fMesh); MItMeshPolygon polyIter(fMesh); MItMeshEdge edgeIter(fMesh); MIntArray allVtx; if(vertIDs.length() != 0) { schrinkVtxSelection(vertIDs,vertIter,polyIter, true); } else if(edgeIDs.length() != 0) { shrinkEdgeSelection(edgeIDs,edgeIter,polyIter.count()); } else if(polyIDs.length() != 0) {//jetzt muss faceIDs an der reihe sein, da ja eine auswahl vorhanden sein muss, wenn er in fty ist shrinkFaceSelection(polyIDs,edgeIter,polyIter.count()); } break; } }
//----------------------------------------------------------------------- void visualizeMeshNode::draw( M3dView & view, const MDagPath & path, M3dView::DisplayStyle style, M3dView::DisplayStatus status ) //----------------------------------------------------------------------- { // cout << "cvColor::draw\n"; MStatus stat; MObject thisNode = thisMObject(); MPlug plug(thisNode, drawingEnabled) ; //soll überhaupt etwas gezeichnet werden? bool doDraw; plug.getValue(doDraw); if (!doDraw) return; //Okay, also die restlichen Daten extrahieren //Lokale Variablen float fPointSize; //PointSize holen plug.setAttribute(pointSize); plug.getValue(fPointSize); bool allowBeautyMode = true; // Jetzt das Plug auslesen um herauszufinden, ob man schön zeichnen darf oder nicht // TODO /* // Test HDC dc; dc = view.deviceContext(); PIXELFORMATDESCRIPTOR pfd; int iPixelFormat; // get the current pixel format index iPixelFormat = GetPixelFormat(dc); // obtain a detailed description of that pixel format int returnVal = DescribePixelFormat(dc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd); //cout<<pfd.nSize<<endl; //cout<<sizeof(PIXELFORMATDESCRIPTOR)<<endl; cout<<pfd.iPixelType<<" = ReturnVal"<<endl; cout<<returnVal<<" = ReturnVal"<<endl; cout<<iPixelFormat<<" = PixelFormat"<<endl; */ //Farbe holen -> Diese Schreibweise hat den (hier unbedeutenden) Vorteil, dass Objekte automatisch zerstört werden - sie existieren nur innerhalb der Klammern { MColor tmpColor; plug.setAttribute(vtxColorObj); MObject colorObj; plug.getValue(colorObj); MFnNumericData numDataFn(colorObj); numDataFn.getData(tmpColor.r, tmpColor.g, tmpColor.b); //wenn sich die Farben verändert haben, dann die liste updaten - und alles neuzeichnen if(tmpColor != vtxColor) { vtxColor = tmpColor; listNeedsUpdate = true; } plug.setAttribute(vtxColorObj2); plug.getValue(colorObj); numDataFn.setObject(colorObj); numDataFn.getData(tmpColor.r, tmpColor.g, tmpColor.b); if(tmpColor != vtxColor2) { vtxColor2 = tmpColor; listNeedsUpdate = true; } } //jetzt noch die Node ermuntern, die comuteMethode aufzurufen plug.setAttribute(vtxLocations); bool dummy; plug.getValue(dummy); //vtxWeights müssen gesetzt sein if(vtxWeightArray.length() == 0) return; //MeshData holen plug.setAttribute(inputMesh); MObject meshData; plug.getValue(meshData); visualizeMeshNode::meshStatus mStat = getMeshStatus(); // Wenn sich der Anezigstatus des Meshes ändert, dann muss die DisplayList neu erstellt werden // Nur um den PolygonOffset zu aktualisieren if(mStat != lastStat) { lastStat = mStat; listNeedsUpdate; } //if( mStat == kNone) // Nichts zeichnen, wenn nix selected // return; view.beginGL(); // view.beginOverlayDrawing(); //Im PointMode werden PointsGezeigt, und wenn das Objekt selected ist (dann funzt shaded nicht mehr) if( style == M3dView::kPoints || (mStat == kSelected ) || wasInCompute || !allowBeautyMode) { //VertiIter initialisieren MItMeshVertex vertIter(meshData); drawPoints(vertIter, fPointSize); // Das updaten der DisplayLists ist zu langsam, weshalb automatisch vtxMode genommen wird wasInCompute = false; } else {//in diesem Modus werden Faces gezeichnet, mit entsprechenden alphawerten als zeichen ihrer Farbe MItMeshPolygon polyIter(meshData); MItMeshVertex vertIter(meshData); //Die displayList prüfen if( (listNeedsUpdate & !wasInCompute) || lastDMode != style ) {//neue Liste erzeugen - wird eigentlich nur einmal pro drawAktion gemacht lastDMode = style; if( list != 450000 ) //alte liste löschen glDeleteLists(list, 1); list = glGenLists(1); if(glIsList(list)) { listNeedsUpdate = wasInCompute = false; //####################### //NEUE LISTE AUFZEICHNEN //####################### glNewList(list, GL_COMPILE_AND_EXECUTE); //drawShaded(polyIter, vertIter, style, mStat); drawShadedTriangles(polyIter, vertIter, style, mStat); //####################### //ENDE LISTE AUFZEICHNEN //####################### glEndList(); } else { //fehler, also alles ohne displayList zeichnen //drawShaded(polyIter, vertIter, style, mStat); drawShadedTriangles(polyIter, vertIter, style, mStat); } } else { glCallList(list); wasInCompute = false; } } view.endGL(); // view.endOverlayDrawing(); }
void VMesh::draw() { if(!has_mesh) return; MStatus status; MFnMesh meshFn(pgrow, &status ); MItMeshVertex vertIter(pgrow, &status); MPoint S; MVector N, tang, ttang, binormal, dir, hair_up; MColor Cscale, Cerect, Crotate, Ccurl; float rot; MATRIX44F hair_space; MString setScale("fb_scale"); MString setErect("fb_erect"); MString setRotate("fb_rotate"); MString setCurl("fb_curl"); MIntArray conn_face; glBegin(GL_LINES); for( int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { //S = vertIter.position(MSpace::kWorld); //glVertex3f(S.x, S.y, S.z); vertIter.getNormal(N, MSpace::kWorld); N.normalize(); vertIter.getColor(Cscale, &setScale); vertIter.getColor(Cerect, &setErect); vertIter.getColor(Crotate, &setRotate); vertIter.getColor(Ccurl, &setCurl); vertIter.getConnectedFaces(conn_face); tang = MVector(0,0,0); for(int j=0; j<conn_face.length(); j++) { meshFn.getFaceVertexTangent (conn_face[j], i, ttang, MSpace::kWorld); ttang.normalize(); tang += ttang; } tang /= conn_face.length(); conn_face.clear(); tang.normalize(); tang = N^tang; tang.normalize(); binormal = N^tang; if(Crotate.r<0.5) { rot = (0.5 - Crotate.r)*2; tang = tang + (binormal-tang)*rot; tang.normalize(); binormal = N^tang; } else { rot = (Crotate.r-0.5)*2; tang = tang + (binormal*-1-tang)*rot; tang.normalize(); binormal = N^tang; } dir = tang + (N - tang)*Cerect.r; dir.normalize(); //S = S+dir*Cscale.r*m_scale; //glVertex3f(S.x, S.y, S.z); hair_up = dir^binormal; hair_space.setIdentity(); hair_space.setOrientations(XYZ(binormal.x, binormal.y, binormal.z), XYZ(hair_up.x, hair_up.y, hair_up.z), XYZ(dir.x, dir.y, dir.z)); S = vertIter.position(MSpace::kWorld); hair_space.setTranslation(XYZ(S.x, S.y, S.z)); fb->create(Cscale.r*m_scale, 0, Cscale.r*m_scale*(Ccurl.r-0.5)*2); XYZ pw; for(int j=0; j<NUMBENDSEG; j++) { fb->getPoint(j, pw); hair_space.transform(pw); glVertex3f(pw.x, pw.y, pw.z); fb->getPoint(j+1, pw); hair_space.transform(pw); glVertex3f(pw.x, pw.y, pw.z); } } glEnd(); }
void VMesh::save(const char* filename, int isStart) { MStatus status; MFnMesh meshFn(pgrow, &status ); MItMeshPolygon faceIter( pgrow, &status ); MItMeshVertex vertIter(pgrow, &status); int m_n_triangle=0, m_n_vertex=0; MIntArray m_vertex_id; MFloatArray facevarying_s, facevarying_t; MPointArray m_vertex_p; MVectorArray m_vertex_n, m_vertex_t; meshFn.getPoints(m_vertex_p, MSpace::kWorld); float auv[2]; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); m_n_triangle += vexlist.length() - 2; for( unsigned int i=1; i < vexlist.length()-1; i++ ) { m_vertex_id.append(vexlist[0]); m_vertex_id.append(vexlist[i]); m_vertex_id.append(vexlist[i+1]); faceIter.getUV(0, auv); facevarying_s.append(auv[0]); facevarying_t.append(auv[1]); faceIter.getUV(i, auv); facevarying_s.append(auv[0]); facevarying_t.append(auv[1]); faceIter.getUV(i+1, auv); facevarying_s.append(auv[0]); facevarying_t.append(auv[1]); } } XYZ* pbinormal = new XYZ[meshFn.numVertices()]; XYZ* pv = new XYZ[meshFn.numVertices()]; float* pscale = new float[meshFn.numVertices()]; float* curlarray = new float[meshFn.numVertices()]; float* widtharray = new float[meshFn.numVertices()]; float* densityarray = new float[meshFn.numVertices()]; MVector tnor, tang, ttang, binormal, dir, hair_up, hair_v; MPoint tpos; MColor Cscale, Cerect, Crotate, Cstiff, Ccurl, Cwidth, Cdensity; float rot; MATRIX44F hair_space, hair_space_inv; MString setScale("fb_scale"); MString setErect("fb_erect"); MString setRotate("fb_rotate"); MString setStiff("fb_stiffness"); MString setCurl("fb_curl"); MString setWidth("fb_width"); MString setDensity("fb_density"); MIntArray conn_face; XYZ dP; vertIter.reset(); for( int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { vertIter.getConnectedFaces(conn_face); vertIter.getNormal(tnor, MSpace::kWorld); tnor.normalize(); m_vertex_n.append(tnor); vertIter.getColor(Cscale, &setScale); vertIter.getColor(Cerect, &setErect); vertIter.getColor(Crotate, &setRotate); vertIter.getColor(Cstiff, &setStiff); vertIter.getColor(Ccurl, &setCurl); vertIter.getColor(Cwidth, &setWidth); vertIter.getColor(Cdensity, &setDensity); if(Cstiff.r < 0.1) Cstiff.r = 0.1; tang = MVector(0,0,0); for(int j=0; j<conn_face.length(); j++) { meshFn.getFaceVertexTangent (conn_face[j], i, ttang, MSpace::kWorld); ttang.normalize(); tang += ttang; } tang /= conn_face.length(); conn_face.clear(); tang.normalize(); tang = tnor^tang; tang.normalize(); binormal = tnor^tang; if(Crotate.r<0.5) { rot = (0.5 - Crotate.r)*2; tang = tang + (binormal-tang)*rot; tang.normalize(); binormal = tnor^tang; } else { rot = (Crotate.r-0.5)*2; tang = tang + (binormal*-1-tang)*rot; tang.normalize(); binormal = tnor^tang; } pbinormal[i] = XYZ(binormal.x, binormal.y, binormal.z); pscale[i] = Cscale.r * m_scale; dir = tang + (tnor - tang)*Cerect.r; dir.normalize(); m_vertex_t.append(dir); hair_up = dir^binormal; //pup[i] = XYZ(hair_up.x, hair_up.y, hair_up.z); hair_space.setIdentity(); hair_space.setOrientations(XYZ(binormal.x, binormal.y, binormal.z), XYZ(hair_up.x, hair_up.y, hair_up.z), XYZ(dir.x, dir.y, dir.z)); hair_space.setTranslation(XYZ(m_vertex_p[i].x, m_vertex_p[i].y, m_vertex_p[i].z)); hair_space_inv = hair_space; hair_space_inv.inverse(); hair_v = getVelocity(i); dP = XYZ(hair_v.x, hair_v.y, hair_v.z); hair_space_inv.transformAsNormal(dP); if(dP.y<0) dP.y = 0; dP *= m_wind/Cstiff.r; pv[i] = dP; curlarray[i] = Ccurl.r; widtharray[i] = Cwidth.r; densityarray[i] = Cdensity.r; } m_n_vertex = meshFn.numVertices(); FXMLTriangleMap fmap; fmap.beginMap(filename); // write vertex id string static_path(filename); zGlobal::cutByFirstDot(static_path); static_path.append(".hbs"); if(isStart == 1) { fmap.staticBegin(static_path.c_str(), m_n_triangle); int* id_list = new int[m_n_triangle*3]; for(int i=0; i<m_n_triangle*3; i++) id_list[i] = m_vertex_id[i]; fmap.addVertexId(m_n_triangle*3, id_list); delete[] id_list; float* sarray = new float[m_n_triangle*3]; float* tarray = new float[m_n_triangle*3]; for(int i=0; i<m_n_triangle*3; i++) { sarray[i] = facevarying_s[i]; tarray[i] = facevarying_t[i]; } fmap.addStaticFloatArray("root_s", m_n_triangle*3, sarray); fmap.addStaticFloatArray("root_t", m_n_triangle*3, tarray); delete[] sarray; delete[] tarray; XYZ* recpref = new XYZ[m_n_vertex]; for(int i=0; i<m_n_vertex; i++) recpref[i] = XYZ(m_vertex_p[i].x, m_vertex_p[i].y, m_vertex_p[i].z); fmap.addPref(m_n_vertex, recpref); delete[] recpref; fmap.addStaticFloatArray("scale", m_n_vertex, pscale); fmap.addStaticFloatArray("curl", m_n_vertex, curlarray); fmap.addStaticFloatArray("width", m_n_vertex, widtharray); fmap.addStaticFloatArray("density", m_n_vertex, densityarray); fmap.staticEnd(); } else { fmap.staticBeginNoWrite(static_path.c_str(), m_n_triangle); fmap.addVertexId(m_n_triangle*3); fmap.addStaticFloatArray("root_s", m_n_triangle*3); fmap.addStaticFloatArray("root_t", m_n_triangle*3); fmap.addPref(m_n_vertex); fmap.addStaticFloatArray("scale", m_n_vertex); fmap.addStaticFloatArray("curl", m_n_vertex); fmap.addStaticFloatArray("width", m_n_vertex); fmap.addStaticFloatArray("density", m_n_vertex); fmap.staticEndNoWrite(); } delete[] curlarray; delete[] widtharray; delete[] densityarray; // write vertex p string dynamic_path(filename); zGlobal::cutByLastDot(dynamic_path); dynamic_path.append(".hbd"); fmap.dynamicBegin(dynamic_path.c_str()); XYZ* recp = new XYZ[m_n_vertex]; for(int i=0; i<m_n_vertex; i++) recp[i] = XYZ(m_vertex_p[i].x, m_vertex_p[i].y, m_vertex_p[i].z); fmap.addP(m_n_vertex, recp); delete[] recp; // write vertex n XYZ* recn = new XYZ[m_n_vertex]; for(int i=0; i<m_n_vertex; i++) recn[i] = XYZ(m_vertex_n[i].x, m_vertex_n[i].y, m_vertex_n[i].z); fmap.addN(m_n_vertex, recn); delete[] recn; // write veretx tangent XYZ* rect = new XYZ[m_n_vertex]; for(int i=0; i<m_n_vertex; i++) rect[i] = XYZ(m_vertex_t[i].x, m_vertex_t[i].y, m_vertex_t[i].z); fmap.addDynamicVectorArray("direction", m_n_vertex, rect); delete[] rect; // write vertex binormal fmap.addDynamicVectorArray("binormal", m_n_vertex, pbinormal); delete[] pbinormal; // write vertex up // fmap.addDynamicVectorArray("up", m_n_vertex, pup); // delete[] pup; // write vertex wind fmap.addDynamicVectorArray("wind", m_n_vertex, pv); delete[] pv; // write bound box MPoint corner_l, corner_h; getBBox(corner_l, corner_h); fmap.addBBox(corner_l.x, corner_l.y, corner_l.z, corner_h.x, corner_h.y, corner_h.z); fmap.dynamicEnd(); fmap.endMap(filename); char info[256]; sprintf(info, "hairBase writes %s", filename); MGlobal::displayInfo ( info ); m_vertex_id.clear(); m_vertex_p.clear(); m_vertex_n.clear(); m_vertex_t.clear(); delete[] pscale; }
MObject VMesh::createFeather() { MStatus stat; MFnMeshData dataCreator; MObject outMeshData = dataCreator.create(&stat); int numVertex = 0; int numPolygon = 0; MPointArray vertexArray; MFloatArray uArray, vArray; MIntArray polygonCounts, polygonConnects, polygonUVs; MFnMesh meshFn(pgrow, &stat); MItMeshVertex vertIter(pgrow, &stat); MItMeshPolygon faceIter(pgrow, &stat); MPoint S; MVector N, tang, ttang, binormal, dir, hair_up; MColor Cscale, Cerect, Crotate, Ccurl, Cwidth; float rot, lengreal; MATRIX44F hair_space; MString setScale("fb_scale"); MString setErect("fb_erect"); MString setRotate("fb_rotate"); MString setCurl("fb_curl"); MString setWidth("fb_width"); MIntArray conn_face; for( int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { if(vertIter.onBoundary()) continue; vertIter.getNormal(N, MSpace::kWorld); N.normalize(); vertIter.getColor(Cscale, &setScale); vertIter.getColor(Cerect, &setErect); vertIter.getColor(Crotate, &setRotate); vertIter.getColor(Ccurl, &setCurl); vertIter.getColor(Cwidth, &setWidth); vertIter.getConnectedFaces(conn_face); tang = MVector(0,0,0); for(int j=0; j<conn_face.length(); j++) { meshFn.getFaceVertexTangent (conn_face[j], i, ttang, MSpace::kWorld); ttang.normalize(); tang += ttang; } tang /= conn_face.length(); conn_face.clear(); tang.normalize(); tang = N^tang; tang.normalize(); binormal = N^tang; if(Crotate.r<0.5) { rot = (0.5 - Crotate.r)*2; tang = tang + (binormal-tang)*rot; tang.normalize(); binormal = N^tang; } else { rot = (Crotate.r-0.5)*2; tang = tang + (binormal*-1-tang)*rot; tang.normalize(); binormal = N^tang; } dir = tang + (N - tang)*Cerect.r; dir.normalize(); //S = S+dir*Cscale.r*m_scale; //glVertex3f(S.x, S.y, S.z); hair_up = dir^binormal; hair_space.setIdentity(); hair_space.setOrientations(XYZ(binormal.x, binormal.y, binormal.z), XYZ(hair_up.x, hair_up.y, hair_up.z), XYZ(dir.x, dir.y, dir.z)); S = vertIter.position(MSpace::kWorld); hair_space.setTranslation(XYZ(S.x, S.y, S.z)); lengreal = Cscale.r*m_scale; fb->create(lengreal, 0, lengreal*(Ccurl.r-0.5)*2); XYZ pw; MPoint pvx; MPoint pright = S + binormal*Cwidth.r*m_width*lengreal; MPoint pleft = S - binormal*Cwidth.r*m_width*lengreal; MPoint phit; int polyhit; meshFn.getClosestPoint (pright, phit, MSpace::kObject, &polyhit); MVector topright = phit - S; topright.normalize(); topright *= Cwidth.r*m_width*lengreal; meshFn.getClosestPoint (pleft, phit, MSpace::kObject, &polyhit); MVector topleft = phit - S; topleft.normalize(); topleft *= Cwidth.r*m_width*lengreal; //tws_binormal = binormal*cos(0.2) + hair_up*sin(0.2); for(int j=0; j<NUMBENDSEG+1; j++) { fb->getPoint(j, pw); hair_space.transform(pw); pvx = MPoint(pw.x, pw.y, pw.z) + topleft;//- tws_binormal*Cwidth.r*m_width*lengreal; vertexArray.append(pvx); pvx = MPoint(pw.x, pw.y, pw.z); vertexArray.append(pvx); pvx = MPoint(pw.x, pw.y, pw.z) + topright;//tws_binormal*Cwidth.r*m_width*lengreal; vertexArray.append(pvx); uArray.append(0.0); vArray.append((float)j/NUMBENDSEG); uArray.append(0.5); vArray.append((float)j/NUMBENDSEG); uArray.append(1.0); vArray.append((float)j/NUMBENDSEG); } for(int j=0; j<NUMBENDSEG; j++) { polygonConnects.append(j*3 + numVertex); polygonConnects.append(j*3+3 + numVertex); polygonConnects.append(j*3+4 + numVertex); polygonConnects.append(j*3+1 + numVertex); polygonCounts.append(4); polygonConnects.append(j*3+1 + numVertex); polygonConnects.append(j*3+4 + numVertex); polygonConnects.append(j*3+5 + numVertex); polygonConnects.append(j*3+2 + numVertex); polygonCounts.append(4); polygonUVs.append(j*3 + numVertex); polygonUVs.append(j*3+3 + numVertex); polygonUVs.append(j*3+4 + numVertex); polygonUVs.append(j*3+1 + numVertex); polygonUVs.append(j*3+1 + numVertex); polygonUVs.append(j*3+4 + numVertex); polygonUVs.append(j*3+5 + numVertex); polygonUVs.append(j*3+2 + numVertex); } numVertex += (NUMBENDSEG+1)*3; numPolygon += NUMBENDSEG*2; } MIntArray connvert; int idxpre; float averg_scale, averg_erect, averg_rotate, averg_curl, averg_width; for( int i=0; !faceIter.isDone(); faceIter.next(), i++ ) { if(faceIter.onBoundary()) continue; faceIter.getNormal(N, MSpace::kWorld); N.normalize(); faceIter.getVertices(connvert); averg_scale=averg_erect=averg_rotate=averg_curl=0; for(int j=0; j<connvert.length(); j++) { vertIter.setIndex(connvert[j], idxpre); vertIter.getColor(Cscale, &setScale); vertIter.getColor(Cerect, &setErect); vertIter.getColor(Crotate, &setRotate); vertIter.getColor(Ccurl, &setCurl); vertIter.getColor(Cwidth, &setWidth); averg_scale += Cscale.r; averg_erect += Cerect.r; averg_rotate += Crotate.r; averg_curl += Ccurl.r; averg_width += Cwidth.r; } averg_scale /= connvert.length(); averg_erect /= connvert.length(); averg_rotate /= connvert.length(); averg_curl /= connvert.length(); averg_width /= connvert.length(); tang = MVector(0,0,0); for(int j=0; j<connvert.length(); j++) { meshFn.getFaceVertexTangent (i, connvert[j], ttang, MSpace::kWorld); ttang.normalize(); tang += ttang; } //tang /= conn_face.length(); connvert.clear(); tang.normalize(); tang = N^tang; tang.normalize(); binormal = N^tang; if(averg_rotate<0.5) { rot = (0.5 - averg_rotate)*2; tang = tang + (binormal-tang)*rot; tang.normalize(); binormal = N^tang; } else { rot = (averg_rotate-0.5)*2; tang = tang + (binormal*-1-tang)*rot; tang.normalize(); binormal = N^tang; } dir = tang + (N - tang)*averg_erect; dir.normalize(); //S = S+dir*Cscale.r*m_scale; //glVertex3f(S.x, S.y, S.z); hair_up = dir^binormal; hair_space.setIdentity(); hair_space.setOrientations(XYZ(binormal.x, binormal.y, binormal.z), XYZ(hair_up.x, hair_up.y, hair_up.z), XYZ(dir.x, dir.y, dir.z)); S = faceIter.center(MSpace::kWorld); hair_space.setTranslation(XYZ(S.x, S.y, S.z)); lengreal = Cscale.r*m_scale; fb->create(lengreal, 0, lengreal*(averg_curl-0.5)*2); MPoint pright = S + binormal*Cwidth.r*m_width*lengreal; MPoint pleft = S - binormal*Cwidth.r*m_width*lengreal; XYZ pw; MPoint pvx; MPoint phit; int polyhit; meshFn.getClosestPoint (pright, phit, MSpace::kObject, &polyhit); MVector topright = phit - S; topright.normalize(); topright *= Cwidth.r*m_width*lengreal; meshFn.getClosestPoint (pleft, phit, MSpace::kObject, &polyhit); MVector topleft = phit - S; topleft.normalize(); topleft *= Cwidth.r*m_width*lengreal; //tws_binormal = binormal*cos(0.2) + hair_up*sin(0.2); for(int j=0; j<NUMBENDSEG+1; j++) { fb->getPoint(j, pw); hair_space.transform(pw); pvx = MPoint(pw.x, pw.y, pw.z) + topleft;//- tws_binormal*averg_width*m_width*lengreal; vertexArray.append(pvx); pvx = MPoint(pw.x, pw.y, pw.z); vertexArray.append(pvx); pvx = MPoint(pw.x, pw.y, pw.z) + topright;//tws_binormal*averg_width*m_width*lengreal; vertexArray.append(pvx); uArray.append(0.0); vArray.append((float)j/NUMBENDSEG); uArray.append(0.5); vArray.append((float)j/NUMBENDSEG); uArray.append(1.0); vArray.append((float)j/NUMBENDSEG); } for(int j=0; j<NUMBENDSEG; j++) { polygonConnects.append(j*3 + numVertex); polygonConnects.append(j*3+3 + numVertex); polygonConnects.append(j*3+4 + numVertex); polygonConnects.append(j*3+1 + numVertex); polygonCounts.append(4); polygonConnects.append(j*3+1 + numVertex); polygonConnects.append(j*3+4 + numVertex); polygonConnects.append(j*3+5 + numVertex); polygonConnects.append(j*3+2 + numVertex); polygonCounts.append(4); polygonUVs.append(j*3 + numVertex); polygonUVs.append(j*3+3 + numVertex); polygonUVs.append(j*3+4 + numVertex); polygonUVs.append(j*3+1 + numVertex); polygonUVs.append(j*3+1 + numVertex); polygonUVs.append(j*3+4 + numVertex); polygonUVs.append(j*3+5 + numVertex); polygonUVs.append(j*3+2 + numVertex); } numVertex += (NUMBENDSEG+1)*3; numPolygon += NUMBENDSEG*2; } MFnMesh meshCreateFn; meshCreateFn.create( numVertex, numPolygon, vertexArray, polygonCounts, polygonConnects, outMeshData, &stat ); meshCreateFn.setUVs ( uArray, vArray ); meshCreateFn.assignUVs ( polygonCounts, polygonUVs ); return outMeshData; }
// write a normal mesh // MStatus vxCache::writeMesh(const char* filename, MDagPath meshDag, const MObject& meshObj) { struct meshInfo mesh; MString uvset("map1"); MStatus status; MFnMesh meshFn(meshDag, &status ); MItMeshPolygon faceIter( meshDag, MObject::kNullObj, &status ); MItMeshVertex vertIter(meshDag, MObject::kNullObj, &status); MItMeshEdge edgeIter(meshDag, MObject::kNullObj, &status); mesh.numPolygons = meshFn.numPolygons(); mesh.numVertices = meshFn.numVertices(); mesh.numFaceVertices = meshFn.numFaceVertices(); mesh.numUVs = meshFn.numUVs(uvset, &status); mesh.skip_interreflection = mesh.skip_scattering = 0; //if(zWorks::hasNamedAttribute(meshObj, "_prt_ig_intr") == 1) mesh.skip_interreflection = 1; //if(zWorks::hasNamedAttribute(meshObj, "_prt_ig_scat") == 1) mesh.skip_scattering = 1; //zWorks::displayIntParam("N Face", mesh.numPolygons); //zWorks::displayIntParam("N Vertex", mesh.numVertices); //zWorks::displayIntParam("N Facevertex", mesh.numFaceVertices); //zWorks::displayIntParam("N UV", mesh.numUVs); int *fcbuf = new int[mesh.numPolygons]; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { fcbuf[ faceIter.index() ] = faceIter.polygonVertexCount(); } int* vertex_id = new int[mesh.numFaceVertices]; int* uv_id = new int[mesh.numFaceVertices]; // output face loop int acc = 0; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); for( unsigned int i=0; i < vexlist.length(); i++ ) { vertex_id[acc] = vexlist[i]; faceIter.getUVIndex ( i, uv_id[acc] ); acc++; } } // output vertices MPointArray pArray; if(worldSpace) meshFn.getPoints ( pArray, MSpace::kWorld); else meshFn.getPoints ( pArray, MSpace::kObject ); XYZ *pbuf = new XYZ[pArray.length()]; for( unsigned int i=0; i<pArray.length(); i++) { pbuf[i].x = pArray[i].x; pbuf[i].y = pArray[i].y; pbuf[i].z= pArray[i].z; } //output texture coordinate MFloatArray uArray, vArray; meshFn.getUVs ( uArray, vArray, &uvset ); double* ubuf = new double[mesh.numUVs]; double* vbuf = new double[mesh.numUVs]; for( unsigned int i=0; i<uArray.length(); i++) { ubuf[i] = uArray[i]; vbuf[i] = vArray[i]; } /* XYZ *norbuf = new XYZ[mesh.numVertices]; vertIter.reset(); MVector tnor; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { if(worldSpace) vertIter.getNormal(tnor, MSpace::kWorld); else vertIter.getNormal(tnor, MSpace::kObject); tnor.normalize(); norbuf[i].x = tnor.x; norbuf[i].y = tnor.y; norbuf[i].z = tnor.z; } MStatus hasAttr; MString sColorSet("set_prt_attr"); meshFn.numColors( sColorSet, &hasAttr ); XYZ *colbuf = new XYZ[mesh.numVertices]; vertIter.reset(); if(hasAttr) { MColor col; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; vertIter.getConnectedFaces(conn_face); vertIter.getColor(col, conn_face[0], &sColorSet); colbuf[i].x = col.r; colbuf[i].y = col.g; colbuf[i].z = col.b; } } else { for( unsigned int i=0; i<vertIter.count(); i++ ) colbuf[i] = XYZ(1.0f); } vertIter.reset(); XYZ *vsbuf = new XYZ[mesh.numVertices]; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face, conn_edge; vertIter.getConnectedFaces(conn_face); vertIter.getConnectedEdges(conn_edge); MPoint Q; for(unsigned j=0; j<conn_face.length(); j++) { int pre_id; faceIter.setIndex(conn_face[j],pre_id); Q += faceIter.center(MSpace::kWorld); } Q = Q/(double)conn_face.length(); MPoint R; for(unsigned j=0; j<conn_edge.length(); j++) { int pre_id; edgeIter.setIndex(conn_edge[j], pre_id); R += edgeIter.center(MSpace::kWorld); } R = R/(double)conn_edge.length(); MPoint S = vertIter.position(MSpace::kWorld); int nv = conn_edge.length(); MPoint nS = (Q + R*2 + S*(nv-3))/nv; vsbuf[i].x = nS.x; vsbuf[i].y = nS.y; vsbuf[i].z = nS.z; } XYZ *tangbuf = new XYZ[mesh.numVertices]; vertIter.reset(); for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; MVector tang(0,0,0); vertIter.getConnectedFaces(conn_face); //for(int j = 0; j<conn_face.length(); j++) { MVector ttang; meshFn.getFaceVertexTangent (conn_face[0], i, ttang, MSpace::kWorld, &uvset); tang += ttang; } tang.normalize(); tangbuf[i].x = tang.x; tangbuf[i].y = tang.y; tangbuf[i].z = tang.z; tangbuf[i] = norbuf[i].cross(tangbuf[i]); tangbuf[i].normalize(); } */ FMCFMesh fmesh; fmesh.save(mesh.numVertices, mesh.numFaceVertices, mesh.numPolygons, mesh.numUVs, mesh.skip_interreflection, mesh.skip_scattering, fcbuf, vertex_id, uv_id, pbuf, //vsbuf, //norbuf, //tangbuf, //colbuf, ubuf, vbuf, filename); delete[] fcbuf; delete[] vertex_id; delete[] uv_id; delete[] pbuf; //delete[] vsbuf; //delete[] norbuf; //delete[] tangbuf; //delete[] colbuf; delete[] ubuf; delete[] vbuf; return MS::kSuccess; }
void ExportACache::save(const char* filename, int frameNumber, char bfirst) { MStatus status; FXMLScene xml_f; xml_f.begin(filename, frameNumber, bfirst); for(unsigned it=0; it<m_mesh_list.length(); it++) { m_mesh_list[it].extendToShape(); MString surface = m_mesh_list[it].partialPathName(); AHelper::validateFilePath(surface); MFnDependencyNode fnode(m_mesh_list[it].node()); MString smsg("prtMsg"); MStatus hasMsg; MPlug pmsg = fnode.findPlug( smsg, 1, &hasMsg ); char bNoChange = 0; if(hasMsg) { MObject oattrib; AHelper::getConnectedNode(oattrib, pmsg); fnode.setObject(oattrib); bool iattr = 0; AHelper::getBoolAttributeByName(fnode, "noChange", iattr); if(iattr) bNoChange = 1; } xml_f.meshBegin(surface.asChar(), bNoChange); MFnMesh meshFn(m_mesh_list[it], &status ); MItMeshPolygon faceIter(m_mesh_list[it], MObject::kNullObj, &status ); MItMeshVertex vertIter(m_mesh_list[it], MObject::kNullObj, &status); MItMeshEdge edgeIter(m_mesh_list[it], MObject::kNullObj, &status); int n_tri = 0; float f_area = 0; double area; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); n_tri += vexlist.length() - 2; faceIter.getArea( area, MSpace::kWorld ); f_area += (float)area; } xml_f.triangleInfo(n_tri, f_area); float avg_grid = sqrt(f_area/n_tri)/2; double light_intensity = 1.0; if(hasMsg) { MObject oattrib; AHelper::getConnectedNode(oattrib, pmsg); fnode.setObject(oattrib); bool iattr = 0; AHelper::getBoolAttributeByName(fnode, "noChange", iattr); if(iattr) xml_f.addAttribute("noChange", 1); AHelper::getBoolAttributeByName(fnode, "skipIndirect", iattr); if(iattr) xml_f.addAttribute("skipIndirect", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "skipScatter", iattr); if(iattr) xml_f.addAttribute("skipScatter", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "skipBackscatter", iattr); if(iattr) xml_f.addAttribute("skipBackscatter", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "asLightsource", iattr); if(iattr) xml_f.addAttribute("asLightsource", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "asGhost", iattr); if(iattr) xml_f.addAttribute("invisible", 1); iattr = 0; AHelper::getBoolAttributeByName(fnode, "castNoShadow", iattr); if(iattr) xml_f.addAttribute("noShadow", 1); double td; if(AHelper::getDoubleAttributeByName(fnode, "lightIntensity", td)) light_intensity = td; fnode.setObject(m_mesh_list[it].node()); } xml_f.staticBegin(); int n_poly = meshFn.numPolygons(); int n_vert = meshFn.numVertices(); int* polycount = new int[n_poly]; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) polycount[ faceIter.index() ] = faceIter.polygonVertexCount(); xml_f.addFaceCount(n_poly, polycount); delete[] polycount; int n_facevertex = meshFn.numFaceVertices(); int* polyconnect = new int[n_facevertex]; int acc = 0; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); for( int i=vexlist.length()-1; i >=0; i-- ) { polyconnect[acc] = vexlist[i]; acc++; } } xml_f.addFaceConnection(n_facevertex, polyconnect); delete[] polyconnect; int* triconnect = new int[3*n_tri]; acc = 0; faceIter.reset(); for( ; !faceIter.isDone(); faceIter.next() ) { MIntArray vexlist; faceIter.getVertices ( vexlist ); for( int i=vexlist.length()-2; i >0; i-- ) { triconnect[acc] = vexlist[vexlist.length()-1]; acc++; triconnect[acc] = vexlist[i]; acc++; triconnect[acc] = vexlist[i-1]; acc++; } } xml_f.addTriangleConnection(3*n_tri, triconnect); delete[] triconnect; if(meshFn.numUVSets() > 0) { MStringArray setNames; meshFn.getUVSetNames(setNames); for(unsigned i=0; i< setNames.length(); i++) { float* scoord = new float[n_facevertex]; float* tcoord = new float[n_facevertex]; acc = 0; faceIter.reset(); MFloatArray uarray, varray; if(faceIter.hasUVs (setNames[i], &status)) { for( ; !faceIter.isDone(); faceIter.next() ) { faceIter.getUVs ( uarray, varray, &setNames[i] ); for( int j=uarray.length()-1; j >=0 ; j-- ) { scoord[acc] = uarray[j]; tcoord[acc] = 1.0 - varray[j]; acc++; } } if(setNames[i] == "map1") { xml_f.uvSetBegin(setNames[i].asChar()); xml_f.addS("facevarying float s", meshFn.numFaceVertices(), scoord); xml_f.addT("facevarying float t", meshFn.numFaceVertices(), tcoord); xml_f.uvSetEnd(); } else { xml_f.uvSetBegin(setNames[i].asChar()); std::string paramname("facevarying float u_"); paramname.append(setNames[i].asChar()); xml_f.addS(paramname.c_str(), meshFn.numFaceVertices(), scoord); paramname = "facevarying float v_"; paramname.append(setNames[i].asChar()); xml_f.addT(paramname.c_str(), meshFn.numFaceVertices(), tcoord); xml_f.uvSetEnd(); } } else MGlobal::displayWarning(MString("Skip empty uv set: ") + setNames[i]); delete[] scoord; delete[] tcoord; } } MStringArray colorSetNames; meshFn.getColorSetNames (colorSetNames); for(unsigned int i=0; i<colorSetNames.length(); i++) { MStatus hasColor; XYZ *colors = new XYZ[n_vert]; vertIter.reset(); MString aset = colorSetNames[i]; MColor col; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; vertIter.getConnectedFaces(conn_face); vertIter.getColor(col, conn_face[0], &aset); colors[i].x = col.r*light_intensity; colors[i].y = col.g*light_intensity; colors[i].z = col.b*light_intensity; } xml_f.addVertexColor(aset.asChar(), n_vert, colors); delete[] colors; } //if(!bNoChange) { //} MPointArray p_vert; meshFn.getPoints ( p_vert, MSpace::kWorld ); MPoint corner_l(10e6, 10e6, 10e6); MPoint corner_h(-10e6, -10e6, -10e6); for( unsigned int i=0; i<p_vert.length(); i++) { if( p_vert[i].x < corner_l.x ) corner_l.x = p_vert[i].x; if( p_vert[i].y < corner_l.y ) corner_l.y = p_vert[i].y; if( p_vert[i].z < corner_l.z ) corner_l.z = p_vert[i].z; if( p_vert[i].x > corner_h.x ) corner_h.x = p_vert[i].x; if( p_vert[i].y > corner_h.y ) corner_h.y = p_vert[i].y; if( p_vert[i].z > corner_h.z ) corner_h.z = p_vert[i].z; } XYZ *cv = new XYZ[n_vert]; for( unsigned int i=0; i<p_vert.length(); i++) { cv[i].x = p_vert[i].x; cv[i].y = p_vert[i].y; cv[i].z= p_vert[i].z; } //if(!bNoChange) //else xml_f.addStaticP(n_vert, cv); XYZ *nor = new XYZ[n_vert]; XYZ *tang = new XYZ[n_vert]; vertIter.reset(); MVector vnor; for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { vertIter.getNormal(vnor, MSpace::kWorld); vnor.normalize(); nor[i].x = vnor.x; nor[i].y = vnor.y; nor[i].z = vnor.z; } MString uvset("map1"); vertIter.reset(); for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray conn_face; vertIter.getConnectedFaces(conn_face); MVector ctang(0,0,0); MVector ttang; for(unsigned j = 0; j<conn_face.length(); j++) { meshFn.getFaceVertexTangent (conn_face[j], i, ttang, MSpace::kWorld, &uvset); ttang.normalize(); ctang += ttang; } ctang.normalize(); tang[i].x = ctang.x; tang[i].y = ctang.y; tang[i].z = ctang.z; tang[i] = nor[i].cross(tang[i]); tang[i].normalize(); } //if(!bNoChange) //else xml_f.addStaticN(n_vert, nor); //xml_f.addTangent(n_vert, tang); // export per-vertex thickness float* vgrd = new float[n_vert]; int pidx; vertIter.reset(); for( unsigned int i=0; !vertIter.isDone(); vertIter.next(), i++ ) { MIntArray connfaces; vertIter.getConnectedFaces( connfaces ); float connarea = 0; for(unsigned j=0; j<connfaces.length(); j++) { faceIter.setIndex(connfaces[j], pidx); faceIter.getArea(area, MSpace::kWorld ); connarea += (float)area/faceIter.polygonVertexCount(); } vgrd[i] = sqrt(connarea)/2; if(vgrd[i] > avg_grid) vgrd[i] = avg_grid; } //if(!bNoChange) //else xml_f.addStaticGridSize(n_vert, vgrd); // //else xml_f.staticEnd(); if(!bNoChange) { xml_f.dynamicBegin(); xml_f.addP(n_vert, cv); xml_f.addN(n_vert, nor); xml_f.addGridSize(n_vert, vgrd); xml_f.dynamicEnd(); } delete[] cv; delete[] tang; delete[] nor; delete[] vgrd; xml_f.addBBox(corner_l.x, corner_l.y, corner_l.z, corner_h.x, corner_h.y, corner_h.z); xml_f.meshEnd(bNoChange); } /* disable nurbs for now float aspace[4][4]; for(unsigned it=0; it<m_nurbs_list.length(); it++) { MVector scale = AHelper::getTransformWorldNoScale(m_nurbs_list[it].fullPathName(), aspace); MString surfacename = m_nurbs_list[it].fullPathName(); AHelper::validateFilePath(surfacename); xml_f.transformBegin(surfacename.asChar(), aspace); xml_f.addScale(scale.x, scale.y, scale.z); m_nurbs_list[it].extendToShape(); surfacename = m_nurbs_list[it].fullPathName(); AHelper::validateFilePath(surfacename); MFnNurbsSurface fsurface(m_nurbs_list[it]); int degreeU = fsurface.degreeU(); int degreeV = fsurface.degreeV(); int formU, formV; if(fsurface.formInU() == MFnNurbsSurface::kOpen ) formU = 0; else if(fsurface.formInU() == MFnNurbsSurface::kClosed ) formU = 1; else formU = 2; if(fsurface.formInV() == MFnNurbsSurface::kOpen ) formV = 0; else if(fsurface.formInV() == MFnNurbsSurface::kClosed ) formV = 1; else formV = 2; xml_f.nurbssurfaceBegin(surfacename.asChar(), degreeU, degreeV, formU, formV); xml_f.staticBegin(); MPointArray p_cvs; fsurface.getCVs( p_cvs, MSpace::kObject ); unsigned n_cvs = p_cvs.length(); XYZ *cv = new XYZ[n_cvs]; for(unsigned i=0; i<n_cvs; i++) { cv[i].x = p_cvs[i].x; cv[i].y = p_cvs[i].y; cv[i].z= p_cvs[i].z; } xml_f.addStaticVec("cvs", n_cvs, cv); delete[] cv; MDoubleArray knotu, knotv; fsurface.getKnotsInU(knotu); fsurface.getKnotsInV(knotv); unsigned n_ku = knotu.length(); unsigned n_kv = knotv.length(); float *ku = new float[n_ku]; for(unsigned i=0; i<n_ku; i++) ku[i] = knotu[i]; float *kv = new float[n_kv]; for(unsigned i=0; i<n_kv; i++) kv[i] = knotv[i]; xml_f.addStaticFloat("knotu", n_ku, ku); xml_f.addStaticFloat("knotv", n_kv, kv); delete[] ku; delete[] kv; xml_f.staticEnd(); xml_f.nurbssurfaceEnd(); xml_f.transformEnd(); } */ xml_f.cameraBegin("backscat_camera", m_space); xml_f.cameraEnd(); xml_f.cameraBegin("eye_camera", m_eye); p_eye.extendToShape(); MFnCamera feye(p_eye); xml_f.addAttribute("focal_length", (float)feye.focalLength()); xml_f.addAttribute("horizontal_film_aperture", (float)feye.horizontalFilmAperture()); xml_f.addAttribute("vertical_film_aperture", (float)feye.verticalFilmAperture()); xml_f.addAttribute("near_clipping_plane", (float)feye.nearClippingPlane()); xml_f.addAttribute("far_clipping_plane", (float)feye.farClippingPlane()); xml_f.cameraEnd(); xml_f.end(filename); }
MStatus meshInfo5::doIt( const MArgList& args ) { MStatus stat = MS::kSuccess; MSelectionList selection; MGlobal::getActiveSelectionList( selection ); MDagPath dagPath; MObject component; unsigned int i, nVerts; int fIndex, vIndex, fvIndex; MVector fNormal, vNormal, fvNormal; MString txt; MItSelectionList iter( selection ); for ( ; !iter.isDone(); iter.next() ) { iter.getDagPath( dagPath, component ); MFnMesh meshFn( dagPath ); // This handles whole mesh selections and mesh-face component selections MItMeshPolygon faceIter( dagPath, component, &stat ); if( stat == MS::kSuccess ) { txt += MString( "Object: " ) + dagPath.fullPathName() + "\n"; for( ; !faceIter.isDone(); faceIter.next() ) { nVerts = faceIter.polygonVertexCount(); for( i=0; i < nVerts; i++ ) { fvIndex = i; fIndex = faceIter.index(); vIndex = faceIter.vertexIndex( i ); faceIter.getNormal( fNormal ); meshFn.getVertexNormal( vIndex, vNormal ); faceIter.getNormal( fvIndex, fvNormal ); addData( txt, fIndex, vIndex, fvIndex, fNormal, vNormal, fvNormal ); } } } else { // This handles mesh-vertex component selections MItMeshVertex vertIter( dagPath, component, &stat ); if( stat == MS::kSuccess ) { txt += MString( "Object: " ) + dagPath.fullPathName() + "\n"; MIntArray faceIds; MIntArray vertIds; for( ; !vertIter.isDone(); vertIter.next() ) { vIndex = vertIter.index(); vertIter.getNormal( vNormal ); vertIter.getConnectedFaces( faceIds ); for( i=0; i < faceIds.length(); i++ ) { fIndex = faceIds[i]; meshFn.getPolygonNormal( fIndex, fNormal ); meshFn.getFaceVertexNormal( fIndex, vIndex, fvNormal ); meshFn.getPolygonVertices( fIndex, vertIds ); for( fvIndex=0; fvIndex < int(vertIds.length()); fvIndex++ ) { if( vertIds[fvIndex] == vIndex ) break; } addData( txt, fIndex, vIndex, fvIndex, fNormal, vNormal, fvNormal ); } } } } } MGlobal::displayInfo( txt ); return MS::kSuccess; }
//-------------------------------------------------------------------------------------- void componentConverter::vtxToConnectedFaceVtx(const MIntArray& vtxIDs, MIntArray& outVtxIDs) //-------------------------------------------------------------------------------------- { // Wandelt die vtxSelection in die connecteten faceVtx um (die Vertizen der verbundenen Faces) // Die gegebenen Vtx werden nicht mit hinzugefuegt outVtxIDs.setLength(0); outVtxIDs.setSizeIncrement(vtxIDs.length() / 4); MItMeshVertex vertIter(mesh); MItMeshPolygon polyIter(mesh); BPT_BA allFaces(polyIter.count(), true); BPT_BA allVtx(vertIter.count(), true); // BA mit den vtxIDs initialisieren // Die vtxIds bereits jetzt false setzen allVtx.setBits(vtxIDs, false); MIntArray conFaces; // hlt die verbundenen Faces MIntArray conVtx; // Im face enthaltene Vtx uint i, x, y , l2,l3, l = vtxIDs.length(); for(i = 0; i < l; i++) { vertIter .setIndex(vtxIDs[i], tmp); vertIter.getConnectedFaces(conFaces); // Jetzt die gueltigen conFaces holen conFaces = allFaces & conFaces; // Jetzt die conFaces false setzen, danit diese nicht wieder bearbeitet werden allFaces.setBits(conFaces, false); l2 = conFaces.length(); // jetzt die restlichen Faces on the fly in Vtx umwandeln for(x = 0; x < l2; x++) { // Jetzt die vertizen des Faces holen und auf Array packen, wenn sie einzigartig sind polyIter.setIndex(conFaces[x], tmp); polyIter.getVertices(conVtx); // Checken, ob Vtx einzigartig sind conVtx = allVtx & conVtx; // Das was uebrig bleibt im BitArray deaktivieren und zum outArray hinzufuegen allVtx.setBits(conVtx, false); l3 = conVtx.length(); for(y = 0; y < l3; y++) { outVtxIDs.append(conVtx[y]); } } } }