void NifImporter::SetNormals(Mesh& mesh, const vector<Niflib::Triangle>& tris, const vector<Niflib::Vector3>& n)
{
mesh.checkNormals(TRUE);
if (n.size() > 0)
{
bool needNormals = false;
for (unsigned int i=0; i<n.size(); i++){
Vector3 v = n[i];
Point3 norm(v.x, v.y, v.z);
if (norm != mesh.getNormal(i)) {
needNormals = true;
break;
}
}
if (needNormals)
{
#if VERSION_3DSMAX > ((5000<<16)+(15<<8)+0) // Version 5
mesh.SpecifyNormals();
MeshNormalSpec *specNorms = mesh.GetSpecifiedNormals ();
if (NULL != specNorms)
{
specNorms->ClearAndFree();
specNorms->SetNumFaces(tris.size());
specNorms->SetNumNormals(n.size());
Point3* norms = specNorms->GetNormalArray();
for (unsigned int i=0; i<n.size(); i++){
Vector3 v = n[i];
norms[i] = Point3(v.x, v.y, v.z);
}
MeshNormalFace* pFaces = specNorms->GetFaceArray();
for (unsigned int i=0; i<tris.size(); i++){
const Triangle& tri = tris[i];
pFaces[i].SpecifyNormalID(0, tri.v1);
pFaces[i].SpecifyNormalID(1, tri.v2);
pFaces[i].SpecifyNormalID(2, tri.v3);
}
#if VERSION_3DSMAX > ((7000<<16)+(15<<8)+0) // Version 7+
specNorms->SetAllExplicit(true);
#else
for (int i=0; i<specNorms->GetNumNormals(); ++i) {
specNorms->SetNormalExplicit(i, true);
}
#endif
specNorms->CheckNormals();
}
#endif
}
}
}
bool Exporter::splitMesh(INode *node, Mesh& mesh, FaceGroups &grps, TimeValue t, vector<Color4>& vertColors, bool noSplit)
{
Mtl* nodeMtl = node->GetMtl();
Matrix3 tm = node->GetObjTMAfterWSM(t);
// Order of the vertices. Get 'em counter clockwise if the objects is
// negatively scaled.
int vi[3];
if (TMNegParity(tm)) {
vi[0] = 2; vi[1] = 1; vi[2] = 0;
} else {
vi[0] = 0; vi[1] = 1; vi[2] = 2;
}
Matrix3 flip;
flip.IdentityMatrix();
flip.Scale(Point3(1, -1, 1));
int nv = mesh.getNumVerts();
int nf = mesh.getNumFaces();
if (noSplit)
{
int nv = mesh.getNumVerts();
int nf = mesh.getNumFaces();
// Dont split the mesh at all. For debugging purposes.
FaceGroup& grp = grps[0];
grp.vidx.resize(nv, -1);
grp.verts.resize(nv);
grp.faces.resize(nf);
grp.uvs.resize(nv);
grp.vnorms.resize(nv);
grp.fidx.resize(nf);
Matrix3 texm;
getTextureMatrix(texm, getMaterial(node, 0));
texm *= flip;
for (int face=0; face<nf; ++face) {
grp.fidx[face] = face;
for (int vi=0; vi<3; ++vi) {
int idx = mesh.faces[face].getVert(vi);
grp.faces[face][vi] = idx;
// Calculate normal
Point3 norm;
#if VERSION_3DSMAX <= ((5000<<16)+(15<<8)+0) // Version 5
norm = getVertexNormal(&mesh, face, mesh.getRVertPtr(idx));
#else
MeshNormalSpec *specNorms = mesh.GetSpecifiedNormals ();
if (NULL != specNorms && specNorms->GetNumNormals() != 0)
norm = specNorms->GetNormal(face, vi);
else
norm = getVertexNormal(&mesh, face, mesh.getRVertPtr(idx));
#endif
Point3 uv;
if (mesh.tVerts && mesh.tvFace) {
uv = mesh.tVerts[ mesh.tvFace[ face ].t[ vi ]] * texm;
uv.y += 1.0f;
}
if (grp.vidx[idx] == idx){
ASSERT(grp.verts[idx] == TOVECTOR3(mesh.getVert(idx)));
//ASSERT(vg.norm == norm);
//Point3 uv = mesh.getTVert(idx);
//if (mesh.getNumTVerts() > 0)
//{
// ASSERT(grp.uvs[idx].u == uv.x && grp.uvs[idx].v == uv.y);
//}
} else {
grp.vidx[idx] = idx;
grp.verts[idx] = TOVECTOR3(mesh.getVert(idx));
//grp.uvs[idx].u = uv.x;
//grp.uvs[idx].v = uv.y;
grp.vnorms[idx] = TOVECTOR3(norm);
}
}
}
for (int i=0; i<nv; ++i) {
ASSERT(grp.vidx[i] != -1);
}
}
else
{
int face, numSubMtls = nodeMtl?nodeMtl->NumSubMtls():0;
for (face=0; face<mesh.getNumFaces(); face++)
{
int mtlID = (numSubMtls!=0) ? (mesh.faces[face].getMatID() % numSubMtls) : 0;
Mtl *mtl = getMaterial(node, mtlID);
Matrix3 texm;
getTextureMatrix(texm, mtl);
texm *= flip;
FaceGroup& grp = grps[mtlID];
if (grp.uvMapping.size() == 0) // Only needs to be done once per face group
{
int nmaps = 0;
int nmapsStart = max(1, mesh.getNumMaps() - (mesh.mapSupport(0) ? 1 : 0)); // Omit vertex color map.
for (int ii = 1; ii <= nmapsStart; ii++) // Winnow out the unsupported maps.
{
if (!mesh.mapSupport(ii)) continue;
grp.uvMapping[ii] = nmaps++;
}
grp.uvs.resize(nmaps == 0 ? 1 : nmaps);
}
if (nv > int(grp.verts.capacity()))
{
grp.vgrp.reserve(nv);
grp.verts.reserve(nv);
grp.vnorms.reserve(nv);
for (int i=0; i<grp.uvs.size(); ++i)
grp.uvs[i].reserve(nv);
grp.vcolors.reserve(nv);
grp.vidx.reserve(nv);
}
if (nf > int(grp.faces.capacity()))
{
grp.faces.reserve(nf);
grp.fidx.reserve(nf);
}
Triangle tri;
for (int i=0; i<3; i++)
tri[i] = addVertex(grp, face, vi[i], &mesh, texm, vertColors);
grp.faces.push_back(tri);
if (grp.fidx.size() < nf)
grp.fidx.resize(nf,-1);
grp.fidx[face] = grp.faces.size() - 1;
}
}
return true;
}
int Exporter::addVertex(FaceGroup &grp, int face, int vi, Mesh *mesh, const Matrix3 &texm, vector<Color4>& vertColors)
{
VertexGroup vg;
int vidx;
vidx = vg.idx = mesh->faces[ face ].v[ vi ];
vg.pt = mesh->verts[ vidx ];
#if VERSION_3DSMAX <= ((5000<<16)+(15<<8)+0) // Version 5
vg.norm = getVertexNormal(mesh, face, mesh->getRVertPtr(vidx));
#else
MeshNormalSpec *specNorms = mesh->GetSpecifiedNormals ();
if (NULL != specNorms && specNorms->GetNumNormals() != 0)
vg.norm = specNorms->GetNormal(face, vi);
else
vg.norm = getVertexNormal(mesh, face, mesh->getRVertPtr(vidx));
#endif
int nmaps = grp.uvMapping.size();
map<int,int>::iterator UVSetIter;
vg.uvs.resize(nmaps > 0 ? nmaps : 1);
if (nmaps > 0) {
for (UVSetIter=grp.uvMapping.begin() ; UVSetIter != grp.uvMapping.end(); UVSetIter++ )
{
int maxUVIdx = (*UVSetIter).first;
int nifUVIdx = (*UVSetIter).second;
TexCoord& uvs = vg.uvs[nifUVIdx];
UVVert *uv = mesh->mapVerts(maxUVIdx);
TVFace *tv = mesh->mapFaces(maxUVIdx);
if (uv && tv) {
Point3 uvw = uv[ tv[ face ].t[ vi ]] * texm;
uvs.u = uvw[0];
uvs.v = uvw[1] + 1.0f;
}
}
} else {
if (mesh->tVerts && mesh->tvFace) {
Point3 uvw = mesh->tVerts[ mesh->tvFace[ face ].t[ vi ]] * texm;
vg.uvs[0].u = uvw[0];
vg.uvs[0].v = uvw[1] + 1.0f;
}
}
vg.color = Color4(1.0f, 1.0f, 1.0f);
if (mVertexColors && !vertColors.empty()){
TVFace *vcFace = mesh->vcFaceData ? mesh->vcFaceData : mesh->vcFace;
if (vcFace) {
int vidx = vcFace[ face ].t[ vi ];
vg.color = vertColors[vidx];
}
}
VertexCompare vc(grp, Exporter::mWeldThresh, Exporter::mNormThresh, Exporter::mUVWThresh);
int n = grp.verts.size();
#if 0
IntRange range = std::equal_range(grp.vmap.begin(), grp.vmap.end(), vg, vc);
if (range.first != range.second) {
return (*range.first);
}
grp.vmap.insert(range.first, n);
#else
for (int i=0; i<grp.vgrp.size(); i++) {
if ( vc.compare(vg, i) == 0 )
return i;
}
grp.vmap.push_back(n);
#endif
grp.vidx.push_back(vidx);
grp.vgrp.push_back(vg);
grp.verts.push_back(TOVECTOR3(vg.pt));
grp.vnorms.push_back(TOVECTOR3(vg.norm));
for (int i=0; i< grp.uvs.size(); ++i) {
TexCoords& uvs = grp.uvs[i];
uvs.push_back(vg.uvs[i]);
}
grp.vcolors.push_back(vg.color);
return n;
}
Exporter::Result Exporter::exportMesh(NiNodeRef &ninode, INode *node, TimeValue t)
{
ObjectState os = node->EvalWorldState(t);
bool local = !mFlattenHierarchy;
TriObject *tri = (TriObject *)os.obj->ConvertToType(t, Class_ID(TRIOBJ_CLASS_ID, 0));
if (!tri)
return Skip;
Mesh *copymesh = NULL;
Mesh *mesh = &tri->GetMesh();
Matrix3 mtx(true), rtx(true);
if (Exporter::mCollapseTransforms)
{
mtx = GetNodeLocalTM(node, t);
mtx.NoTrans();
Quat q(mtx);
q.MakeMatrix(rtx);
mesh = copymesh = new Mesh(*mesh);
{
int n = mesh->getNumVerts();
for ( unsigned int i = 0; i < n; ++i ) {
Point3& vert = mesh->getVert(i);
vert = mtx * vert;
}
mesh->checkNormals(TRUE);
#if VERSION_3DSMAX > ((5000<<16)+(15<<8)+0) // Version 6+
MeshNormalSpec *specNorms = mesh->GetSpecifiedNormals ();
if (NULL != specNorms) {
specNorms->CheckNormals();
for ( unsigned int i = 0; i < specNorms->GetNumNormals(); ++i ) {
Point3& norm = specNorms->Normal(i);
norm = (rtx * norm).Normalize();
}
}
#endif
}
}
// Note that calling setVCDisplayData will clear things like normals so we set this up first
vector<Color4> vertColors;
if (mVertexColors)
{
bool hasvc = false;
if (mesh->mapSupport(MAP_ALPHA))
{
mesh->setVCDisplayData(MAP_ALPHA); int n = mesh->getNumVertCol();
if (n > vertColors.size())
vertColors.assign(n, Color4(1.0f, 1.0f, 1.0f, 1.0f));
VertColor *vertCol = mesh->vertColArray;
if (vertCol) {
for (int i=0; i<n; ++i) {
VertColor c = vertCol[ i ];
float a = (c.x + c.y + c.z) / 3.0f;
vertColors[i].a = a;
hasvc |= (a != 1.0f);
}
}
}
if (mesh->mapSupport(0))
{
mesh->setVCDisplayData(0);
VertColor *vertCol = mesh->vertColArray;
int n = mesh->getNumVertCol();
if (n > vertColors.size())
vertColors.assign(n, Color4(1.0f, 1.0f, 1.0f, 1.0f));
if (vertCol) {
for (int i=0; i<n; ++i) {
VertColor col = vertCol[ i ];
vertColors[i] = Color4(col.x, col.y, col.z, vertColors[i].a);
hasvc |= (col.x != 1.0f || col.y != 1.0f || col.z != 1.0f);
}
}
}
if (!hasvc) vertColors.clear();
}
#if VERSION_3DSMAX <= ((5000<<16)+(15<<8)+0) // Version 5
mesh->checkNormals(TRUE);
#else
MeshNormalSpec *specNorms = mesh->GetSpecifiedNormals ();
if (NULL != specNorms) {
specNorms->CheckNormals();
if (specNorms->GetNumNormals() == 0)
mesh->checkNormals(TRUE);
} else {
mesh->checkNormals(TRUE);
}
#endif
Result result = Ok;
Modifier* geomMorpherMod = GetMorpherModifier(node);
bool noSplit = FALSE;
// bool noSplit = (NULL != geomMorpherMod);
while (1)
{
FaceGroups grps;
if (!splitMesh(node, *mesh, grps, t, vertColors, noSplit))
{
result = Error;
break;
}
bool exportStrips = mTriStrips && (Exporter::mNifVersionInt > VER_4_2_2_0);
Matrix44 tm = Matrix44::IDENTITY;
if ( mExportExtraNodes || (mExportType != NIF_WO_ANIM && isNodeKeyed(node) ) ) {
tm = TOMATRIX4(getObjectTransform(node, t, false) * Inverse(getNodeTransform(node, t, false)));
} else {
Matrix33 rot; Vector3 trans;
objectTransform(rot, trans, node, t, local);
tm = Matrix44(trans, rot, 1.0f);
}
tm = TOMATRIX4(Inverse(mtx)) * tm;
TSTR basename = node->NodeName();
TSTR format = (!basename.isNull() && grps.size() > 1) ? "%s:%d" : "%s";
int i=1;
FaceGroups::iterator grp;
for (grp=grps.begin(); grp!=grps.end(); ++grp, ++i)
{
string name = FormatString(format, basename.data(), i);
NiTriBasedGeomRef shape = makeMesh(ninode, getMaterial(node, grp->first), grp->second, exportStrips);
if (shape == NULL)
{
result = Error;
break;
}
if (node->IsHidden())
shape->SetVisibility(false);
shape->SetName(name);
shape->SetLocalTransform(tm);
if (Exporter::mZeroTransforms) {
shape->ApplyTransforms();
}
makeSkin(shape, node, grp->second, t);
if (geomMorpherMod) {
vector<Vector3> verts = shape->GetData()->GetVertices();
exportGeomMorpherControl(geomMorpherMod, verts, shape->GetData()->GetVertexIndices(), shape);
shape->GetData()->SetConsistencyFlags(CT_VOLATILE);
}
}
break;
}
if (tri != os.obj)
tri->DeleteMe();
if (copymesh)
delete copymesh;
return result;
}
void RenderMesh::ConvertFaces(Mesh *Mesh, int MatIndex, Tab<Vert3> &Verts, Tab<Face3> &Faces, bool NegScale)
{
Face3 TmpFace;
Vert3 TmpVert;
BitArray Written;
int i,j,k,NumFace;
int NumUV,UVCount,Index;
int NumVert,Count,VIndex;
Face *aFace;
Tab<BasisVert> FNormals;
Tab<VNormal> Normals;
UVVert *UVVert;
TVFace *UVFace;
Point3 S,T,SxT;
unsigned long Sg;
bool useMeshNorms = false;
if(NegScale)
{
gVIndex[0] = 2;
gVIndex[1] = 1;
gVIndex[2] = 0;
}
else
{
gVIndex[0] = 0;
gVIndex[1] = 1;
gVIndex[2] = 2;
}
// Do we have an EditNormal modifier present - if so we use those normals instead.
// We only use this if they have been applied on a face with smoothing groups, otherwise
// it messes up the tangent space calculation. Probably not the most obtmized route, but it
// works...
MeshNormalSpec * meshNorm = Mesh->GetSpecifiedNormals();
if(meshNorm && meshNorm->GetNumNormals())
useMeshNorms = true;
NumFace = 0;
for(i=0; i < Mesh->getNumFaces(); i++)
{
if(!Mesh->faces[i].Hidden())
{
Index = Mesh->getFaceMtlIndex(i) + 1;
if(Index == MatIndex || MatIndex == 0)
{
NumFace++;
}
}
}
NumVert = Mesh->getNumVerts();
Verts.SetCount(NumVert);
Faces.SetCount(NumFace);
if(NumVert == 0 || NumFace == 0)
{
return;
}
ComputeVertexNormals(Mesh,FNormals,Normals,NegScale);
Written.SetSize(Mesh->getNumVerts());
Written.ClearAll();
NumUV = Mesh->getNumMaps();
if(NumUV)
{
Count = 0;
if(NumUV > MAX_TMUS + 1)
{
NumUV = MAX_TMUS + 1;
}
for(i=0; i < Mesh->getNumFaces(); i++)
{
aFace = &Mesh->faces[i];
TmpFace.m_Num[0] = aFace->v[gVIndex[0]];
TmpFace.m_Num[1] = aFace->v[gVIndex[1]];
TmpFace.m_Num[2] = aFace->v[gVIndex[2]];
Sg = aFace->smGroup;
for(j=0; j < 3; j++)
{
VIndex = aFace->v[gVIndex[j]];
TmpVert.m_Pos = Mesh->verts[VIndex];
if(Sg)
{
if(useMeshNorms)
{
int normID = meshNorm->Face(i).GetNormalID(gVIndex[j]);
TmpVert.m_Normal = meshNorm->Normal(normID).Normalize();
Normals[VIndex].GetNormal(Sg,S,T,SxT);
}
else
TmpVert.m_Normal = Normals[VIndex].GetNormal(Sg,S,T,SxT);
TmpVert.m_S = S;
TmpVert.m_T = T;
TmpVert.m_SxT = SxT;
}
else
{
TmpVert.m_Normal = FNormals[i].m_Normal;
TmpVert.m_S = FNormals[i].m_S;
TmpVert.m_T = FNormals[i].m_T;
TmpVert.m_SxT = FNormals[i].m_SxT;
}
UVCount = 0;
TmpVert.m_Sg = Sg;
for(k=0;k<m_MapChannels.Count();k++)
{
int index = m_MapChannels[k];
if(Mesh->getNumMapVerts(index))
{
UVVert = Mesh->mapVerts(index);
UVFace = Mesh->mapFaces(index);
TmpVert.m_UV[k].x = UVVert[UVFace[i].t[gVIndex[j]]].x;
TmpVert.m_UV[k].y = UVVert[UVFace[i].t[gVIndex[j]]].y;
}
else
{
TmpVert.m_UV[k].x = 0.0f;
TmpVert.m_UV[k].y = 0.0f;
}
}
if(Written[VIndex])
{
if((Sg == 0) ||
(Verts[VIndex].m_Sg != TmpVert.m_Sg) ||
(!UVVertEqual(Verts[VIndex].m_UV[0],TmpVert.m_UV[0])))
{
TmpFace.m_Num[j] = Verts.Count();
Verts.Append(1,&TmpVert,10);
}
}
else
{
Verts[VIndex] = TmpVert;
Written.Set(VIndex);
}
}
if(!Mesh->faces[i].Hidden())
{
Index = Mesh->getFaceMtlIndex(i) + 1;
if(Index == MatIndex || MatIndex == 0)
{
Faces[Count++] = TmpFace;
}
}
}
}
else
{
for(i=0; i < Mesh->getNumFaces(); i++)
{
aFace = &Mesh->faces[i];
Faces[i].m_Num[0] = aFace->v[gVIndex[0]];
Faces[i].m_Num[1] = aFace->v[gVIndex[1]];
Faces[i].m_Num[2] = aFace->v[gVIndex[2]];
for(j=0; j < 3; j++)
{
VIndex = aFace->v[gVIndex[j]];
Verts[VIndex].m_Pos = Mesh->verts[VIndex];
Verts[VIndex].m_Normal = Normals[VIndex].GetNormal(aFace->smGroup,S,T,SxT);
Verts[VIndex].m_S = Point3(0.0f,0.0f,0.0f);
Verts[VIndex].m_T = Point3(0.0f,0.0f,0.0f);
Verts[VIndex].m_SxT = Point3(0.0f,0.0f,0.0f);
for(k=0; k < MAX_TMUS; k++)
{
Verts[VIndex].m_UV[k].x = 0.0f;
Verts[VIndex].m_UV[k].y = 0.0f;
}
}
}
}
Verts.Shrink();
}
void MaxAWDExporter::ExportTriGeom(AWDTriGeom *awdGeom, Object *obj, INode *node, ISkin *skin, IGameMesh * igame_mesh)
{
if (awdGeom != NULL) {
if (awdGeom->get_is_created())
return;
else {
awdGeom->set_is_created(true);
// Extract skinning information (returns number of joints per vertex),
// and writes the weights and joints array according to the jpv
int jpv=0;
awd_float64 *weights=NULL;
awd_uint32 *joints=NULL;
jpv = ExportSkin(node, skin, &weights, &joints);
// Calculate offset matrix from the object TM (which includes geometry offset)
// this will be used to transform all vertices into node space.
int time=maxInterface->GetTime();
// get the neutral pose time from the vertex (using a dedcated cache for this)
bool hasVertexAnim=vetexAnimNeutralPosecache->hasKey(node);
if(hasVertexAnim)
time=vetexAnimNeutralPosecache->Get(node)*GetTicksPerFrame();
else{
// get the neutral pose time from the skeleton, if any is used
if (opts->ExportSkin() && skin && jpv>0) {
SkeletonCacheItem *skel = skeletonCache->GetFromBone(skin->GetBone(0));
time=skel->awdSkel->get_neutralPose();
}
}
Matrix3 offsMtx = node->GetObjectTM(time) * Inverse(node->GetNodeTM(time));
bool isInSkinPoseMode=false;
double *mtxData = (double *)malloc(12*sizeof(double));
SerializeMatrix3(offsMtx, mtxData);
/*if (skin && jpv>0) {
// if the mesh is not in "Skin Pose Mode",
// we add the bind-matrix to the offset matrix (so that all points are moved accoridingly)
// and later we set the transform matrix of the mesh to the identity-matrix (no transform)
ISkinPose * skinPose;
skinPose=skinPose->GetISkinPose(*node);
//isInSkinPoseMode=skinPose->SkinPoseMode();
Matrix3 mtx;
mtx.IdentityMatrix();
if (!isInSkinPoseMode){
Matrix3 bm;
bm.IdentityMatrix();
//skin->GetSkinInitTM(node, bm, true);
//offsMtx *= bm;
//SerializeMatrix3(mtx, mtxData);
}
skinPose=NULL;
}*/
ObjectState os;
// Flatten entire modifier stack
os = node->EvalWorldState(time);
obj = os.obj;
// its allready been taken care that the correct obj is submitted to this function, so we can directly convert to TriObject (?)
TriObject *triObject = (TriObject*)obj->ConvertToType(time, Class_ID(TRIOBJ_CLASS_ID, 0));
Mesh mesh = triObject->mesh;
int numTris = mesh.getNumFaces();
int numVerts = mesh.getNumVerts();
awdGeom->set_originalPointCnt(numVerts);
// This could happen for example with splines (No!, this should never happen, because we check for this earlier (?))
if (numTris==0)
return;
/*
//TODO: optional reorder exported faces, so that quads are stored first
//we than can store one uint32 as offset into the triangle-list, to reconstruct quads on import
int * quadDic=(int *)malloc(sizeof(int) * numTris);
int * isExportedDic=(int *)malloc(sizeof(int) * numTris);
int cnt1=0;
for(cnt1=0;cnt1<numTris;cnt1++){
quadDic[cnt1]=0;
isExportedDic[cnt1]=0;
}
PolyObject *polyObject = (PolyObject*)obj->ConvertToType(time, Class_ID(POLYOBJ_CLASS_ID, 0));
if (polyObject!=NULL){
MNMesh mnMesh = polyObject->GetMesh();
int numFaces = mnMesh.FNum();
int numtri = mnMesh.TriNum();
int idxCnt=0;
for(idxCnt=0;idxCnt<numFaces;idxCnt++){
MNFace thisface=mnMesh.f[idxCnt];
if(thisface.TriNum()==2){
Tab<int> intList;
thisface.GetTriangles(intList);
//quadDic[intList[0]]=intList[1];
//quadDic[intList[1]]=intList[0];
}
}
//if (polyObject!=obj)
// polyObject->DeleteMe();
}
*/
bool force_split=opts->SplitByMatID();// if true, the GeomUtils will create a SubGeo for each MaterialID used by a face, no matter if they share materials or not
bool useUV=opts->ExportUVs();// TODO: check if uvs exists
bool useSecUVs=useUV; // TODO: check if second UVs exists (and are requested)
bool useNormals=opts->ExportNormals();
// ATTENTION:
// we have collected all meshintsances that are using this geometry.
// but some material-settings ( UV / SecondUV / explode) can force us to create multiple geometries...
// the IGAmeMesh gives acces to some handy functions for exporting meshes
// we still need to use the mesh from the standart api, to have access to the correct UV (?)
MeshNormalSpec *specificNormals = NULL;
if(igame_mesh!=NULL){
int numTrisGameMesh = igame_mesh->GetNumberOfFaces();
if (numTrisGameMesh!=numTris){
return; //ERROR: faceCount of game-mesh is not facecount of api-mesh - should not happen
}
AWDBlockList * meshInstanceList = awdGeom->get_mesh_instance_list();
if (meshInstanceList==NULL){
return; //ERROR: faceCount of game-mesh is not facecount of api-mesh - should not happen
}
int numMeshInstances=meshInstanceList->get_num_blocks();
if ((meshInstanceList!=NULL)&&(numMeshInstances==0)){
return; //ERROR: faceCount of game-mesh is not facecount of api-mesh - should not happen
}
// check if the first UVChannel is available for this mesh ( numTVFaces must be equal to numTris)
if (useUV) {
try{
if (mesh.mapSupport(1)){
MeshMap * mesh_map;
mesh_map = &(mesh.Map(1));
int numTrisMap = mesh_map->getNumFaces();
if (numTrisMap!=numTris){
useUV=false;
useSecUVs=false;
}
}
else{
useUV=false;
useSecUVs=false;
}
}
catch(...){
useUV=false;
useSecUVs=false;
}
}
// check if any normals are available for the mesh
if (useNormals) {
mesh.SpecifyNormals();
specificNormals = mesh.GetSpecifiedNormals();
int specificNormalCount = specificNormals->GetNumNormals();// for me, this is allways been 0
if (specificNormalCount==0){
specificNormals=NULL;
int numNorms = igame_mesh->GetNumberOfNormals();
if (numNorms==0){
useNormals=false;
}
}
}
AWD_field_type precision_geo=AWD_FIELD_FLOAT32;
if (opts->StorageGeometry()==1)
precision_geo=AWD_FIELD_FLOAT64;
AWDGeomUtil * geomUtil=new AWDGeomUtil(awdGeom->get_split_faces(), force_split, useUV, useSecUVs, useNormals, 0.0, jpv, precision_geo);
// create a list of GUGeom for each Mesh instance.
// before collecting the actual geom-data,
// we will reduce the number of GUGeoms to the minimum needed to display all mesh-instances correctly
geomUtil->createPreGeometries(meshInstanceList);
Tab<int> MatIDList=igame_mesh->GetActiveMatIDs();
int matIDCnt;
Tab<FaceEx *> facelist;
// for each submesh do:
for (matIDCnt=0; matIDCnt< MatIDList.Count(); matIDCnt++){
facelist=igame_mesh->GetFacesFromMatID(MatIDList[matIDCnt]);
int idx;
int faceCnt=facelist.Count();
if (faceCnt>0){
// if the submesh will be used (if the matID is used by any face):
AWDBlockList * subMaterialList = new AWDBlockList();
int meshInstCnt=0;
// for each mesh instance, apply the material
for (meshInstCnt=0;meshInstCnt<numMeshInstances; meshInstCnt++){
AWDMeshInst * awdMesh=(AWDMeshInst *)meshInstanceList->getByIndex(meshInstCnt);
if (awdMesh==NULL){
return;
}
else{
AWDBlockList * preMaterials = awdMesh->get_pre_materials();
if (preMaterials==NULL){
return;
}
else{
bool createDefault = false;
AWDMaterial * thisMatBlock = (AWDMaterial *)preMaterials->getByIndex(MatIDList[matIDCnt]);
if (thisMatBlock==NULL){
thisMatBlock=(AWDMaterial *)awdMesh->get_defaultMat();
}
if (useUV){
if (thisMatBlock->get_mappingChannel()>0)
thisMatBlock->set_mappingChannel(checkIfUVMapExists(mesh, numTris, thisMatBlock->get_mappingChannel()));
}
if (useSecUVs){
if (thisMatBlock->get_secondMappingChannel()>0)
thisMatBlock->set_secondMappingChannel(checkIfUVMapExists(mesh, numTris, thisMatBlock->get_secondMappingChannel()));
}
subMaterialList->force_append(thisMatBlock);
}
}
}
geomUtil->add_new_sub_geo_to_preGUgeoms(subMaterialList, MatIDList[matIDCnt]);
delete subMaterialList;
}
}
geomUtil->createGeometries();
for (matIDCnt=0; matIDCnt<MatIDList.Count(); matIDCnt++){
facelist=igame_mesh->GetFacesFromMatID(MatIDList[matIDCnt]);
int idx;
int faceCnt=facelist.Count();
if (faceCnt>0){
int numGeoms=geomUtil->get_geoList()->get_num_blocks();
int geoCnt;
for(geoCnt=0; geoCnt<numGeoms; geoCnt++){
GUGeo * thisGUGeo = geomUtil->get_geoList()->get_by_idx(geoCnt);
// get the uvs using the index stored in the geomUtil
// get the secondUV using the index stored in the geomUtil
// get the explode (normals) using the index stored in the geomUtil
// ATTENTION: its not a Subgeo but a SubgeoGroup, so it contain several Subgeos if the face or vert lists are to big for one subgeo
int thisSubGeoIdx=geomUtil->getSubGeoIdxForMatIdx(MatIDList[matIDCnt]);
GUSubGeoGroup *thisSubGeoGroup = thisGUGeo->get_subGeomList()->get_by_idx(thisSubGeoIdx);
if (thisSubGeoGroup==NULL){
return;
}
AWDMaterial * thisAWDMat=(AWDMaterial *)thisSubGeoGroup->materials->getByIndex(0);
bool explode=thisAWDMat->get_is_faceted();
MeshMap * mainUVMeshMap=NULL;
MeshMap * secondUVMeshMap=NULL;
if (thisSubGeoGroup->include_uv){
if (thisAWDMat->get_mappingChannel()>0)
mainUVMeshMap = &(mesh.Map(thisAWDMat->get_mappingChannel()));
}
if (thisSubGeoGroup->include_suv){
if (thisAWDMat->get_secondMappingChannel()>0)
secondUVMeshMap = &(mesh.Map(thisAWDMat->get_secondMappingChannel()));
}
// for each face in the list do:
bool hasMultipleUV=false;
for (idx=0;idx<faceCnt;idx++){
/*if(isExportedDic[idx]==0){
isExportedDic[idx]=1;
if(quadDic[idx]>0){
int yes=0;
}*/
// this will create a new SubGeo inside the SubgeoGroup, if the limits are reached
thisSubGeoGroup->check_limits();
// create a new vert
FaceEx * f=facelist[idx];
int apiFaceIdx=f->meshFaceIndex;
TVFace tvface;
TVFace tvFaceSecond;
Face face = mesh.faces[apiFaceIdx];
DWORD *inds = face.getAllVerts();
if (thisSubGeoGroup->include_uv){
if (mainUVMeshMap!=NULL)
tvface = mainUVMeshMap->tf[apiFaceIdx];
else
tvface = mesh.tvFace[apiFaceIdx];
}
if (thisSubGeoGroup->include_suv){
if (secondUVMeshMap!=NULL)
tvFaceSecond = secondUVMeshMap->tf[apiFaceIdx];
else
tvFaceSecond = mesh.tvFace[apiFaceIdx];
}
Point3 faceNormal;
if (geomUtil->include_normals) {
// if we want to export normals, but no normals was read, than we need to calculate ourself,
// using the face-normal for the angle-calulation
if ((igame_mesh==NULL && specificNormals==NULL)||(explode)){
// faceNormal = mesh.getFaceNormal(t); // this crashes 3dsmax (why?), so calulate the facenormal manually:
Point3 v0, v1, v2;
Tab<Point3> fnorms;
v0 = mesh.getVert(face.getVert(0));
v1 = mesh.getVert(face.getVert(1));
v2 = mesh.getVert(face.getVert(2));
faceNormal = (v1-v0)^(v2-v1);
faceNormal = Normalize(faceNormal);
}
}
int v;
for (v=2; v>=0; v--) {
int vIdx = face.getVert(v);
Point3 vtx = offsMtx * mesh.getVert(vIdx);
vdata *vd = (vdata *)malloc(sizeof(vdata));
vd->orig_idx = vIdx;
vd->x = vtx.x;
vd->y = vtx.z;
vd->z = vtx.y;
// Might not have UV coords
if (geomUtil->include_uv) {
int tvIdx;
Point3 tvtx;
Point3 stvtx;
if (mainUVMeshMap!=NULL)
tvtx=mainUVMeshMap->tv[tvface.t[v]];
else{
tvIdx = tvface.getTVert(v);
tvtx = mesh.getTVert(tvIdx);
}
if (secondUVMeshMap!=NULL)
stvtx=secondUVMeshMap->tv[tvFaceSecond.t[v]];
else{
tvIdx = tvface.getTVert(v);
stvtx = mesh.getTVert(tvIdx);
}
vd->u = tvtx.x;
vd->v = 1.0-tvtx.y;
vd->su = stvtx.x;
vd->sv = 1.0-stvtx.y;
}
if (geomUtil->include_normals) {
Point3 normal;
// if specific vertex-normals was found, we use it, if the subgeo is not set to explode
if ((specificNormals!=NULL) && (!explode)){
normal = specificNormals->GetNormal(apiFaceIdx, v);
}
// else if a (not specific) vertex-normals was found (on the igame-mesh), we use it, if the subgeo is not set to explode
else if ((igame_mesh!=NULL) && (!explode)){
igame_mesh->GetNormal(f->norm[v], normal, true);
}
// else: since we still want normals exported, we use the face-normal (using facenormal with threshold of 0 will explode the mesh
else{
// i dont think this should really get executed anymore (since the igame-object allways should give access to the normals)
normal=faceNormal;
}
// if the object is skinned, we get the global normals
if (jpv>0){
if (normal)
normal=offsMtx*normal;
}
vd->nx = normal.x;
vd->ny = normal.z;
vd->nz = normal.y;
}
// If there is skinning information, copy it from the weight
// and joint index arrays returned by ExportSkin() above.
vd->num_bindings = jpv;
if (jpv > 0) {
vd->weights = (awd_float64*)malloc(jpv*sizeof(awd_float64));
vd->joints = (awd_uint32*)malloc(jpv*sizeof(awd_uint32));
int memoffs = jpv*vIdx;
memcpy(vd->weights, weights+memoffs, jpv*sizeof(awd_float64));
memcpy(vd->joints, joints+memoffs, jpv*sizeof(awd_uint32));
}
vd->force_hard = false;
// add the new vertex to the subgeo
thisSubGeoGroup->append_vdata(vd);
}
}
}
}
}
AWDBlockList * returned_geoms = geomUtil->build_geom(awdGeom);
AWDBlockIterator * it=NULL;
AWDMeshInst * block;
int maxCount=0;
int geomCnt=0;
for (geomCnt=0; geomCnt<returned_geoms->get_num_blocks();geomCnt++){
AWDTriGeom * thisAWDGeom=(AWDTriGeom *)returned_geoms->getByIndex(geomCnt);
it = new AWDBlockIterator(thisAWDGeom->get_mesh_instance_list());
AWDSubGeom *sub;
sub = thisAWDGeom->get_first_sub();
while (sub) {
AWDBlockList *subGeoGroupMatList=sub->get_materials();
int thisIdx=0;
it->reset();
while ((block = (AWDMeshInst*)it->next()) != NULL) {
block->set_geom(thisAWDGeom);
//if (!isInSkinPoseMode){
// block->set_transform(mtxData);
//}
AWDMaterial * thisMat=(AWDMaterial *)subGeoGroupMatList->getByIndex(thisIdx);
if (thisMat==NULL){
int test=0;
//ERROR - this should never happen
}
else{
AWDLightPicker * lightPicker=(AWDLightPicker *)block->get_lightPicker();
AWDBlock * thisAnimator=(AWDBlock *)block->get_animator();
if ((lightPicker!=NULL)||(thisAnimator!=NULL)){
thisMat=thisMat->get_unique_material(lightPicker, thisAnimator, NULL);
if(lightPicker!=NULL){
if(opts->SetMultiPass()){
// multipass using the number of lights, that the lightpicker uses
if (lightPicker->get_lights()->get_num_blocks()>4){
thisMat->set_multiPass(true);
}
else{
thisMat->set_multiPass(false);
}
}
if ((lightPicker->get_lights()->get_num_blocks()>4)&&(!thisMat->get_multiPass())){
AWDMessageBlock * newWarning = new AWDMessageBlock(thisMat->get_name(), "AWDMaterial has more than 4 lights assigned, but is set to singlepass. this will cause problems on render.");
awd->get_message_blocks()->append(newWarning);
}
if(opts->IncludeShadows()){
if(thisMat->get_shadowMethod()!=NULL){
bool shadowOK=lightPicker->check_shadowMethod((AWDShadowMethod *)(thisMat->get_shadowMethod()));
if(!shadowOK){
AWDMessageBlock * newWarning = new AWDMessageBlock(thisMat->get_name(), "Could not find the ShadowMethod thats applied to the material on one of the lights that it assigned to the material.");
awd->get_message_blocks()->append(newWarning);
thisMat->set_shadowMethod(NULL);
}
}
if(thisMat->get_shadowMethod()==NULL){
thisMat->set_shadowMethod(lightPicker->get_shadowMethod());
}
}
}
}
block->add_material((AWDMaterial*)thisMat);
}
thisIdx++;
}
sub = sub->next;
}
delete it;
}
delete returned_geoms;
// If conversion created a new object, dispose it
if (triObject != obj)
triObject->DeleteMe();
delete geomUtil;
}
else{
}
//free(quadDic);
//free(isExportedDic);
free(mtxData);
if (weights!=NULL)
free(weights);
if (joints!=NULL)
free(joints);
}
}
return;
}
void SymmetryMod::ModifyTriObject (TimeValue t, ModContext &mc, TriObject *tobj, INode *inode) {
Mesh &mesh = tobj->GetMesh();
Interval iv = FOREVER;
int axis, slice, weld, flip;
float threshold;
mp_pblock->GetValue (kSymAxis, t, axis, iv);
mp_pblock->GetValue (kSymFlip, t, flip, iv);
mp_pblock->GetValue (kSymSlice, t, slice, iv);
mp_pblock->GetValue (kSymWeld, t, weld, iv);
mp_pblock->GetValue (kSymThreshold, t, threshold, iv);
if (threshold<0) threshold=0;
// Get transform from mirror controller:
Matrix3 tm = CompMatrix (t, NULL, &mc, &iv);
Matrix3 itm = Inverse (tm);
// Get DotProd(N,x)=offset plane definition from transform
Point3 Axis(0,0,0);
Axis[axis] = flip ? -1.0f : 1.0f;
Point3 origin = tm.GetTrans();
Point3 N = Normalize(tm*Axis - origin);
float offset = DotProd (N, origin);
// Slice operation does not handle NormalSpecs, but it handles mapping channels.
// move our mesh normal data to a map channel
MeshNormalSpec *pNormals = mesh.GetSpecifiedNormals ();
int normalMapChannel = INVALID_NORMALMAPCHANNEL;
if (pNormals && pNormals->GetNumFaces())
{
pNormals->SetParent(&mesh);
//find an empty map channel
for (int mp = 0; mp < mesh.getNumMaps(); mp++)
{
if (!mesh.mapSupport(mp))
{
normalMapChannel = mp;
mesh.setMapSupport(normalMapChannel,TRUE);
MeshMap& map = mesh.Map(normalMapChannel);
for (int i = 0; i < map.fnum; i++)
{
for (int j = 0; j < 3; j++)
{
unsigned int newID = pNormals->Face(i).GetNormalID(j);
map.tf[i].t[j] = newID;
}
}
map.setNumVerts(pNormals->GetNumNormals());
for (int i = 0; i < map.vnum; i++)
{
map.tv[i] = pNormals->Normal(i);
}
// make sure nothing is done with MeshNormalSpec (until data is copied back)
pNormals->Clear();
break;
}
}
}
// Slice off everything below the plane.
if (slice) SliceTriObject (mesh, N, offset);
MirrorTriObject (mesh, axis, tm, itm,normalMapChannel);
if (weld) WeldTriObject (mesh, N, offset, threshold);
//now move the normals back
if (pNormals && normalMapChannel != -1)
{
MeshMap& map = mesh.Map(normalMapChannel);
pNormals->SetNumFaces(map.fnum);
pNormals->SetNumNormals(map.vnum);
pNormals->SetAllExplicit(true);
BitArray temp;
temp.SetSize(map.vnum);
temp.SetAll();
pNormals->SpecifyNormals(TRUE,&temp);
for (int i = 0; i < map.vnum; i++)
{
pNormals->GetNormalArray()[i] = map.tv[i];
pNormals->SetNormalExplicit(i,true);
}
for (int i = 0; i < map.fnum; i++)
{
for (int j = 0; j < 3; j++)
{
pNormals->SetNormalIndex(i,j,map.tf[i].t[j]);
MeshNormalFace& face = pNormals->Face(i);
face.SpecifyAll(true);
}
}
pNormals->SetFlag(MESH_NORMAL_MODIFIER_SUPPORT);
for (int i = 0; i < pNormals->GetNumFaces(); i++)
{
for (int j = 0; j < 3; j++)
{
int id = pNormals->GetNormalIndex(i,j);
}
}
pNormals->CheckNormals();
pNormals->SetParent(NULL);
// Free the map channel
mesh.setMapSupport(normalMapChannel,FALSE);
}
tobj->UpdateValidity (GEOM_CHAN_NUM, iv);
tobj->UpdateValidity (TOPO_CHAN_NUM, iv);
tobj->UpdateValidity (VERT_COLOR_CHAN_NUM, iv);
tobj->UpdateValidity (TEXMAP_CHAN_NUM, iv);
tobj->UpdateValidity (SELECT_CHAN_NUM, iv);
}
/*
* Get vertex normal using smooth group with normal method.(using RVertex information)
* FaceVertexIdx is between 0 and 2 local to a triangle
*/
Point3 SGP_MaxInterface::GetVertexNormal( Mesh* pMesh, int faceId, int vertexId, int FaceVertexIdx )
{
//////////////////////////////////////////////////////////////////////////
// Below is the way if someone has used "edit normals modifier" to change vertex normal
MeshNormalSpec *pNormalSpec = pMesh->GetSpecifiedNormals();
if( pNormalSpec )
{
const int NumFaces = pNormalSpec->GetNumFaces();
const int NumNormals = pNormalSpec->GetNumNormals();
if( NumFaces != 0 && NumNormals != 0 )
{
const int NormalID = pNormalSpec->Face(faceId).GetNormalID(FaceVertexIdx);
return pNormalSpec->Normal(NormalID).Normalize();
}
}
//////////////////////////////////////////////////////////////////////////
RVertex *pRVertex;
pRVertex = pMesh->getRVertPtr(vertexId);
// get the face
Face *pFace;
pFace = &pMesh->faces[faceId];
// get the smoothing group of the face
DWORD smGroup;
smGroup = pFace->smGroup;
// get the number of normals
int normalCount;
normalCount = pRVertex->rFlags & NORCT_MASK;
// check if the normal is specified ...
if(pRVertex->rFlags & SPECIFIED_NORMAL)
{
return pRVertex->rn.getNormal();
}
// ... otherwise, check for a smoothing group
else if((normalCount > 0) && (smGroup != 0))
{
// If there is only one vertex is found in the rn member.
if(normalCount == 1)
{
return pRVertex->rn.getNormal();
}
else
{
int normalId;
Point3 n(0,0,0);
for(normalId = 0; normalId < normalCount; normalId++)
{
if(pRVertex->ern[normalId].getSmGroup() & smGroup)
{
n = n+pRVertex->ern[normalId].getNormal();
}
}
n = n.Normalize();
return n;
}
}
// if all fails, return the face normal
return pMesh->getFaceNormal(faceId);
}
BOOL GetVertexNormalUsingSmoothGroup(Point3& VN, Mesh& mesh, int faceId, int globalvertexId, int _FaceVertexIdx)
{
//_FaceVertexIdx is between 0 and 2 local to a triangle
//THIS IS WHAT YOU NEED IF SOMEONE HAS USED THE EDIT NORMAL MODIFIER
MeshNormalSpec * normalspec = mesh.GetSpecifiedNormals();
if (normalspec)
{
const int NumFaces = normalspec->GetNumFaces ();
const int NumNormals = normalspec->GetNumNormals ();
if (NumFaces && NumNormals)
{
const int normID = normalspec->Face(faceId).GetNormalID(_FaceVertexIdx);
VN = normalspec->Normal(normID).Normalize();
return TRUE;
}
}
// get the "rendered" vertex
RVertex *pRVertex = mesh.getRVertPtr(globalvertexId);
if(! pRVertex)return FALSE;
// get the face
const Face& Face = mesh.faces[faceId];
// get the smoothing group of the face
const DWORD smGroup = Face.smGroup;
// get the number of normals
const int normalCount = pRVertex->rFlags & NORCT_MASK;
// check if the normal is specified ...
if(pRVertex->rFlags & SPECIFIED_NORMAL)
{
VN = pRVertex->rn.getNormal();
return TRUE;
}
// ... otherwise, check for a smoothing group
else if((normalCount > 0) && (smGroup != 0))
{
// If there is only one vertex is found in the rn member.
if(normalCount == 1)
{
VN = pRVertex->rn.getNormal();
return TRUE;
}
else
{
for(int normalId = 0; normalId < normalCount; normalId++)
{
if(pRVertex->ern[normalId].getSmGroup() & smGroup)
{
VN = pRVertex->ern[normalId].getNormal();
return TRUE;
}
}
}
}
// if all failed, return the face normal
VN = mesh.getFaceNormal(faceId);
return TRUE;
}