3Dmax入门学习导出插件制作详解-职坐标

3Dmax入门学习导出插件制作详解

关关 2018-09-06 来源：阅读 657 评论 0

摘要：本篇3Dmax教程探讨了导出插件制作，希望阅读本篇文章以后大家有所收获，帮助大家对3Dmax的掌握更加熟练。

本篇3Dmax教程探讨了导出插件制作，希望阅读本篇文章以后大家有所收获，帮助大家对3Dmax的掌握更加熟练。

第一节：开始

源代码：phase0.zip

在这一节我们将建立插件的“框架”，通常建立插件时我们需要按下面步骤：

1. 假如插件的框架已经存在（通过VC向导建立），那么就可以跳过此节。

2. 假如没有存在我们用VC的向导来建立。

3. 那么我们做下面的事情：

建立一个Win32DLL工程，通常把这个工程放进MaxSDK目录下。设置工程的配置，用于编译DLL。将DLL生成目录设置为MAXSDK/PLUGIN目录。并在工程设置中加入MAXSDK的Include 和 Lib路径。

加两个CPP文件（PLUGINNAME.CPP and DLLENTRY.CPP），前一个文件将包含根据实际的插件类型产生的执行代码。后一个文件是插件DLL ”C” 类型的导出接口。同样，我们加PLUGINNAME.H文件来定义插件的主类。我们加 PLUGINNAME.DEF文件，来说明DLL的导出接口，内容如下：

LIBRARY MyPlugIn // 插件名称

EXPORTS

LibDescription @1 // DLL描述

LibNumberClasses @2 // 返回嵌入类数目

LibClassDesc @3 // 返回第I个类的描述符

LibVersion @4 // 插件版本

SECTIONS

.data READ WRITE

我们加一个字符串资源连同一个版本资源，假如插件需要一个对话框的话，可以加一个。对于本文不需要对话框。

插件必要条件：

我们需要加一个基本类，这个类是所有插件都需要的。DLLENTRY.CPP包含我们所需要的类，这些代码变化不大，几乎可以作为样板在各个插件中使用。这个类经由 LibClassDesc 导入插件构造类 ClassDesc。

DLL接口清楚的说明：DllMain 初始化一些习惯性的定制。LibDescription 将返回字串用来描述插件。Libnumberclasses 返回插件类型号。Libclassdesc 返回Classdesc类用来建立插件对象。Libversion 返回插件的版本，版本在VERSION_3DSMAX 中定义。

LibClassDesc 通常返回单个静态ClassDesc类地址。对于本文，我们的类继承自ClassDesc2。一般来说，我们推荐使用ClassDesc2 和 ParamBlock2 代替以前的版本，以前的版本将被逐步淘汰。

早先的观点，ClassDesc类主要作为一个类工厂被插件类继承。既然这样，主要插件类将继承sceneExport。在我们的插件中我们从 Classdesc2 和 sceneExport 中继承。代表性的，一个静态的单独的ClassDesc类实例通过LibClassdesc建立和返回。我们的派生类也将返回类ID和名字信息和SceneExport派生类名字信息。SDK有一个工具(GENCID.EXE)可以提供一个简单的途径建立唯一的类ID。

MyExporter 是我们从SceneExport 类派生的，简要的说明如下：

int ExtCount() :返回导出提供者扩展名的数量。

const TCHAR * Ext(int n) :返回扩展名

const TCHAR * LongDesc() :返回文件导出格式的“长”类型描述

const TCHAR * ShortDesc() :返回文件导出格式的“短”类型描述

const TCHAR * AuthorName() : 提供插件名，描述插件的作者和公司

const TCHAR * CopyrightMessage() :提供版本字串

const TCHAR * OtherMessage1() : 没有用

const TCHAR * OtherMessage2() : 没有用

unsigned int Version() :有时多余的，但是返回一个版本号为导出者

void ShowAbout() :显示一个about对话框，

int DoExport() :实际的导出方法

大多数方法从字符串表中返回一个局部串或者一个宏定义和常量。导出插件的最主要方法是DoExport方法，我们将在下节中进行扩展。这个例子是简单的，我们没有定制导出选项。看一下导出例子和框架导出，通过简单的途径，我们可以提供一个指定的对话框，在导出前设置导出选项。

