截取3D游戏模型为obj格式

最新推荐文章于 2024-06-14 09:31:29 发布
最新推荐文章于 2024-06-14 09:31:29 发布
阅读量776 收藏
点赞数
分类专栏： 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/twopointfive/article/details/85055286
版权

将任意d3d9游戏的模型截取到obj格式：工具下载

1，将d3d9.dll、snapconfig.cfg拷贝或覆盖到游戏运行目录（若果原先已经有d3d9.dll，则先备份以便还原）。

 

2，运行游戏，所有贴图和模型会自动保存到运行目录的SnapMesh文件夹。

 

3，截取完后不在使用时记得将d3d9.dll删除或还原，否则每次启动都会截取导致游戏很卡。

 

snapconfig.cfg配置说明：

[config]

snapAllTexture = 1           是否截取所有贴图（1是 包括ui贴图，0否 只截取模型贴图）

snapMesh = 1                  是否截取模型

snapMeshNormal = 0       是否截取模型法线信息

snapIndexSeprate = 0      是否将同一缓冲区的不同段作为不同的模型截取

minMeshTrigonNum = 1   截取模型最小面数

logDrawCount = 0            日志记录数

worldTransform = 0          是否使用世界坐标系（否则模型坐标系）

flipTexCoordV = 1            是否反转V向纹理坐标

 

原理：

新的d3d9.dll实际起到了一个代理作用。每次绘制结束保存纹理和模型。

这个技术同样适用于制作带有游戏内界面的外挂程序。

 

 

部分代码

 

