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]);
}
}
}
}