我们加一些保护方法（DoHeader,DoNodes,DoTailer）为我们导出全局场景信息时可用，下面的每个节点的信息，下面的任何“End Delimiter”文件信息。我们也加入一些指针成员变量，和一些文件读写指针将在实际导出时用。

！注意：上面讲的在sdk中可以读的更详细，参考“Creating a new Plug-In Project”

！注意：你可以看一下sdk中的例子，许多不同类型的代码组织结构被用。你可以选择自己合适的。

实现：

1、建立一个DLL工程 Exporter。

2、复制phase0文件到Exporter目录。

3、打开VC，打开工程Exporter.dsw。

4、检查EXPORTER.DEF

5、检查DLLENTRY.CPP

6、看 EXPORTER.H、EXPORTER.CPP 注意一下#define MYEXP_CLASSID 、MyExporterClassDesc等。

7、看资源，对话框，版本等。

8、编译，用3Dmax导出，你会看到一个“.MEP”扩展名，这就是你的插件要导出的。

第二节几何体

源代码：phase1.zip

对于我们第一次进行实际的3dmax场景导出，我们将集中讨论几何场景对象。

对于3ds max场景导出通过节点操作比较容易实现，我们第一步需要建立一个节点列举器方法来处理和操作3dmax场景中的节点。我们通过不同的方式这样做：提供我们自己的方法，利用 Iscene 和 TreeEnum 回调函数经由ExpInterface来操作。举个例子，我们编写我们的列举器。

对于在3ds max场景层次中一些简短背景信息，基本层次是场景树，有一个根节点，它的孩子是场景中的其它所有节点。假如一个节点又有一个层次（经由3ds Max连接，可能基于对象层，比如骨骼），这也将被描述为“树”，对此我们也可给出更好的抽象的定义。

根节点有些特殊，我们访问它通过Interface::GetRootNode 这个方法，根节点不代表任何实际的几何对象。

对于我们节点操作，代码如下面所示：

nodeEnum(Node ptr)

If the ptr isn’t valid, exit

If the ptr isn’t selected, and we’re exporting only selected nodes, exit

If the user canceled (usually via ESC), exit

Otherwise

Evaluate the object, determine what type of object it is, and call

a specific helper method that exports that type of object

For each child of the current ptr Node

nodeEnum(child)

上面的代码在MyExporter::DoNodes函数中调用了节点列举函数，此函数实现如下：

Get a count of the children of the Root Node

For each child of the Root Node

Check for cancel and break if cancelled

nodeEnum(child)

网格对象(Mesh)：

3dmax网格是由三角形构成的，每一个几何对象必须能转变为相应的三角形网格。场景中的任何东西都是由这些三元网格组成。然而原始的可能不是这样，为了得到三角形网格我们用函数：Object::ConvertToType（参数TRIOBJ_CLASS_ID）.

我们调用 ConvertToType函数，它检查和返回与原始对象指针相同的对象指针。假如过这样做了，返回的指针和原始指针相同，那么将产生一个新的网格对象，我们调用和负责释放此网格，示例如下：