void IDirect3DDevice9Proxy::ExportMesh()
{
if (G_Config.m_snapMesh==false)
{
return;
}
m_textureCoordExported=false;
m_pOriIDirect3DDevice9->GetIndices(&m_pIndexBuffer);
m_iIndexBuffer = (int)m_pIndexBuffer;

int startIndex = m_startIndex;
if (G_Config.m_snapIndexSeprate==0)
{
startIndex = 0;
}

MeshKey key;
key.m_indexPointer = m_iIndexBuffer;
key.m_startIndex = startIndex;
key.m_primcount = m_PrimitiveCount;

if (m_drawType==D_DrawIndexedPrimitive
&&m_pIndexBuffer
&&G_SavedMesh.find(key)==G_SavedMesh.end()
&&(m_PrimitiveType==D3DPT_TRIANGLELIST||m_PrimitiveType==D3DPT_TRIANGLESTRIP||m_PrimitiveType==D3DPT_TRIANGLEFAN)
&&m_PrimitiveCount>=G_Config.m_minMeshTrigonNum
)
{
IDirect3DBaseTexture9* pTexture=NULL;
int stage = 0;
bool get = false;
while (stage<8)
{
HRESULT res = m_pOriIDirect3DDevice9->GetTexture(stage,&pTexture);
if (pTexture)
{
get = true;
break;
}
//G_FastLog.OutputStr("GetTexture() return %d!",(int)res);
stage++;
}
if (pTexture==NULL)
{
int stage = 0;
while (stage<8)
{
pTexture = m_pTexture[stage];
if (pTexture)
{
break;
}
stage++;
}
}

//文理有可能已经释放重新加载，而指针值正巧相等，所以重新保存一下
if(pTexture)
{
char buf[256];
//texture在前以便排序剔除重复纹理
sprintf(buf,"SnapMesh\\%d_%d_%d.png",(int)pTexture,m_iIndexBuffer,startIndex);
D3DXSaveTextureToFile(buf, D3DXIFF_PNG, pTexture, NULL);
//GetTexture加了引用技术，需要释放
if(get)pTexture->Release();
}

G_SavedMesh.insert(key);
///
for (UINT i=0;i<8;i++)
{
m_pOriIDirect3DDevice9->GetStreamSource(i,m_pStreamVertexBuffer+i,m_streamOffsetInBytes+i,m_streamStride+i);
}

m_pIndexBuffer->GetDesc(&m_indexBufferDesc);

//if (SUCCEEDED(m_pOriIDirect3DDevice9->GetStreamSource(0,&pStreamData,&OffsetInBytes,&Stride)))
{
IDirect3DVertexDeclaration9* pDecl=NULL;
if (SUCCEEDED(m_pOriIDirect3DDevice9->GetVertexDeclaration(&pDecl)))
{
if (pDecl==NULL)
{
//DWORD FVF;
//if (SUCCEEDED(m_pOriIDirect3DDevice9->GetFVF(&FVF)))
//{
// if (FVF&D3DFVF_XYZ)
// {
// }
// if (FVF&D3DFVF_TEX2)
// {
// }
//}
}
else
{
if (SUCCEEDED(pDecl->GetDeclaration(m_vertexElement,&m_numElements)))
{
//
char buf[256];
sprintf(buf,"SnapMesh\\%d_%d.obj",m_iIndexBuffer,startIndex);
LogExportMesh();

//写入obj文件
FILE* file = fopen(buf, "wb");
if(file)
{
fprintf(file,"# exported by crapell engine!");
fprintf(file,"\n");
fprintf(file,"\n");

char mtlFileNameLocal[256];
sprintf(mtlFileNameLocal,"%d_%d.mtl",m_iIndexBuffer,startIndex);
fprintf(file,"mtllib %s ",mtlFileNameLocal);
fprintf(file,"\n");

fprintf(file,"# new object: ");
fprintf(file,"onemesh");
fprintf(file,"\n");

fprintf(file,"g ");
fprintf(file,"onemesh");
fprintf(file,"\n");

fprintf(file,"usemtl ");

char mtlFileName[256];
sprintf(mtlFileName,"SnapMesh\\%d_%d_%d.png",(int)pTexture,m_iIndexBuffer,startIndex);
fprintf(file,mtlFileName);
fprintf(file,"\n");

//输出数据流注释
for (UINT is=0;is<4;is++)
{
if (m_streamStride[is]<=0)
{
break;
}
fprintf(file,"# stream source[%d]: offset %d; stride %d;",is,m_streamOffsetInBytes[is],m_streamStride[is]);
fprintf(file,"\n");
}

fprintf(file,"# vertex element num:%d",m_numElements);
fprintf(file,"\n");

for (UINT e=0;e<m_numElements;e++)
{
int istream = m_vertexElement[e].Stream;
fprintf(file,"# vertex element[%d]:stream index%d; usage %s; type %s; offset in stride%d;",e,istream,usagename[m_vertexElement[e].Usage],typename_[m_vertexElement[e].Type],m_vertexElement[e].Offset);
fprintf(file,"\n");
if(istream==255)
{
break;
}
}

if(m_indexBufferDesc.Format==D3DFMT_INDEX32)
{
fprintf(file,"# %s: base vertex %d; vertex num %d; prim count %d; format INDEX32; type %s;",drawtypename[m_drawType],m_BaseVertexIndex,m_NumVertices,m_PrimitiveCount,primitivetypename_[m_PrimitiveType]);
}
else if(m_indexBufferDesc.Format==D3DFMT_INDEX16)
{
fprintf(file,"# %s: base vertex %d; vertex num %d; prim count %d; format INDEX16; type %s;",drawtypename[m_drawType],m_BaseVertexIndex,m_NumVertices,m_PrimitiveCount,primitivetypename_[m_PrimitiveType]);
}
else
{
fprintf(file,"# %s: base vertex %d; vertex num %d; prim count %d; format unknow; type %s;",drawtypename[m_drawType],m_BaseVertexIndex,m_NumVertices,m_PrimitiveCount,primitivetypename_[m_PrimitiveType]);
}
fprintf(file,"\n");

D3DXMATRIX wordMat;
D3DXMATRIX wordMatN;
D3DXVECTOR3 pos;
D3DXVECTOR4 res;
if (G_Config.m_worldTransform)
{
m_pOriIDirect3DDevice9->GetTransform(D3DTS_WORLD,&wordMat);
wordMatN = wordMat;
wordMatN(3,0)=0;
wordMatN(3,1)=0;
wordMatN(3,2)=0;
}

fprintf(file,"\n");

//输出真正数据
{
for (UINT e=0;e<m_numElements;e++)
{
int istream = m_vertexElement[e].Stream;
if(istream==255)
{
break;
}

if (m_vertexElement[e].Usage==D3DDECLUSAGE_POSITION)
{
char* bufferData;
if(SUCCEEDED(m_pStreamVertexBuffer[istream]->Lock(m_BaseVertexIndex * m_streamStride[istream], m_NumVertices * m_streamStride[istream], (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=m_BaseVertexIndex;pnum<m_NumVertices;pnum++)
{
fprintf(file,"v ");
switch (m_vertexElement[e].Type)
{
case D3DDECLTYPE_FLOAT3:
case D3DDECLTYPE_FLOAT4:
{
float* v = (float*)(bufferData+m_vertexElement[e].Offset);
if (G_Config.m_worldTransform)
{
pos.x = *v;
pos.y = *(v+1);
pos.z = *(v+2);
D3DXVec3Transform(&res,&pos,&wordMat);
fprintf(file,"%f %f %f ",res.x,res.y,res.z);
}
else
{
fprintf(file,"%f %f %f ",*v,*(v+1),*(v+2));
}
}
break;
//case D3DDECLTYPE_SHORT3:
case D3DDECLTYPE_SHORT4:
{
short* v = (short*)(bufferData+m_vertexElement[e].Offset);
if (G_Config.m_worldTransform)
{
pos.x = *v;
pos.y = *(v+1);
pos.z = *(v+2);
D3DXVec3Transform(&res,&pos,&wordMat);
fprintf(file,"%f %f %f ",res.x,res.y,res.z);
}
else
{
fprintf(file,"%f %f %f ",float(*v),float(*(v+1)),float(*(v+2)));
}
}
break;
}
bufferData+=m_streamStride[istream];
//fprintf(file,"# buffer pointer %d ",v);
fprintf(file,"\n");
}
}
m_pStreamVertexBuffer[istream]->Unlock();
//}
}
else if (m_vertexElement[e].Usage==D3DDECLUSAGE_NORMAL)
{
if (G_Config.m_snapMeshNormal)
{
char* bufferData;
if(SUCCEEDED(m_pStreamVertexBuffer[istream]->Lock(m_BaseVertexIndex * m_streamStride[istream], m_NumVertices * m_streamStride[istream], (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=m_BaseVertexIndex;pnum<m_NumVertices;pnum++)
{
fprintf(file,"vn ");
switch (m_vertexElement[e].Type)
{
case D3DDECLTYPE_FLOAT3:
case D3DDECLTYPE_FLOAT4:
{
float* v = (float*)(bufferData+m_vertexElement[e].Offset);
if (G_Config.m_worldTransform)
{
pos.x = *v;
pos.y = *(v+1);
pos.z = *(v+2);
D3DXVec3Transform(&res,&pos,&wordMatN);
fprintf(file,"%f %f %f ",res.x,res.y,res.z);
}
else
{
fprintf(file,"%f %f %f ",*v,*(v+1),*(v+2));
}
}
break;
//case D3DDECLTYPE_SHORT3:
case D3DDECLTYPE_SHORT4:
{
short* v = (short*)(bufferData+m_vertexElement[e].Offset);
if (G_Config.m_worldTransform)
{
pos.x = *v;
pos.y = *(v+1);
pos.z = *(v+2);
D3DXVec3Transform(&res,&pos,&wordMatN);
fprintf(file,"%f %f %f ",res.x,res.y,res.z);
}
else
{
fprintf(file,"%f %f %f ",float(*v),float(*(v+1)),float(*(v+2)));
}
}
case D3DDECLTYPE_SHORT4N:
{
short* v = (short*)(bufferData+m_vertexElement[e].Offset);
if (G_Config.m_worldTransform)
{
pos.x = *v;
pos.y = *(v+1);
pos.z = *(v+2);
D3DXVec3Transform(&res,&pos,&wordMatN);
fprintf(file,"%f %f %f ",res.x,res.y,res.z);
}
else
{
fprintf(file,"%f %f %f ",float(*v),float(*(v+1)),float(*(v+2)));
}
}
break;
}
bufferData+=m_streamStride[istream];
//fprintf(file,"# buffer pointer %d ",v);
fprintf(file,"\n");
}
}
m_pStreamVertexBuffer[istream]->Unlock();
//}
}
}
else if (m_vertexElement[e].Usage==D3DDECLUSAGE_TEXCOORD)
{
if (m_textureCoordExported==false)
{
m_textureCoordExported=true;
char* bufferData;
if(SUCCEEDED(m_pStreamVertexBuffer[istream]->Lock(m_BaseVertexIndex * m_streamStride[istream], m_NumVertices * m_streamStride[istream], (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=m_BaseVertexIndex;pnum<m_NumVertices;pnum++)
{
fprintf(file,"vt ");
switch (m_vertexElement[e].Type)
{
case D3DDECLTYPE_FLOAT3:
case D3DDECLTYPE_FLOAT4:
{
float* v = (float*)(bufferData+m_vertexElement[e].Offset);
if(G_Config.m_flipTexCoordV)
fprintf(file,"%f %f %f ",*v,1-*(v+1),*(v+2));
else
fprintf(file,"%f %f %f ",*v,*(v+1),*(v+2));
}
break;
case D3DDECLTYPE_FLOAT2:
{
float* v = (float*)(bufferData+m_vertexElement[e].Offset);
if(G_Config.m_flipTexCoordV)
fprintf(file,"%f %f %f ",*v,1-*(v+1),1.0f);
else
fprintf(file,"%f %f %f ",*v,*(v+1),1.0f);
}
break;
case D3DDECLTYPE_SHORT4:
{
short* v = (short*)(bufferData+m_vertexElement[e].Offset);
if(G_Config.m_flipTexCoordV)
fprintf(file,"%f %f %f ",(float)*v,(float)(1-*(v+1)),(float)*(v+2));
else
fprintf(file,"%f %f %f ",(float)*v,(float)(*(v+1)),(float)*(v+2));
}
break;
case D3DDECLTYPE_SHORT2:
{
short* v = (short*)(bufferData+m_vertexElement[e].Offset);
if(G_Config.m_flipTexCoordV)
fprintf(file,"%f %f %f ",(float)*v,(float)(1-*(v+1)),1);
else
fprintf(file,"%f %f %f ",(float)*v,(float)(*(v+1)),1);
}
break;
}
bufferData+=m_streamStride[istream];
fprintf(file,"\n");
}
}
m_pStreamVertexBuffer[istream]->Unlock();
}
}
}
}

//输出索引
int offset = -m_MinVertexIndex+m_BaseVertexIndex;
if (m_PrimitiveType==D3DPT_TRIANGLELIST)
{
if(m_indexBufferDesc.Format==D3DFMT_INDEX16)
{
short int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(short int), m_PrimitiveCount*3 * sizeof(short int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
(*bufferData)+offset+1,(*bufferData)+offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData+=3;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
else
{
int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(int), m_PrimitiveCount*3 * sizeof(int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
(*bufferData)+offset+1,(*bufferData)+offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData+=3;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
}
else if (m_PrimitiveType==D3DPT_TRIANGLESTRIP)
{
if(m_indexBufferDesc.Format==D3DFMT_INDEX16)
{
short int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(short int), (m_PrimitiveCount+2) * sizeof(short int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
(*bufferData)+offset+1,(*bufferData)+offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData++;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
else
{
int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(int), (m_PrimitiveCount+2) * sizeof(int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
(*bufferData)+offset+1,(*bufferData)+offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData++;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
}
else if (m_PrimitiveType==D3DPT_TRIANGLEFAN)
{
if(m_indexBufferDesc.Format==D3DFMT_INDEX16)
{
short int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(short int), (m_PrimitiveCount+2) * sizeof(short int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
offset+1,offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData++;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
else
{
int* bufferData;
if(SUCCEEDED(m_pIndexBuffer->Lock(m_startIndex * sizeof(int), (m_PrimitiveCount+2) * sizeof(int), (void**)&bufferData, D3DLOCK_READONLY)))
{
for (int pnum=0;pnum<m_PrimitiveCount;)
{
fprintf(file,"f ");
//v/t
fprintf(file,"%d/%d %d/%d %d/%d ",
offset+1,offset+1,
(*(bufferData+1))+offset+1,(*(bufferData+1)+offset+1),
(*(bufferData+2))+offset+1,(*(bufferData+2))+offset+1);
bufferData++;
pnum++;
fprintf(file,"\n");
}
m_pIndexBuffer->Unlock();
}
}
}
fclose(file);
}


材质
char mtlFileName[256];
sprintf(mtlFileName,"SnapMesh\\%d_%d.mtl",m_iIndexBuffer,startIndex);
FILE* mtlfile = fopen(mtlFileName, "wb");
if(mtlfile)
{
fprintf(mtlfile,"# exported by crapell engine!");
fprintf(mtlfile,"\n");
fprintf(mtlfile,"\n");
fprintf(mtlfile,"newmtl ");
sprintf(buf,"SnapMesh\\%d_%d_%d.png",(int)pTexture,m_iIndexBuffer,startIndex);
fprintf(mtlfile,buf);
fprintf(mtlfile,"\n");

fprintf(mtlfile,"Ka 1.0 1.0 1.0 ");
fprintf(mtlfile,"\n");

fprintf(mtlfile,"Kd 1.0 1.0 1.0 ");
fprintf(mtlfile,"\n");

fprintf(mtlfile,"Ks 0.2 0.2 0.2 ");
fprintf(mtlfile,"\n");

fprintf(mtlfile,"Ns 32 ");
fprintf(mtlfile,"\n");

fprintf(mtlfile,"map_Kd %s ",buf);
fprintf(mtlfile,"\n");

fprintf(mtlfile,"\n");
fclose(mtlfile);
}
}
pDecl->Release();
}
}
}

for (UINT i=0;i<8;i++)
{
m_pOriIDirect3DDevice9->GetStreamSource(i,m_pStreamVertexBuffer+i,m_streamOffsetInBytes+i,m_streamStride+i);
if (m_pStreamVertexBuffer[i])
{
m_pStreamVertexBuffer[i]->Release();
}
}
}
if (m_pIndexBuffer)
{
m_pIndexBuffer->Release();
}
m_drawType=D_DrawTriPatch;
}

void IDirect3DDevice9Proxy::ExportTexture(IDirect3DBaseTexture9* pTexture)
{
if (G_Config.m_snapAllTexture==false)
{
return;
}

char buf[256];
sprintf(buf,"SnapMesh\\texture\\%d.png",(int)pTexture);
if (G_SavedTexture.find((int)pTexture)==G_SavedTexture.end())
{
D3DXSaveTextureToFile(buf, D3DXIFF_PNG, pTexture, NULL);
G_SavedTexture.insert((int)pTexture);
}
}

娄磊lorry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
3DRipperDX-游戏模型截取器
01-30
压缩包内包含三部分内容： A，3DRipperDX截取器； B，max导入插件； C，DDS图片快速查看器； 其中max插件包含以下版本：max5.6.7.8.9.2009（x86&x64）.2010（x86&x64）.2011（x86&x64）， 亲测max8版本可用。模型提取正常。其余版本未测试。 测试提取了 战地2 游戏的模型。
如何截取3D网游模型
痞子龙3D编程
03-16 2408
网络游戏工具【GameAssassin】[/color> 是一个针对网络游戏和3D游戏的辅助工具，具有设置3D游戏的线框显示模式，截获3D游戏的模型贴图数据等功能，针对于网络游戏，此软件能够接获游戏所发 出并且接受的网络消息，并且能够向服务器直接发送外部的自定义数据。如果想截游戏模型，首先要到GA的官方下载相关软件和插件。下载地址 只需下载GA和导入MAX用的插件就可以。首先是激活功能，这是必须做
探索游戏世界：Apicula——DS游戏模型提取神器
最新发布
gitblog_00035的博客
06-14 368
探索游戏世界：Apicula——DS游戏模型提取神器 项目地址:https://gitcode.com/scurest/apicula 在数字娱乐的领域里，探索和理解游戏内部构造总是一件激动人心的事情。今天，我们向您推荐一个独特的开源工具——Apicula。这个强大的工具能够从任天堂DS（DS）游戏中提取3D模型，并进行查看与转换，为游戏爱好者和开发者提供了一个全新的窗口，去了解并操作那些隐藏在...
3d游戏模型提取神器 N+ Ripper （Nijia Ripper）版本1.71
05-19
功能介绍 1、用于截取3D遊戲中的模型,贴图和著色器(仅限DirectX 8,DirectX 9和DirectX 11程序) 2、提取所有可用的模型的頂點信息，包括所有的紋理坐標，法線，重量，BLENDWEIGHT，BLENDINDICES，副法線，切線，指數，紋理，著色器。 3、截取出來的模型都是*.rip格式,压缩包里已有一个ninja_importer.ms的3DS MAX导入插件
游戏里的角色都什么格式图片_截取游戏3D模型并导入Mathematica
weixin_39765588的博客
12-19 282
Background首先Mathematica可以导入3维模型，并且进行一些简单贴图效果制作，还可以修改与组合再生成三维打印的模型。 其次，在游戏中截取一些模型是满足个性化需求的一种手段。 比如你自己喜欢的或拥有的某个游戏的某个角色在指定的姿态。 本文介绍下截取模型这个事情对于普通大众的一个现状，并给出一个把截取的模型导入Mathematica并贴图的一个示例。示例因为后面扯了点历史+文字，因此这...
[转]3D Ripper DX模型截取器
weixin_30402343的博客
05-15 1169
http://www.modchina.com/thread-23358-1-1.html 3D RIPPER DX可以将任何DirectX 9.0以上程序和游戏的模型及贴图在运行过程中截取出来（模型导出为.3DR格式），不光是CC3和RA3，甚至连王牌空战的加密模型都可以提取出来，不需要解游戏的打包文件 缺点是截出来的模型是歪的，需要在3DS MAX下使用“FFD 2X2X2”修...
教程教你如何截取3D网游模型.doc
10-07
3D 网游模型截取教程 本文档提供了使用 GameAssassin（GA）工具截取 3D 网游模型的教程。GameAssassin 是一个针对网络游戏和 3D 游戏的辅助工具，具有设置 3D 游戏的线框显示模式，截获 3D 游戏的模型贴图数据等...
3D Ripper DX
07-15
该软件主要针对3D游戏，通过实时捕捉游戏场景，将游戏中的三维模型和贴图导出到本地，供用户进行二次创作或者研究。这些模型通常以常见的3D格式如OBJ、FBX或3DS保存，而贴图则可能以PNG、JPG等图像格式存在。这样，...
ninjaripper1.7.1-模型提取工具.zip
02-01
它可以解析游戏的内部文件格式，将这些模型转换为通用的3D格式，如OBJ或FBX，以便在其他软件中进行编辑或查看。 - **纹理提取**：除了模型，NinjaRipper还能提取游戏中的贴图和纹理，这包括颜色、法线、镜面反射等...
游戏资源截取软件3DRipperDXSetup
10-31
在捕获到资源后，3DRipperDX会将其保存为常见的3D模型格式（如FBX、OBJ），以及纹理和动画文件，便于用户后期编辑和使用。 使用3DRipperDX进行资源截取通常涉及以下步骤： 1. **安装与配置**：下载3DRipperDXSetup...
NJ黑色猎手1.7.1.rar
03-07
"ripdump.exe"是NJ黑色猎手的核心执行文件，它负责解析游戏内存中的3D模型数据，并将其转化为可编辑的格式。"help_ru.txt"是俄文的帮助文档，对于熟悉俄语的用户来说，是额外的参考资料。"x64"和"x86"两个文件夹分别...
ninjaripper:来自 DX11DX9DX8 游戏的 3D 模型纹理着色器
07-04
NINJA RIPPER 用于直接从正在运行的游戏中提取/翻录 3d 模型（网格）、纹理、着色器的实用程序。 当前版本：1.1.2 开膛手 RIPPER FEATURES 提取模型的所有可用顶点信息（位置、所有纹理坐标、法线、权重、BLENDWEIGHT、BLENDINDICES、BINORMAL、TANGENT）、索引、纹理、着色器。 理论上所有提取的信息都可以导入到 3D 编辑器中！ 支持 D3D11、D3D9、D3D8（已处理，但并非所有方法/技术，但应适用于所有游戏的 95%）。 RIPPER 功能描述 • 目标（DX8、DX9、DX11 应用程序）： • Exe - 应用程序/游戏可执行文件的直接路径字段 • Arg - 可执行文件的附加设置字段 • Dir - 包含可执行文件的文件夹的直接路径字段（当您选择 . exe，默认无需更改） • No Wrapper - 撕裂者
3D_obj模型
10-12
可以用three.js加载的Obj模型，可以用photoshop打开下。
3DRipperDX 游戏模型提取软件
05-09
(3DRipperDX 游戏模型提取软件可以提取游戏中的模型
游戏模型提取工具ninjaripper_细节模型工具 houdini游戏工具（四）
weixin_39781452的博客
11-21 3757
前段时间把包括一些新增的游戏工具都看了下，一是可以扩展下思维，二是防止在百忙之中一时冲动重复造轮子。但是也发现很多工具没有介绍莫名其妙，或者比较鸡肋，又或者不完整bug丛生，所以搁置了段时间。后面觉得还是推荐一些好用或者有意思可以开眼见的工具，顺便内容中做些小场景普及下houdini在数字生成艺术作品当中的作用，当然可能都是一些简单的，太难的暂时还不会。 题图就是这次最后...
游戏资源提取常用工具索引
痞子龙3D编程
03-15 2万+
常用工具： 1、3D Ripper DX：DX模型截取器，原名3D Ripper 2、GameAssassin：屏幕模型截取 3、sculptris-alpha：导出OBJ 4、Susie：支持游戏图片格式最多的看图工具。建议配合ViX、Linar等支持Susie插件的看图工具一起使用，提取图片十分快捷。 5、Grapholic：有一定年头的看图软件，不过有部分老游戏的图片格式只有它支持
3D游戏模型提取、导入、导出教程
热门推荐
愤怒的小小强
11-30 6万+
本教程转自 http://geek.prdsarea.com/forum.php?mod=viewthread&tid=891&fromuid=282846 (出处: http://geek.prdsarea.com/) 这个是我的第二个教程，这个教程的主要内容是教大家如何提取3D游戏里的模型，因为有一些3D游戏里面的模型非常精致，例如有一些人物模型或者场景模型。这样大大方便了模型的
如何把obj格式转化为三维模型
04-03
可以使用以下步骤将OBJ格式转换为三维模型： 1. 打开三维建模软件，例如Blender。 2. 在软件中选择导入OBJ文件的选项。 3. 选择OBJ文件并点击导入。 4. 检查导入的模型是否正确。有时候，导入的模型可能需要进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值