void GLC_3DViewCollection::selectAll(bool allShowState)
{
unselectAll();
ViewInstancesHash::iterator iNode= m_3DViewInstanceHash.begin();
while (iNode != m_3DViewInstanceHash.end())
{
GLC_3DViewInstance *pCurrentInstance= &(iNode.value());
const GLC_uint instanceId= pCurrentInstance->id();
if (allShowState || (pCurrentInstance->isVisible() == m_IsInShowSate))
{
pCurrentInstance->select(false);
m_SelectedInstances.insert(instanceId, pCurrentInstance);
m_MainInstances.remove(instanceId);
if(isInAShadingGroup(instanceId))
{
m_ShadedPointerViewInstanceHash.value(shadingGroup(instanceId))->remove(instanceId);
}
}
iNode++;
}
}
void GLC_3DViewCollection::unselectAll()
{
PointerViewInstanceHash::iterator iSelectedNode= m_SelectedInstances.begin();
while (iSelectedNode != m_SelectedInstances.end())
{
GLC_3DViewInstance* pInstance= iSelectedNode.value();
pInstance->unselect();
if (isInAShadingGroup(pInstance->id()))
{
m_ShadedPointerViewInstanceHash.value(shadingGroup(pInstance->id()))->insert(pInstance->id(), pInstance);
}
else
{
m_MainInstances.insert(pInstance->id(), pInstance);
}
++iSelectedNode;
}
// Clear selected node hash table
m_SelectedInstances.clear();
}
bool getObjectShadingGroups(const MObject& geoObject, MObject& sGroup, int instId)
{
MPlugArray connections;
MFnDependencyNode dependNode(geoObject);
MPlug plug(geoObject, dependNode.attribute("instObjGroups"));
plug.elementByLogicalIndex(instId).connectedTo(connections, false, true);
if (connections.length() > 0)
{
MObject shadingGroup(connections[0].node());
if (shadingGroup.apiType() == MFn::kShadingEngine)
{
sGroup = shadingGroup;
return true;
}
}
else
Logging::debug(MString("Object-instObjGroups has no connection to shading group."));
return false;
}
/***** load data *****/
MStatus Submesh::loadMaterial(MObject& shader,MStringArray& uvsets,ParamList& params)
{
MPlug plug;
MPlugArray srcplugarray;
bool foundShader = false;
MStatus stat;
MFnLambertShader* pShader;
//get shader from shading group
MFnDependencyNode shadingGroup(shader);
plug = shadingGroup.findPlug("surfaceShader");
plug.connectedTo(srcplugarray,true,false,&stat);
for (int i=0; i<srcplugarray.length() && !foundShader; i++)
{
if (srcplugarray[i].node().hasFn(MFn::kLambert))
{
pShader = new MFnLambertShader(srcplugarray[i].node());
foundShader = true;
}
}
std::cout << "Found material: " << pShader->name().asChar() << "\n";
//check if this material has already been created
Material* pMaterial = MaterialSet::getSingleton().getMaterial(pShader->name());
//if the material has already been created, update the pointer
if (pMaterial)
m_pMaterial = pMaterial;
//else create it and add it to the material set
else
{
pMaterial = new Material();
pMaterial->load(pShader,uvsets,params);
m_pMaterial = pMaterial;
MaterialSet::getSingleton().addMaterial(pMaterial);
}
//delete temporary shader
delete pShader;
//loading complete
return MS::kSuccess;
}
MStatus Mesh::load(MDagPath& meshDag,MDagPath *pDagPath)
{
MStatus stat;
std::vector<MFloatArray> weights;
std::vector<MIntArray> Ids;
std::vector<MIntArray> jointIds;
unsigned int numJoints = 0;
std::vector<vertexInfo> vertices;
MFloatPointArray points;
MFloatVectorArray normals;
if (!meshDag.hasFn(MFn::kMesh))
return MS::kFailure;
MFnMesh mesh(meshDag);
/*{
mesh.getPoints(points,MSpace::kWorld);
MPoint pos;
mesh.getPoint(1,pos,MSpace::kWorld);
for(unsigned i = 0;i < points.length();i++)
{
MFloatPoint fp = points[i];
float x = fp.x;
float y = fp.y;
float z = fp.z;
fp = fp;
}
}*/
int numVertices = mesh.numVertices();
vertices.resize(numVertices);
weights.resize(numVertices);
Ids.resize(numVertices);
jointIds.resize(numVertices);
// 获取UV坐标集的名称
MStringArray uvsets;
int numUVSets = mesh.numUVSets();
if (numUVSets > 0)
{
stat = mesh.getUVSetNames(uvsets);
if (MS::kSuccess != stat)
{
std::cout << "Error retrieving UV sets names\n";
return MS::kFailure;
}
}
// 保存UV集信息
for (int i=m_uvsets.size(); i<uvsets.length(); i++)
{
uvset uv;
uv.size = 2;
uv.name = uvsets[i].asChar();
m_uvsets.push_back(uv);
}
MStringArray colorSetsNameArray;
m_colorSets.clear();
int numColorSets = mesh.numColorSets();
if (numColorSets > 0)
{
mesh.getColorSetNames(colorSetsNameArray);
}
for (int i = 0; i != colorSetsNameArray.length(); ++i)
{
std::string name = colorSetsNameArray[i].asChar();
m_colorSets.push_back(name);
}
// 检查法线是否反
bool opposite = false;
mesh.findPlug("opposite",true).getValue(opposite);
// get connected skin cluster (if present)
bool foundSkinCluster = false;
MItDependencyNodes kDepNodeIt( MFn::kSkinClusterFilter );
for( ;!kDepNodeIt.isDone() && !foundSkinCluster; kDepNodeIt.next())
{
MObject kObject = kDepNodeIt.item();
m_pSkinCluster = new MFnSkinCluster(kObject);
unsigned int uiNumGeometries = m_pSkinCluster->numOutputConnections();
for(unsigned int uiGeometry = 0; uiGeometry < uiNumGeometries; ++uiGeometry )
{
unsigned int uiIndex = m_pSkinCluster->indexForOutputConnection(uiGeometry);
MObject kOutputObject = m_pSkinCluster->outputShapeAtIndex(uiIndex);
if(kOutputObject == mesh.object())
{
foundSkinCluster = true;
}
else
{
delete m_pSkinCluster;
m_pSkinCluster = NULL;
}
}
// load connected skeleton (if present)
if (m_pSkinCluster)
{
if (!m_pSkeleton)
m_pSkeleton = new skeleton();
stat = m_pSkeleton->load(m_pSkinCluster);
if (MS::kSuccess != stat)
std::cout << "Error loading skeleton data\n";
}
else
{
// breakable;
}
}
// get connected shaders
MObjectArray shaders;
MIntArray shaderPolygonMapping;
stat = mesh.getConnectedShaders(0,shaders,shaderPolygonMapping);
if (MS::kSuccess != stat)
{
std::cout << "Error getting connected shaders\n";
return MS::kFailure;
}
if (shaders.length() <= 0)
{
std::cout << "No connected shaders, skipping mesh\n";
return MS::kFailure;
}
// create a series of arrays of faces for each different submesh
std::vector<faceArray> polygonSets;
polygonSets.resize(shaders.length());
// Get faces data
// prepare vertex table
for (int i=0; i<vertices.size(); i++)
vertices[i].next = -2;
//get vertex positions from mesh data
mesh.getPoints(points,MSpace::kWorld);
mesh.getNormals(normals,MSpace::kWorld);
//get list of vertex weights
if (m_pSkinCluster)
{
MItGeometry iterGeom(meshDag);
for (int i=0; !iterGeom.isDone(); iterGeom.next(), i++)
{
weights[i].clear();
Ids[i].clear();
MObject component = iterGeom.component();
MFloatArray vertexWeights;
stat=m_pSkinCluster->getWeights(meshDag,component,vertexWeights,numJoints);
int nWeights = vertexWeights.length();
for(int j = 0;j<nWeights;j++)
{
if(vertexWeights[j] >= 0.00001f || vertexWeights[j] <= -0.00001f )
{
// 记录该节点j
Ids[i].append(j);
weights[i].append(vertexWeights[j]);
}
}
//weights[i]= vertexWeights;
if (MS::kSuccess != stat)
{
std::cout << "Error retrieving vertex weights\n";
}
// get ids for the joints
if (m_pSkeleton)
{
jointIds[i].clear();
if(weights[i].length() > 0 )
{
MDagPathArray influenceObjs;
m_pSkinCluster->influenceObjects(influenceObjs,&stat);
if (MS::kSuccess != stat)
{
std::cout << "Error retrieving influence objects for given skin cluster\n";
}
jointIds[i].setLength(weights[i].length());
for (int j=0; j<jointIds[i].length(); j++)
{
bool foundJoint = false;
for (int k=0; k<m_pSkeleton->getJoints().size() && !foundJoint; k++)
{
if (influenceObjs[Ids[i][j]].partialPathName() == m_pSkeleton->getJoints()[k].name)
{
foundJoint=true;
jointIds[i][j] = m_pSkeleton->getJoints()[k].id;
}
}
}
}
}
}
}
// create an iterator to go through mesh polygons
if (mesh.numPolygons() > 0)
{
const char *name = mesh.name().asChar();
MItMeshPolygon faceIter(mesh.object(),&stat);
if (MS::kSuccess != stat)
{
std::cout << "Error accessing mesh polygons\n";
return MS::kFailure;
}
// iterate over mesh polygons
for (; !faceIter.isDone(); faceIter.next())
{
int numTris=0;
faceIter.numTriangles(numTris);
// for every triangle composing current polygon extract triangle info
for (int iTris=0; iTris<numTris; iTris++)
{
MPointArray triPoints;
MIntArray tempTriVertexIdx,triVertexIdx;
int idx;
// create a new face to store triangle info
face newFace;
// extract triangle vertex indices
faceIter.getTriangle(iTris,triPoints,tempTriVertexIdx);
// convert indices to face-relative indices
MIntArray polyIndices;
faceIter.getVertices(polyIndices);
unsigned int iPoly, iObj;
for (iObj=0; iObj < tempTriVertexIdx.length(); ++iObj)
{
// iPoly is face-relative vertex index
for (iPoly=0; iPoly < polyIndices.length(); ++iPoly)
{
if (tempTriVertexIdx[iObj] == polyIndices[iPoly])
{
triVertexIdx.append(iPoly);
break;
}
}
}
// iterate over triangle's vertices
for (int i=0; i<3; i++)
{
bool different = true;
int vtxIdx = faceIter.vertexIndex(triVertexIdx[i]);
int nrmIdx = faceIter.normalIndex(triVertexIdx[i]);
// get vertex color
MColor color;
if (faceIter.hasColor(triVertexIdx[i]))
{
//This method gets the average color of the all the vertices in this face
stat = faceIter.getColor(color,triVertexIdx[i]);
if (MS::kSuccess != stat)
{
color = MColor(1,1,1,1);
}
if (color.r > 1)
color.r = 1;
if (color.g > 1)
color.g = 1;
if (color.b > 1)
color.b = 1;
if (color.a > 1)
color.a = 1;
}
else
{
color = MColor(1,1,1,1);
}
if (vertices[vtxIdx].next == -2) // first time we encounter a vertex in this position
{
// save vertex position
points[vtxIdx].cartesianize();
vertices[vtxIdx].pointIdx = vtxIdx;
// save vertex normal
vertices[vtxIdx].normalIdx = nrmIdx;
// save vertex colour
vertices[vtxIdx].r = color.r;
vertices[vtxIdx].g = color.g;
vertices[vtxIdx].b = color.b;
vertices[vtxIdx].a = color.a;
// save vertex texture coordinates
vertices[vtxIdx].u.resize(uvsets.length());
vertices[vtxIdx].v.resize(uvsets.length());
// save vbas
vertices[vtxIdx].vba.resize(weights[vtxIdx].length());
for (int j=0; j<weights[vtxIdx].length(); j++)
{
vertices[vtxIdx].vba[j] = (weights[vtxIdx])[j];
}
// save joint ids
vertices[vtxIdx].jointIds.resize(jointIds[vtxIdx].length());
for (int j=0; j<jointIds[vtxIdx].length(); j++)
{
vertices[vtxIdx].jointIds[j] = (jointIds[vtxIdx])[j];
}
// save uv sets data
for (int j=0; j<uvsets.length(); j++)
{
float2 uv;
stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
if (MS::kSuccess != stat)
{
uv[0] = 0;
uv[1] = 0;
}
vertices[vtxIdx].u[j] = uv[0];
vertices[vtxIdx].v[j] = (-1)*(uv[1]-1);
}
// save vertex index in face info
newFace.v[i] = vtxIdx;
// update value of index to next vertex info (-1 means nothing next)
vertices[vtxIdx].next = -1;
}
else // already found at least 1 vertex in this position
{
// check if a vertex with same attributes has been saved already
for (int k=vtxIdx; k!=-1 && different; k=vertices[k].next)
{
different = false;
MFloatVector n1 = normals[vertices[k].normalIdx];
MFloatVector n2 = normals[nrmIdx];
if (n1.x!=n2.x || n1.y!=n2.y || n1.z!=n2.z)
{
different = true;
}
if (vertices[k].r!=color.r || vertices[k].g!=color.g || vertices[k].b!= color.b || vertices[k].a!=color.a)
{
different = true;
}
for (int j=0; j<uvsets.length(); j++)
{
float2 uv;
stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
if (MS::kSuccess != stat)
{
uv[0] = 0;
uv[1] = 0;
}
uv[1] = (-1)*(uv[1]-1);
if (vertices[k].u[j]!=uv[0] || vertices[k].v[j]!=uv[1])
{
different = true;
}
}
idx = k;
}
// if no identical vertex has been saved, then save the vertex info
if (different)
{
vertexInfo vtx;
// save vertex position
vtx.pointIdx = vtxIdx;
// save vertex normal
vtx.normalIdx = nrmIdx;
// save vertex colour
vtx.r = color.r;
vtx.g = color.g;
vtx.b = color.b;
vtx.a = color.a;
// save vertex vba
vtx.vba.resize(weights[vtxIdx].length());
for (int j=0; j<weights[vtxIdx].length(); j++)
{
vtx.vba[j] = (weights[vtxIdx])[j];
}
// save joint ids
vtx.jointIds.resize(jointIds[vtxIdx].length());
for (int j=0; j<jointIds[vtxIdx].length(); j++)
{
vtx.jointIds[j] = (jointIds[vtxIdx])[j];
}
// save vertex texture coordinates
vtx.u.resize(uvsets.length());
vtx.v.resize(uvsets.length());
for (int j=0; j<uvsets.length(); j++)
{
float2 uv;
stat = faceIter.getUV(triVertexIdx[i],uv,&uvsets[j]);
if (MS::kSuccess != stat)
{
uv[0] = 0;
uv[1] = 0;
}
vtx.u[j] = uv[0];
vtx.v[j] = (-1)*(uv[1]-1);
}
vtx.next = -1;
vertices.push_back(vtx);
// save vertex index in face info
newFace.v[i] = vertices.size()-1;
vertices[idx].next = vertices.size()-1;
}
else
{
newFace.v[i] = idx;
}
}
} // end iteration of triangle vertices
// add face info to the array corresponding to the submesh it belongs
// skip faces with no shaders assigned
if (shaderPolygonMapping[faceIter.index()] >= 0)
polygonSets[shaderPolygonMapping[faceIter.index()]].push_back(newFace);
} // end iteration of triangles
}
}
std::cout << "done reading mesh triangles\n";
// create a submesh for every different shader linked to the mesh
unsigned shaderLength = shaders.length();
for (int i=0; i<shaderLength; i++)
{
// check if the submesh has at least 1 triangle
if (polygonSets[i].size() > 0)
{
//create new submesh
SubMesh* pSubmesh = new SubMesh();
const char *nm = mesh.name().asChar();
const char *nm1 = mesh.partialPathName().asChar();
const char *nm2 = mesh.parentNamespace().asChar();
const char *nm3 = mesh.fullPathName().asChar();
const char *nm4 = meshDag.fullPathName().asChar();
pSubmesh->m_name = meshDag.partialPathName();
if(pDagPath)
pSubmesh->m_name = pDagPath->partialPathName();
const char *szName = pSubmesh->m_name.asChar();
if(shaderLength > 1)
{
char a[256];
sprintf(a,"%d",i);
pSubmesh->m_name += a;
}
OutputDebugString(pSubmesh->m_name.asChar());
OutputDebugString("\n");
//OutputDebugString(szName);
//OutputDebugString("\n");
//load linked shader
stat = pSubmesh->loadMaterial(shaders[i],uvsets);
if (stat != MS::kSuccess)
{
MFnDependencyNode shadingGroup(shaders[i]);
std::cout << "Error loading submesh linked to shader " << shadingGroup.name().asChar() << "\n";
return MS::kFailure;
}
//load vertex and face data
stat = pSubmesh->load(polygonSets[i],vertices,points,normals,opposite);
//add submesh to current mesh
m_submeshes.push_back(pSubmesh);
}
}
return MS::kSuccess;
}
void CoronaRenderer::defineMesh(std::shared_ptr<MayaObject> mobj)
{
std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr;
std::shared_ptr<mtco_MayaObject> obj = std::static_pointer_cast<mtco_MayaObject>(mobj);
MObject meshObject = obj->mobject;
MStatus stat = MStatus::kSuccess;
bool hasDisplacement = false;
Corona::SharedPtr<Corona::Abstract::Map> displacementMap = nullptr;
float displacementMin = 0.0f;
float displacementMax = 0.01f;
bool displacementAdaptive = false;
bool diplacementIsHdr = true;
Corona::DisplacementMode displacementMode = Corona::DisplacementMode::DISPLACEMENT_NORMAL;
// I do it here for displacement mapping, maybe we should to another place
getObjectShadingGroups(obj->dagPath, obj->perFaceAssignments, obj->shadingGroups, true);
if( obj->shadingGroups.length() > 0)
{
MFnDependencyNode shadingGroup(obj->shadingGroups[0]);
MString sgn = shadingGroup.name();
MObject displacementObj = getConnectedInNode(obj->shadingGroups[0], "displacementShader");
MString doo = getObjectName(displacementObj);
if( (displacementObj != MObject::kNullObj) && (displacementObj.hasFn(MFn::kDisplacementShader)))
{
MObject displacementMapObj = getConnectedInNode(displacementObj, "displacement");
MObject vectorDisplacementMapObj = getConnectedInNode(displacementObj, "vectorDisplacement");
if( (displacementMapObj != MObject::kNullObj) && (displacementMapObj.hasFn(MFn::kFileTexture)))
{
MFnDependencyNode displacmentMapNode(displacementObj);
int dispMode = getEnumInt("displacementMode", displacmentMapNode);
if (dispMode == 1)
displacementMode = Corona::DisplacementMode::DISPLACEMENT_VECTOR_TANGENT;
if (dispMode > 1)
displacementMode = Corona::DisplacementMode::DISPLACEMENT_VECTOR_OBJECT;
displacementAdaptive = getBoolAttr("mtco_displacementAdaptive", displacmentMapNode, false);
getFloat("mtco_displacementMin", displacmentMapNode, displacementMin);
getFloat("mtco_displacementMax", displacmentMapNode, displacementMax);
MObject fileTextureObject = getConnectedInNode(displacementObj, "displacement");
MString fileTexturePath = getConnectedFileTexturePath(MString("displacement"), displacmentMapNode);
int vectorEncoding = getEnumInt("vectorEncoding", displacmentMapNode);
if (vectorEncoding == 0) // absolute, no negative values
diplacementIsHdr = false;
if( fileTexturePath != "")
{
if( !textureFileSupported(fileTexturePath))
{
Logging::error(MString("File texture extension is not supported: ") + fileTexturePath);
}else{
MObject nullObj;
mtco_MapLoader loader(fileTextureObject);
displacementMap = loader.loadBitmap("");
hasDisplacement = true;
}
}
}
}
}
MFnMesh meshFn(meshObject, &stat);
CHECK_MSTATUS(stat);
MPointArray points;
MFloatVectorArray normals;
MFloatArray uArray, vArray;
MIntArray triPointIds, triNormalIds, triUvIds, triMatIds;
Logging::debug("defineMesh pre getMeshData");
obj->getMeshData(points, normals, uArray, vArray, triPointIds, triNormalIds, triUvIds, triMatIds);
int numSteps = (int)obj->meshDataList.size();
uint numVertices = points.length();
uint numNormals = normals.length();
uint numUvs = uArray.length();
MString meshFullName = makeGoodString(meshFn.fullPathName());
Corona::TriangleData td;
Corona::IGeometryGroup* geom = nullptr;
geom = this->context.scene->addGeomGroup();
geom->setMapChannelCount(1);
// to capture the vertex and normal positions, we capture the data during the motion steps
// and save them in a an std::vector. The uv's do not change, so we only sample them once.
// we always have at least one motionstep even if we have no motionblur
uint npts = 0;
for( int mbStep = 0; mbStep < numSteps; mbStep++)
{
MeshData& md = obj->meshDataList[mbStep];
if (md.points.length() != numVertices)
{
Logging::debug(MString("Error there is a mismatch between point data length and num vertices."));
numSteps = 1;
return;
}
if( mbStep > 0)
{
uint npts1 = md.points.length();
if (npts1 != obj->meshDataList[0].points.length())
{
Logging::debug(MString("Error there is a mismatch between point data length between mb steps."));
numSteps = 1;
break;
}
}
npts = md.points.length();
for( uint vtxId = 0; vtxId < md.points.length(); vtxId++)
{
MPoint& p = md.points[vtxId];
geom->getVertices().push(Corona::Pos(p.x,p.y,p.z));
}
for (uint nId = 0; nId < md.normals.length(); nId++)
{
MFloatVector& n = md.normals[nId];
geom->getNormals().push(Corona::Dir(n.x, n.y, n.z));
}
}
for( uint tId = 0; tId < uArray.length(); tId++)
{
size_t mcl = geom->getMapCoordIndices().size();
geom->getMapCoordIndices().push(mcl);
geom->getMapCoords().push(Corona::Pos(uArray[tId], vArray[tId], 0.0f));
}
obj->geom = geom;
int numTris = triPointIds.length() / 3;
for (uint triId = 0; triId < numTris; triId++)
{
uint index = triId * 3;
int perFaceShadingGroup = triMatIds[triId];
int vtxId0 = triPointIds[index];
int vtxId1 = triPointIds[index + 1];
int vtxId2 = triPointIds[index + 2];
int normalId0 = triNormalIds[index];
int normalId1 = triNormalIds[index + 1];
int normalId2 = triNormalIds[index + 2];
int uvId0 = triUvIds[index];
int uvId1 = triUvIds[index + 1];
int uvId2 = triUvIds[index + 2];
if ((vtxId0 >= npts) || (vtxId1 >= npts) || (vtxId2 >= npts))
Logging::error(MString("Index > npts!!! -- Obj: ") + obj->shortName);
std::auto_ptr<Corona::TriangleData> trip;
if (hasDisplacement)
{
std::auto_ptr<Corona::DisplacedTriangleData> dtrip = std::auto_ptr<Corona::DisplacedTriangleData>(new Corona::DisplacedTriangleData);
dtrip->displacement.mode = displacementMode;
dtrip->displacement.isHdr = diplacementIsHdr;
dtrip->displacement.mapChannel = 0;
dtrip->displacement.map = displacementMap;
dtrip->displacement.waterLevel = -Corona::INFINITY;
dtrip->displacement.min = displacementMin;
dtrip->displacement.max = displacementMax;
dtrip->displacement.adaptive = displacementAdaptive;
trip = dtrip;
}
else{
trip = std::auto_ptr<Corona::TriangleData>(new Corona::TriangleData);
}
trip->v.setSegments(1 - 1); // fixme for deformation motionblur
trip->n.setSegments(1 - 1); // fixme for deformation motionblur
for (int stepId = 0; stepId < 1; stepId++)
{
trip->v[stepId][0] = vtxId0 + numVertices * stepId;
trip->v[stepId][1] = vtxId1 + numVertices * stepId;
trip->v[stepId][2] = vtxId2 + numVertices * stepId;
trip->n[stepId][0] = normalId0 + numNormals * stepId;
trip->n[stepId][1] = normalId1 + numNormals * stepId;
trip->n[stepId][2] = normalId2 + numNormals * stepId;
}
if (numUvs > 0)
{
trip->t[0] = uvId0;
trip->t[1] = uvId1;
trip->t[2] = uvId2;
}
trip->materialId = perFaceShadingGroup;
trip->edgeVis[0] = trip->edgeVis[1] = trip->edgeVis[2] = true;
geom->addPrimitive(*trip);
}
//Logging::debug("}");
obj->perFaceAssignments.clear();
obj->meshDataList.clear();
}
void CoronaRenderer::defineMesh(mtco_MayaObject *obj)
{
MObject meshObject = obj->mobject;
MStatus stat = MStatus::kSuccess;
bool hasDisplacement = false;
Corona::Abstract::Map *displacementMap = NULL;
float displacementMin = 0.0f;
float displacementMax = 0.01f;
// I do it here for displacement mapping, maybe we should to another place
getObjectShadingGroups(obj->dagPath, obj->perFaceAssignments, obj->shadingGroups);
if( obj->shadingGroups.length() > 0)
{
MFnDependencyNode shadingGroup(obj->shadingGroups[0]);
MString sgn = shadingGroup.name();
MObject displacementObj = getConnectedInNode(obj->shadingGroups[0], "displacementShader");
MString doo = getObjectName(displacementObj);
if( (displacementObj != MObject::kNullObj) && (displacementObj.hasFn(MFn::kDisplacementShader)))
{
MObject displacementMapObj = getConnectedInNode(displacementObj, "displacement");
if( (displacementMapObj != MObject::kNullObj) && (displacementMapObj.hasFn(MFn::kFileTexture)))
{
MFnDependencyNode displacmentMapNode(displacementObj);
getFloat("mtco_displacementMin", displacmentMapNode, displacementMin);
getFloat("mtco_displacementMax", displacmentMapNode, displacementMax);
MString fileTexturePath = getConnectedFileTexturePath(MString("displacement"), displacmentMapNode);
if( fileTexturePath != "")
{
MapLoader loader;
displacementMap = loader.loadBitmap(fileTexturePath.asChar());
hasDisplacement = true;
}
}
}
}
MFnMesh meshFn(meshObject, &stat);
CHECK_MSTATUS(stat);
MItMeshPolygon faceIt(meshObject, &stat);
CHECK_MSTATUS(stat);
MPointArray points;
meshFn.getPoints(points);
MFloatVectorArray normals;
meshFn.getNormals( normals, MSpace::kWorld );
MFloatArray uArray, vArray;
meshFn.getUVs(uArray, vArray);
//logger.debug(MString("Translating mesh object ") + meshFn.name().asChar());
MString meshFullName = makeGoodString(meshFn.fullPathName());
Corona::TriangleData td;
Corona::IGeometryGroup* geom = NULL;
geom = this->context.scene->addGeomGroup();
obj->geom = geom;
for( uint vtxId = 0; vtxId < points.length(); vtxId++)
{
geom->getVertices().push(Corona::Pos(points[vtxId].x,points[vtxId].y,points[vtxId].z));
}
for( uint nId = 0; nId < normals.length(); nId++)
{
geom->getNormals().push(Corona::Dir(normals[nId].x,normals[nId].y,normals[nId].z));
}
for( uint tId = 0; tId < uArray.length(); tId++)
{
geom->getMapCoords().push(Corona::Pos(uArray[tId],vArray[tId],0.0f));
geom->getMapCoordIndices().push(geom->getMapCoordIndices().size());
}
MPointArray triPoints;
MIntArray triVtxIds;
MIntArray faceVtxIds;
MIntArray faceNormalIds;
for(faceIt.reset(); !faceIt.isDone(); faceIt.next())
{
int faceId = faceIt.index();
int numTris;
faceIt.numTriangles(numTris);
faceIt.getVertices(faceVtxIds);
MIntArray faceUVIndices;
faceNormalIds.clear();
for( uint vtxId = 0; vtxId < faceVtxIds.length(); vtxId++)
{
faceNormalIds.append(faceIt.normalIndex(vtxId));
int uvIndex;
faceIt.getUVIndex(vtxId, uvIndex);
faceUVIndices.append(uvIndex);
}
for( int triId = 0; triId < numTris; triId++)
{
int faceRelIds[3];
faceIt.getTriangle(triId, triPoints, triVtxIds);
for( uint triVtxId = 0; triVtxId < 3; triVtxId++)
{
for(uint faceVtxId = 0; faceVtxId < faceVtxIds.length(); faceVtxId++)
{
if( faceVtxIds[faceVtxId] == triVtxIds[triVtxId])
{
faceRelIds[triVtxId] = faceVtxId;
}
}
}
uint vtxId0 = faceVtxIds[faceRelIds[0]];
uint vtxId1 = faceVtxIds[faceRelIds[1]];
uint vtxId2 = faceVtxIds[faceRelIds[2]];
uint normalId0 = faceNormalIds[faceRelIds[0]];
uint normalId1 = faceNormalIds[faceRelIds[1]];
uint normalId2 = faceNormalIds[faceRelIds[2]];
uint uvId0 = faceUVIndices[faceRelIds[0]];
uint uvId1 = faceUVIndices[faceRelIds[1]];
uint uvId2 = faceUVIndices[faceRelIds[2]];
if( hasDisplacement )
{
Corona::DisplacedTriangleData tri;
tri.displacement.map = displacementMap;
MPoint p0 = points[vtxId0];
MPoint p1 = points[vtxId1];
MPoint p2 = points[vtxId2];
tri.v[0] = Corona::AnimatedPos(Corona::Pos(p0.x, p0.y, p0.z));
tri.v[1] = Corona::AnimatedPos(Corona::Pos(p1.x, p1.y, p1.z));
tri.v[2] = Corona::AnimatedPos(Corona::Pos(p2.x, p2.y, p2.z));
MVector n0 = normals[normalId0];
MVector n1 = normals[normalId1];
MVector n2 = normals[normalId2];
Corona::Dir dir0(n0.x, n0.y, n0.z);
Corona::Dir dir1(n1.x, n1.y, n1.z);
Corona::Dir dir2(n2.x, n2.y, n2.z);
tri.n[0] = Corona::AnimatedDir(dir0);
tri.n[1] = Corona::AnimatedDir(dir1);
tri.n[2] = Corona::AnimatedDir(dir2);
Corona::Pos uv0(uArray[uvId0],vArray[uvId0],0.0);
Corona::Pos uv1(uArray[uvId1],vArray[uvId1],0.0);
Corona::Pos uv2(uArray[uvId2],vArray[uvId2],0.0);
Corona::StaticArray<Corona::Pos, 3> uvp;
uvp[0] = uv0;
uvp[1] = uv1;
uvp[2] = uv2;
tri.t.push(uvp);
tri.materialId = 0;
tri.displacement.min = displacementMin;
tri.displacement.max = displacementMax;
geom->addPrimitive(tri);
}else{
Corona::TriangleData tri;
tri.v = Corona::AnimatedPosI3(vtxId0, vtxId1, vtxId2);
tri.n = Corona::AnimatedDirI3(normalId0, normalId1, normalId2);
tri.t[0] = uvId0;
tri.t[1] = uvId1;
tri.t[2] = uvId2;
tri.materialId = 0;
geom->addPrimitive(tri);
}
}
}
}