TriObject *tri = (TriObject *) obj->ConvertToType(ip->GetTime()

if (obj != tri) deleteIt = TRUE

一旦我们有了一个网格，我们可以得到顶点的数目和面的数目。这些信息通过网格(Mesh)类的API来得到。

在对像空间操作网格，我们需要得到节点的转换矩阵（为现在的帧），我们以行的格式将它们导出。

我们通过ObjectTM类导出网格的每一个顶点的世界坐标。

我们导出面，面由用三个数值的顶点数组来表示。顶点是按照顺时针方向排列的，描述物体的“前”表面。我们也可导出“边缘可见性”，它是用来描述边缘，比如 A->B。假如3dsmax画一条高光线在视口，并且采用的是边缘模式，再假如这边缘能被选择，最后我们将导出一组光滑的面，这是通过顶点法向量经过Phong运算或者其它Shading运算方法产生的。

在这片教材中我们将导出网格材质和UV坐标等信息，可以参考源码。

具体源码如下:

#include "Max.h"
#include "resource.h"
#include "export.h"
#include "istdplug.h"
#include "decomp.h"
#include "helpsys.h"
#include "buildver.h"
#include <plugapi.h>
#include <stdmat.h>
#include <mesh.h>
#include <vector>
#include <algorithm>
#include <modstack.h>
#include "ISkinCodes.h"
#include <iparamb2.h>
#include <iskin.h>
#include <d3dx9.h>
#include <Phyexp.h>
using namespace std;
bool isExportSelect;
TCHAR *GetString(int id)

{

static TCHAR buf[256];

if (hInstance)
return LoadString(hInstance, id, buf, sizeof(buf)) buf : NULL;

return NULL;

}

class d3export :public SceneExport
{
public:
int ExtCount();
const TCHAR *AuthorName();
const TCHAR * CopyrightMessage();
int DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts=FALSE, DWORD options=0);
const TCHAR*Ext(int n);
const TCHAR*LongDesc();//这些实现我都删了，这个很简单吧，根据你的需要自己写吧
const TCHAR*ShortDesc() ;
const TCHAR*OtherMessage1() ;
const TCHAR*OtherMessage2() ;
void ShowAbout(HWND hWnd);
unsigned int Version();
protected:
private:
};

DWORD meshOff=0;
DWORD boneOff=0;
DWORD animationOff=0;
bool isIncludeNormalData=true;
bool isIncludeVertexColor=0;
bool isIncludeTexCoord=0;
bool isOptimized=0;//是否优化
DWORD vertexNum=0;
DWORD faceNum=0;
DWORD materialNum=0;
vector<POSITION>vertPosVec;
vector<Point3>normalVec;
vector<DWORD>colorVec;
vector<TEXCOORD>texcoordVec;
vector<FACE>faceVec;
DWORD attributeSize=0;//=FACE
vector<DWORD>attributeBufferVec;
vector<MAT_TEX>materialVec;

//
DWORD g_boneNum;
vector<Bone_st>g_BoneList;

DWORD frameNum;
float inter;
vector<D3DXMATRIX>matrixList;

vector<NODE_MESH> meshVec;

vector<TCHAR*>texNameV;
void WriteFile(char*content)
{
FILE*pF=fopen( "D://log.txt","at");
fseek(pF,0,SEEK_END);
fwrite(content,sizeof(char),strlen(content),pF);
char end='/n';
fwrite( &end,1,1,pF);
fclose(pF);
}

};
class SceneEnumProc: public ITreeEnumProc
{
public:
int callback( INode *node );
};

int SceneEnumProc::callback(INode *node )
{
if((isExportSelect&& node->Selected()) == FALSE)
return TREE_CONTINUE;

if (node->IsHidden())
return TREE_CONTINUE;
//Object*pObject=node->GetObjectRef();
ObjectState pObjectState=node->EvalWorldState(0);
Object*pObject=pObjectState.obj;
TriObject*pTriObject=NULL;
Class_ID meshID=Class_ID(TRIOBJ_CLASS_ID,0);
if (pObject->SuperClassID()==GEOMOBJECT_CLASS_ID)
{
if (pObject- >CanConvertToType(meshID)&&pObject->IsRenderable())
{
pTriObject=(TriObject*)pObject- >ConvertToType(0,meshID);
meshVec.push_back(NODE_MESH(node, &pTriObject->mesh));
}
}
return TREE_CONTINUE;
}
void GetShortName(TCHAR*fileName,TCHAR*shortName)
{
TCHAR*dest=_tcsrchr(fileName,'//');
if (!dest)
{
dest=fileName;
}
else
{
dest++;
}
_tcscpy(shortName,dest);
}
void FillMat(Mtl*nodeMtl , MAT_TEX&theM)
{
MATERIAL& mat=theM.mat;
TCHAR*fileN=theM.texName;
ZeroMemory(&theM,sizeof(theM));
Texmap *tmap =nodeMtl->GetSubTexmap(ID_DI);
TCHAR*fileName=NULL;
if(tmap)
{
if (tmap- >ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
{

BitmapTex*pBitMapT=(BitmapTex*)tmap;
if (pBitMapT)
{
fileName=pBitMapT- >GetMapName();
}
}
}
StdMat * stdM=(StdMat*)nodeMtl;
Color diff=stdM->GetDiffuse(0);//没要自发光
Color spe=stdM-> GetSpecular(0);
Color amb =stdM->GetAmbient(0);
float power=stdM->GetShinStr(0);

mat.Ambient=COLOR(amb.r,amb.g,amb.b);
mat.Diffuse=COLOR(diff.r,diff.g,diff.b);
mat.Specular=COLOR(spe.r,spe.g,spe.b);
mat.Power=power;
if(fileName)
{
texNameV.push_back(fileName);
GetShortName(fileName,fileN);
}
}
bool isMatIn(MAT_TEX&mt,int&index)
{
int mNum=(int)materialVec.size();
for (index=0;index <mNum;index++)
{
if (!_tcscmp(mt.texName,materialVec[index].texName))
{
//如果有相同的材质（以纹理文件作为标准）
return true;
}
}
return false;
}
void AddDefaultMtl( vector<MAT_TEX>&theM)
{
theM.push_back(MAT_TEX());
ZeroMemory(&theM[0],sizeof(MAT_TEX));
theM[0].mat.Diffuse=COLOR(0.7f,0.7f,0.7f,1.0f);
}
void GetIndexList(vector<MAT_TEX>theMat,vector<int>&intVec )
{
int tempSize=(int)theMat.size();
for (int i=0;i<tempSize;i++)
{
int index;
if (!isMatIn(theMat[i],index))
{
materialVec.push_back(theMat[i]);
}
intVec.push_back(index);
}
}
bool fEq(float a,float b)
{
return fabs(a-b)<0.00001f;
}

void AddExtV(DWORD vertexIn,DWORD faceIn,DWORD i,float&u,float&v,float newU,float newV,vector<ExtV>&meshExV)
{
if (fEq(u, -1.0f)&&fEq(v,-1.0f))
{
u=newU;
v=newV;
return;
}

if (fEq(u,newU)&&fEq(v,newV) )
{
return;
}
else
{
//增加一个顶点
ExtV ex(vertexIn,newU,newV);
vector <ExtV>::iterator ite=find(meshExV.begin(),meshExV.end(),ex);
if (ite==meshExV.end())
{//不存在这个元素
meshExV.push_back(ExtV(vertexIn,newU,newV,faceIn,i));
}
else
{
(*ite).fniV.push_back(FNI(faceIn,i));
}
return ;
}

}
void FillmeshUV(NODE_MESH &mesh_node,vector<TEXCOORD>&tempV,vector<ExtV>&extV)
{
int faceNum=mesh_node.pM->getNumFaces();
for (int i=0;i<faceNum;i++)
{
for (int j=0;j <3;j++)
{
DWORD vertexIndex=mesh_node.pM- >faces[i].getVert(j);
//tempV[vertexIndex]//要被输入的；
int tVerNum=mesh_node.pM- >numTVerts;
if (tVerNum >0)
{
DWORD tVertexIndex=mesh_node.pM- >tvFace[i].getTVert(j);
Point3 uvw=mesh_node.pM- >tVerts[tVertexIndex];
Matrix3 m;
m.IdentityMatrix();
m.Scale(Point3(1,-1,1));
m.Translate(Point3(0,1,0));
uvw=uvw*m;
//EXV ABOUT
float &tU=tempV[vertexIndex].u;
float &tV=tempV[vertexIndex].v;
AddExtV(vertexIndex,i,j,tU,tV,uvw.x,uvw.y,extV);
}
}
}

}
void boneProcess(NODE_MESH&nodeMesh,int meshVerNum,int beforeVN);

void NormalProcess(Mesh *ms,vector<Point3>&normalV )
{//我自己来生成发现MD
//此函数根据定点位置和面索引生成发现//基于MAX的发现计算
int vertN=ms->getNumVerts();
int faceN=ms->getNumFaces();
normalV.resize(vertN);
for (vector<Point3>::iterator ini=normalV.begin();ini!=normalV.end();ini++)
{
(*ini)=Point3(0.0f,0.0f,0.0f);
}
for (int i=0;i<faceN;i++)
{
Face &_face=ms->faces[i];
DWORD vI1=_face.v[0];
DWORD vI2=_face.v[1];
DWORD vI3=_face.v[2];
Point3 & firV=ms->verts[vI1];
Point3 & secV=ms->verts[vI2];
Point3 & thiV=ms->verts[vI3];
Point3 normal_=(secV-firV)^(thiV-firV);
normal_=normal_.Normalize();

normalV[vI1]+=normal_;
normalV[vI2]+=normal_;
normalV[vI3]+=normal_;
}

}
void ProcessExt(vector<ExtV>&ext,NODE_MESH&mesh_node,DWORD beforeV);
static void meshProcess(NODE_MESH mesh_node)
{
mylog.WriteFile("bone process");
//下一步是保存到全局里面
DWORD meshVertNum=mesh_node.pM->getNumVerts();
DWORD meshFaceNum=mesh_node.pM->getNumFaces();
if (meshFaceNum<=0||meshVertNum<=0)
{
return;
}
DWORD beforeVN=vertexNum;
DWORD beforeFN=faceNum;
Matrix3 mt=mesh_node.pN->GetObjectTM(0);

//mesh_node.pN->GetObjectTM()
for (DWORD i=0;i<meshVertNum;i++)
{
Point3 vPos=mesh_node.pM- >verts[i];
vPos=mt.PointTransform(vPos);//这段计算出世界位置
vertPosVec.push_back(POSITION(vPos.x,vPos.z,vPos.y));
//Z-Y互换MAX- >DX
}
///
vector<Point3>normalMeshV;
NormalProcess(mesh_node.pM,normalMeshV);
for(vector<Point3>::iterator it=normalMeshV.begin();it!=normalMeshV.end();it++)
{
(*it)=mt.VectorTransform(*it);
(*it)=Point3((*it).x,(*it).z,(*it).y);
(*it)=(*it).Normalize();
Point3 ss=(*it);
}
normalVec.insert(normalVec.end(),normalMeshV.begin(),normalMeshV.end());
/////
for (DWORD j=0;j<meshFaceNum;j++)
{
Face &tFace=mesh_node.pM->faces[j];
faceVec.push_back(FACE((WORD)tFace.v[2]+vertexNum,(WORD)tFace.v[1]+vertexNum,(WORD)tFace.v[0]+vertexNum));
}
vertexNum+=meshVertNum;
faceNum+=meshFaceNum;
/////
vector< MAT_TEX> theM;

bool isMuti=false;
if (isIncludeTexCoord)
{
Mtl*nodeMtl=mesh_node.pN- >GetMtl();
if (nodeMtl)
{
if (nodeMtl- >ClassID()==Class_ID(DMTL_CLASS_ID,0))
{
theM.push_back(MAT_TEX());
FillMat(nodeMtl,theM[0]);
}
else if (nodeMtl- >ClassID()==Class_ID(MULTI_CLASS_ID,0))
{
int numSub=nodeMtl- >NumSubMtls();
if (numSub >0)
{
isMuti=true;
for (int indexM=0;indexM <numSub;indexM++)
{
Mtl*subMtl=nodeMtl- >GetSubMtl(indexM);
if(subMtl- >ClassID()==Class_ID(DMTL_CLASS_ID,0))
{
theM.push_back(MAT_TEX());
FillMat(subMtl,theM[indexM]);
}
}

}
}
}
}
if (theM.size()==0)
{
AddDefaultMtl(theM);
}
vector<int>indexL;
GetIndexList(theM,indexL);
vector<DWORD>tempA(meshFaceNum);
if (theM.size()==1)
{
for (int er=0;er <meshFaceNum;er++)
{
tempA[er]=indexL[0];
}
}
else
{
for (int we=0;we <meshFaceNum;we++)
{
tempA[we]= indexL[mesh_node.pM- >getFaceMtlIndex(we)];
}
}
attributeBufferVec.insert(attributeBufferVec.end(),tempA.begin(),tempA.end());
//创建一个临时的TEXCORRD列表
vector<TEXCOORD>tempV;
for (int v=0;v<meshVertNum;v++)
{
tempV.push_back(TEXCOORD(-1.0f,-1.0f));
}
//填充这个列表
vector<ExtV>extV;
FillmeshUV(mesh_node,tempV,extV);
texcoordVec.insert(texcoordVec.end(),tempV.begin(),tempV.end());
//abcdefg
//EXTV便是分裂的点
///////////////蒙皮信息
/*int _boneNum;
vector<Bone_st>boneL;
vector<INode*>boneInterL;*/
boneProcess(mesh_node,meshVertNum,beforeVN);

ProcessExt(extV,mesh_node,beforeVN);

}
void ProcessExt(vector<ExtV>&ext,NODE_MESH&mesh_node,DWORD beforeV)
{
int BoneNum=(int)g_BoneList.size();
int extN=(int)ext.size();
vertexNum+=extN;
int allFn=(int)faceVec.size();//现在所有的面数
int meshFn=mesh_node.pM->getNumFaces();//当前MESH面数
int beforeFN=allFn-meshFn;//之前面数;
for (int i=0;i<extN;i++)
{
DWORD orgIndex=beforeV+ext[i].meshVertexIndex;

Point3 pos=mesh_node.pM->verts[ ext[i].meshVertexIndex ];
int RealIndex=(int)vertPosVec.size();
vertPosVec.push_back(vertPosVec[orgIndex] );//顶点搞定
int fN=(int)ext[i].fniV.size();
for (int fI=0;fI <fN;fI++)
{
int FNN=beforeFN+ext[i].fniV[fI].faceIndex;
int p=2-ext[i].fniV[fI].i;
faceVec[FNN].i[p]=RealIndex;
//面索引搞定
}
if(isIncludeNormalData)
normalVec.push_back(normalVec[orgIndex]);
if(isIncludeVertexColor)
colorVec.push_back(colorVec[ orgIndex]) ;
if(isIncludeTexCoord)
texcoordVec.push_back( TEXCOORD(ext[i].u,ext[i].v) );
for (int boI=0;boI <BoneNum;boI++)
{//我认为是我的权重裂变出错了
int bInd=(int)g_BoneList.size()-BoneNum+boI;
vector <DWORD>& inI=g_BoneList[bInd].iniIndex;
vector <DWORD>::iterator iti=find(inI.begin(),inI.end(),orgIndex);
if (iti!= inI.end() )
{
DWORD locat=iti-inI.begin();
float weightt=g_BoneList[bInd].weight[locat];
g_BoneList[bInd].addOneVertex(RealIndex,weightt);
}
}

}
}

Modifier* GetMo(NODE_MESH&nodeMesh)
{
Object*pObj=nodeMesh.pN->GetObjectRef();
while (pObj->SuperClassID()==GEN_DERIVOB_CLASS_ID)
{
IDerivedObject *pDerObject = (IDerivedObject *)pObj;
int moNum=pDerObject- >NumModifiers();
for (int moIndex=0;moIndex <moNum;moIndex++)
{
Modifier*pMo=pDerObject- >GetModifier(moIndex);
if (pMo- >ClassID()==SKIN_CLASSID)
{
return pMo;
}
}
pObj=pDerObject- >GetObjRef();
}
return NULL;
}

void ProcessFrame(Interface *ip)
{
int BoneNum=(int)g_BoneList.size();
vector<Matrix3>boneInitML;
for (int i=0;i<BoneNum;i++)
{
Matrix3 initM=g_BoneList[i].pNode- >GetObjectTM(0);
initM.NoScale();
initM.Invert();
boneInitML.push_back(initM);
}
int tn=GetTicksPerFrame();
float interTime=TicksToSec(tn);
inter=interTime;
int startTick=ip->GetAnimRange().Start()/tn;
int endTick=ip->GetAnimRange().End()/tn;
frameNum=endTick-startTick+1;
for (int s=startTick;s<=endTick;s++)
{
for (int b=0;b <BoneNum;b++)
{
TimeValue t;
t=s*tn;
Matrix3 boneM= g_BoneList[b].pNode- >GetObjectTM(t);
boneM.NoScale();
Matrix3 finalM= boneInitML[b]*boneM;
finalM.NoScale();
Point3 transP= finalM.GetTrans();
Quat romate(finalM);
D3DXQUATERNION qua(romate.x,romate.z,romate.y,romate.w);
D3DXMATRIX romateMatrix;
D3DXMatrixRotationQuaternion( &romateMatrix,&qua);
romateMatrix._41=transP.x;
romateMatrix._43=transP.y;
romateMatrix._42=transP.z;
matrixList.push_back(romateMatrix);
}
}
}

bool isBone(INode*thisBone)
{
ObjectState pObs=thisBone->EvalWorldState(0);
if (pObs.obj->ClassID()==Class_ID(BONE_CLASS_ID,0))
{
return true;
}
if (pObs.obj->ClassID()==BONE_OBJ_CLASSID)
{
return true;
}
return false;
}
void AddBoneInfo(DWORD vertexIndex,float weight,INode*pNode)
{
Bone_st bst(pNode);
vector<Bone_st>::iterator loc=find(g_BoneList.begin(),g_BoneList.end(),bst);
if (loc==g_BoneList.end())
{
g_BoneList.push_back(bst);
g_BoneList[g_BoneList.size()-1].addOneVertex(vertexIndex,weight);
}
else
{
(*loc).addOneVertex(vertexIndex,weight);
}

}
Modifier* GetPSMo(NODE_MESH&nodeMesh)
{
INode*nodePtr=nodeMesh.pN;
Object* ObjectPtr = nodePtr->GetObjectRef();

if (!ObjectPtr) return NULL;

// Is derived object
while (ObjectPtr->SuperClassID() == GEN_DERIVOB_CLASS_ID && ObjectPtr)
{
// Yes - > Cast.
IDerivedObject *DerivedObjectPtr = (IDerivedObject *)(ObjectPtr);

// Iterate over all entries of the modifier stack.
int ModStackIndex = 0;
while (ModStackIndex < DerivedObjectPtr->NumModifiers())
{
// Get current modifier.
Modifier* ModifierPtr = DerivedObjectPtr- >GetModifier(ModStackIndex);

// Is this Physique
if (ModifierPtr->ClassID() == Class_ID(PHYSIQUE_CLASS_ID_A, PHYSIQUE_CLASS_ID_B))
{
// Yes - > Exit.
return ModifierPtr;
}

// Next modifier stack entry.
ModStackIndex++;
}
ObjectPtr = DerivedObjectPtr- >GetObjRef();
}

// Not found.
return NULL;

}
void boneProcessByPS(NODE_MESH&nodeMesh,int meshVerNum,int beforeVN)
{
Modifier*pM=GetPSMo(nodeMesh);
if (pM)
{
IPhysiqueExport *phyExport =(IPhysiqueExport*)pM- >GetInterface(I_PHYINTERFACE);
if (phyExport)
{
IPhyContextExport*pContextEx=phyExport- >GetContextInterface(nodeMesh.pN);
if (pContextEx)
{
pContextEx- >ConvertToRigid(TRUE);
for (int i=0;i <meshVerNum;i++)
{
IPhyVertexExport *vtxExport = pContextEx- >GetVertexInterface(i);
int vertexStyle=vtxExport- >GetVertexType();
if (vertexStyle==RIGID_TYPE)
{//只跟一个骨骼有联系
IPhyRigidVertex *vtxNoBlend = (IPhyRigidVertex *)vtxExport;
INode*pOneNode=vtxNoBlend- >GetNode();
float weight=1.0f;
AddBoneInfo(i+beforeVN,weight,pOneNode);
}
else if (vertexStyle==RIGID_BLENDED_TYPE)
{//混合型
IPhyBlendedRigidVertex *vtxBlend = (IPhyBlendedRigidVertex *)vtxExport;
int blendNum=vtxBlend- >GetNumberNodes();
for (int b=0;b <blendNum;b++)
{
INode*pN=vtxBlend- >GetNode(b);
float weight=vtxBlend- >GetWeight(b);
AddBoneInfo(i+beforeVN,weight,pN);
}
}
}
}
}

}
}
void boneProcessBySkin(NODE_MESH&nodeMesh,int meshVerNum,int beforeVN)
{
Modifier*pMo=GetMo(nodeMesh);

if (pMo)
{
ISkin*pSkin=(ISkin*)pMo- >GetInterface(I_SKIN);
if(pSkin)
{
ISkinContextData*pSkinData=pSkin- >GetContextInterface(nodeMesh.pN);
if (!pSkinData)
{
return;
}
for (int verIndex=0;verIndex <meshVerNum;verIndex++)
{
int BoneNum_infi_vert=pSkinData- >GetNumAssignedBones(verIndex);//得到顶点受到影响的骨骼数
for (int i=0;i <BoneNum_infi_vert;i++)
{
int boneIndex=pSkinData- >GetAssignedBone(verIndex,i);
INode*thisBone=pSkin- >GetBone(boneIndex);
float weight=0.0f;
if (isBone(thisBone))
{
weight=pSkinData- >GetBoneWeight(verIndex,i);
//向骨骼里列表里添加我们相应的顶点
AddBoneInfo(verIndex+beforeVN,weight,thisBone);

}
}

}

}
}
static void boneProcess(NODE_MESH &nodeMesh,int vn,int beforeVN)
{
boneProcessBySkin(nodeMesh,vn,beforeVN);
boneProcessByPS(nodeMesh,vn,beforeVN);
}
Interface*ip=NULL;
void CreateData()
{
if (meshVec.size()<=0)
{
return;
}
for_each(meshVec.begin(),meshVec.end(),meshProcess);
ProcessFrame(ip);
}
static INT_PTR CALLBACK ExportOptionsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch(message)
{
case WM_INITDIALOG:
CenterWindow(hDlg,GetParent(hDlg));
SetFocus(hDlg); // For some reason this was necessary. DS-3/4/96
CheckDlgButton(hDlg,IDC_CHECK1, TRUE);
return FALSE;
case WM_DESTROY:
return FALSE;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
isIncludeTexCoord = (IsDlgButtonChecked(hDlg,IDC_CHECK1)>0);
EndDialog(hDlg, 1);
return TRUE;
case IDCANCEL:
EndDialog(hDlg, 0);
return TRUE;
}
}
return FALSE;
}
void Reset()
{
meshOff=0;
boneOff=0;
animationOff=0;
isIncludeNormalData=true;
isIncludeVertexColor=0;
isIncludeTexCoord=0;
isOptimized=0;//是否优化
vertexNum=0;
faceNum=0;
materialNum=0;
vertPosVec.resize(0);
normalVec.resize(0);
colorVec.resize(0);
texcoordVec.resize(0);
faceVec.resize(0);
attributeSize=0;//=FACE
attributeBufferVec.resize(0);
materialVec.resize(0);

g_BoneList.resize(0);
matrixList.resize(0);
meshVec.resize(0);
texNameV.resize(0);
ip=NULL;
}
int d3export::DoExport(const TCHAR *name,ExpInterface *ei,Interface *i, BOOL suppressPrompts, DWORD options)
{
Reset();
int result=DialogBoxParam(hInstance,MAKEINTRESOURCE(IDD_DIALOG1),i->GetMAXHWnd(),ExportOptionsDlgProc,0);
if (result<=0)
{
return 0;
}
mylog.WriteFile("DO export!");
ip=i;
isExportSelect=true;
SceneEnumProc sep;
ei->theScene->EnumTree(&sep);//这个方法会调用SEP类的CALLBACK//这样MESHVEC里面就保存了所要的MESH了

CreateData();

我将写文件的的部分删掉了;你可以按照你的格式写自己的文件

数据就在我上面的全局变量里；

return IMPEXP_SUCCESS;
}

HINSTANCE hInstance;

class d3exportDesc :public ClassDesc
{
public:
int IsPublic()
{
return true;
}
void * Create(BOOL loading=FALSE)
{
return new d3export();
}
const TCHAR* ClassName()
{
return GetString(IDS_CLASSNAME);
}
SClass_ID SuperClassID()
{
return SCENE_EXPORT_CLASS_ID;
}
Class_ID ClassID()
{
return Class_ID(0x59290607, 0x3e1b6d46);
}
const TCHAR* Category()
{
return _T( "");
}