`
micheal19840929
  • 浏览: 167258 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

ms3d 文件格式

阅读更多

最近实验室接了一个项目,开发一个虚拟现实平台,用来展示海底场景,能够对海洋各种环境进行实时渲染,并对以鱼类为主的生物进行形态和行为仿真,设计并实现其基本动作.主要内容有用三维建模,雾化,粒子系统等模拟海底空间效果,对光,影,雾,浪,水流等进行实时渲染.

技术关键问题及解决途径:1)     虚拟海底场景实时生成:通过借助图形处理器(GPU),利用NVIDIA推出的Cg语言编程对海底场景相关的水体、光影效果进行实时渲染;2)     鱼类表面纹理的细节表现:通过使用动态纹理,光影计算以及OpenGL库的纹理映射方法等表现鱼类等的表面纹理细节,使其与所在的海底环境相配合;
平台中对鱼类的动作仿真是难点之一,打算采用ms3d文件,从模型中读取数据,进行渲染.

//                MilkShape 3D 1.8.2 File Format Specification
//
//
//                  This specifcation is written in C style.
//
//
// The data structures are defined in the order as they appear in the .ms3d file.
//
//
//
//
//



//
// max values
//
#define MAX_VERTICES    65534
#define MAX_TRIANGLES   65534
#define MAX_GROUPS      255
#define MAX_MATERIALS   128
#define MAX_JOINTS      128



//
// flags
//
#define SELECTED        1
#define HIDDEN          2
#define SELECTED2       4
#define DIRTY           8



//
// types
//
#ifndef byte
typedef unsigned char byte;
#endif // byte

#ifndef word
typedef unsigned short word;
#endif // word


// force one byte alignment
#include <pshpack1.h>

//
// First comes the header (sizeof(ms3d_header_t) == 14)
//
typedef struct
{
    char    id[10];                                     // always "MS3D000000"
    int     version;                                    // 4
} ms3d_header_t;

//
// Then comes the number of vertices
//
word nNumVertices; // 2 bytes

//
// Then come nNumVertices times ms3d_vertex_t structs (sizeof(ms3d_vertex_t) == 15)
//
typedef struct
{
    byte    flags;                                      // SELECTED | SELECTED2 | HIDDEN
    float   vertex[3];                                  //
    char    boneId;                                     // -1 = no bone
    byte    referenceCount;
} ms3d_vertex_t;

//
// Then comes the number of triangles
//
word nNumTriangles; // 2 bytes

//
// Then come nNumTriangles times ms3d_triangle_t structs (sizeof(ms3d_triangle_t) == 70)
//
typedef struct
{
    word    flags;                                      // SELECTED | SELECTED2 | HIDDEN
    word    vertexIndices[3];                           //
    float   vertexNormals[3][3];                        //
    float   s[3];                                       //
    float   t[3];                                       //
    byte    smoothingGroup;                             // 1 - 32
    byte    groupIndex;                                 //
} ms3d_triangle_t;

//
// Then comes the number of groups
//
word nNumGroups; // 2 bytes

//
// Then come nNumGroups times groups (the sizeof a group is dynamic, because of triangleIndices is numtriangles long)
//
typedef struct
{
    byte            flags;                              // SELECTED | HIDDEN
    char            name[32];                           //
    word            numtriangles;                       //
    word            triangleIndices[numtriangles];      // the groups group the triangles
    char            materialIndex;                      // -1 = no material
} ms3d_group_t;

//
// number of materials
//
word nNumMaterials; // 2 bytes

//
// Then come nNumMaterials times ms3d_material_t structs (sizeof(ms3d_material_t) == 361)
//
typedef struct
{
    char            name[32];                           //
    float           ambient[4];                         //
    float           diffuse[4];                         //
    float           specular[4];                        //
    float           emissive[4];                        //
    float           shininess;                          // 0.0f - 128.0f
    float           transparency;                       // 0.0f - 1.0f
    char            mode;                               // 0, 1, 2 is unused now
    char            texture[128];                        // texture.bmp
    char            alphamap[128];                       // alpha.bmp
} ms3d_material_t;

//
// save some keyframer data
//
float fAnimationFPS; // 4 bytes
float fCurrentTime; // 4 bytes
int iTotalFrames; // 4 bytes

//
// number of joints
//
word nNumJoints; // 2 bytes

//
// Then come nNumJoints joints (the size of joints are dynamic, because each joint has a differnt count of keys
//
typedef struct // 16 bytes
{
    float           time;                               // time in seconds
    float           rotation[3];                        // x, y, z angles
} ms3d_keyframe_rot_t;

typedef struct // 16 bytes
{
    float           time;                               // time in seconds
    float           position[3];                        // local position
} ms3d_keyframe_pos_t;

typedef struct
{
    byte            flags;                              // SELECTED | DIRTY
    char            name[32];                           //
    char            parentName[32];                     //
    float           rotation[3];                        // local reference matrix
    float           position[3];

    word            numKeyFramesRot;                    //
    word            numKeyFramesTrans;                  //

    ms3d_keyframe_rot_t keyFramesRot[numKeyFramesRot];      // local animation matrices
    ms3d_keyframe_pos_t keyFramesTrans[numKeyFramesTrans];  // local animation matrices
} ms3d_joint_t;

//
// Then comes the subVersion of the comments part, which is not available in older files
//
int subVersion; // subVersion is = 1, 4 bytes

// Then comes the numer of group comments
unsigned int nNumGroupComments; // 4 bytes

//
// Then come nNumGroupComments times group comments, which are dynamic, because the comment can be any length
//
typedef struct
{
 int index;  // index of group, material or joint
 int commentLength;  // length of comment (terminating '\0' is not saved), "MC" has comment length of 2 (not 3)
 char comment[commentLength];  // comment
} ms3d_comment_t;

// Then comes the number of material comments
int nNumMaterialComments; // 4 bytes

//
// Then come nNumMaterialComments times material comments, which are dynamic, because the comment can be any length
//

// Then comes the number of joint comments
int nNumJointComments; // 4 bytes

//
// Then come nNumJointComments times joint comments, which are dynamic, because the comment can be any length
//

// Then comes the number of model comments, which is always 0 or 1
int nHasModelComment; // 4 bytes

//
// Then come nHasModelComment times model comments, which are dynamic, because the comment can be any length
//


// Then comes the subversion of the vertex extra information like bone weights, extra etc.
int subVersion;  // subVersion is = 2, 4 bytes

// ms3d_vertex_ex_t for subVersion == 1
typedef struct
{
 char boneIds[3]; // index of joint or -1, if -1, then that weight is ignored, since subVersion 1
 byte weights[3]; // vertex weight ranging from 0 - 255, last weight is computed by 1.0 - sum(all weights), since subVersion 1
 // weight[0] is the weight for boneId in ms3d_vertex_t
 // weight[1] is the weight for boneIds[0]
 // weight[2] is the weight for boneIds[1]
 // 1.0f - weight[0] - weight[1] - weight[2] is the weight for boneIds[2]
} ms3d_vertex_ex_t;

// ms3d_vertex_ex_t for subVersion == 2
typedef struct
{
 char boneIds[3]; // index of joint or -1, if -1, then that weight is ignored, since subVersion 1
 byte weights[3];  // vertex weight ranging from 0 - 100, last weight is computed by 1.0 - sum(all weights), since subVersion 1
 // weight[0] is the weight for boneId in ms3d_vertex_t
 // weight[1] is the weight for boneIds[0]
 // weight[2] is the weight for boneIds[1]
 // 1.0f - weight[0] - weight[1] - weight[2] is the weight for boneIds[2]
 unsigned int extra; // vertex extra, which can be used as color or anything else, since subVersion 2
} ms3d_vertex_ex_t;

// Then comes nNumVertices times ms3d_vertex_ex_t structs (sizeof(ms3d_vertex_ex_t) == 10)

// Then comes the subversion of the joint extra information like color etc.
int subVersion;  // subVersion is = 2, 4 bytes

// ms3d_joint_ex_t for subVersion == 1
typedef struct
{
 float color[3]; // joint color, since subVersion == 1
} ms3d_joint_ex_t;

// Then comes nNumJoints times ms3d_joint_ex_t structs (sizeof(ms3d_joint_ex_t) == 12)

// Then comes the subversion of the model extra information
int subVersion;  // subVersion is = 1, 4 bytes

// ms3d_model_ex_t for subVersion == 1
typedef struct
{
 float jointSize; // joint size, since subVersion == 1
 int transparencyMode; // 0 = simple, 1 = depth buffered with alpha ref, 2 = depth sorted triangles, since subVersion == 1
 float alphaRef; // alpha reference value for transparencyMode = 1, since subVersion == 1
} ms3d_model_ex_t;

#include <poppack.h>


//
// Mesh Transformation:
// 
// 0. Build the transformation matrices from the rotation and position
// 1. Multiply the vertices by the inverse of local reference matrix (lmatrix0)
// 2. then translate the result by (lmatrix0 * keyFramesTrans)
// 3. then multiply the result by (lmatrix0 * keyFramesRot)
//
// For normals skip step 2.
//
//
//
// NOTE:  this file format may change in future versions!
//
//
// - Mete Ciragan
//

 

读取程序:

文件头:ms3dfile.H

#ifndef word
typedef unsigned short word;
#endif // word

typedef struct
{
    char    id[10];                                     // always "MS3D000000"
    int     version;                                    // 4
} ms3d_header_t;

typedef struct
{
    byte    flags;                                      // SELECTED | SELECTED2 | HIDDEN
    float   vertex[3];                                  //
    char    boneId;                                     // -1 = no bone
    byte    referenceCount;
} ms3d_vertex_t;

typedef struct
{
    word    flags;                                      // SELECTED | SELECTED2 | HIDDEN
    word    vertexIndices[3];                           //
    float   vertexNormals[3][3];                        //
    float   s[3];                                       //
    float   t[3];                                       //
    byte    smoothingGroup;                             // 1 - 32
    byte    groupIndex;                                 //
} ms3d_triangle_t;

typedef struct
{
 word edgeIndices[2];
} ms3d_edge_t;

typedef struct
{
    byte            flags;                              // SELECTED | HIDDEN
    char            name[32];                           //
    word            numtriangles;                       //
 word*   triangleIndices;     // the groups group the triangles
    char            materialIndex;                      // -1 = no material
} ms3d_group_t;

typedef struct
{
    char            name[32];                           //
    float           ambient[4];                         //
    float           diffuse[4];                         //
    float           specular[4];                        //
    float           emissive[4];                        //
    float           shininess;                          // 0.0f - 128.0f
    float           transparency;                       // 0.0f - 1.0f
    char            mode;                               // 0, 1, 2 is unused now
    char            texture[128];                        // texture.bmp
    char            alphamap[128];                       // alpha.bmp
} ms3d_material_t;

typedef struct
{
    float           time;                               // time in seconds
    float           rotation[3];                        // x, y, z angles
} ms3d_keyframe_rot_t;

typedef struct
{
    float           time;                               // time in seconds
    float           position[3];                        // local position
} ms3d_keyframe_pos_t;

typedef struct
{
    byte            flags;                              // SELECTED | DIRTY
    char            name[32];                           //
    char            parentName[32];                     //
    float           rotation[3];                        // local reference matrix
    float           position[3];

    word            numKeyFramesRot;                    //
    word            numKeyFramesTrans;                  //

 ms3d_keyframe_rot_t* keyFramesRot;      // local animation matrices
    ms3d_keyframe_pos_t* keyFramesTrans;  // local animation matrices
} ms3d_joint_t;

#include <poppack.h>

class CMS3DFileI;
class CMS3DFile
{
public:
 CMS3DFile();
 virtual ~CMS3DFile();

public:
 bool LoadFromFile(const char* lpszFileName);
 void Clear();

 int GetNumVertices();
 void GetVertexAt(int nIndex, ms3d_vertex_t **ppVertex);
 int GetNumTriangles();
 void GetTriangleAt(int nIndex, ms3d_triangle_t **ppTriangle);
 int GetNumEdges();
 void GetEdgeAt(int nIndex, ms3d_edge_t **ppEdge);
 int GetNumGroups();
 void GetGroupAt(int nIndex, ms3d_group_t **ppGroup);
 int GetNumMaterials();
 void GetMaterialAt(int nIndex, ms3d_material_t **ppMaterial);
 int GetNumJoints();
 void GetJointAt(int nIndex, ms3d_joint_t **ppJoint);
 int FindJointByName(const char* lpszName);

 float GetAnimationFPS();
 float _GetCurrentTime();
 int GetTotalFrames();

private:
 CMS3DFileI *_i;

private:
 CMS3DFile(const CMS3DFile& rhs);
 CMS3DFile& operator=(const CMS3DFile& rhs);
};

#endif // _MS3DFILE_H_ 

文件ms3dfile.CPP

#pragma warning(disable : 4786)
#include "MS3DFile.h"
#include <set>
#include <vector>

#define MAKEDWORD(a, b)      ((unsigned int)(((word)(a)) | ((word)((word)(b))) << 16))

class CMS3DFileI
{
public:
 std::vector<ms3d_vertex_t> arrVertices;
 std::vector<ms3d_triangle_t> arrTriangles;
 std::vector<ms3d_edge_t> arrEdges;
 std::vector<ms3d_group_t> arrGroups;
 std::vector<ms3d_material_t> arrMaterials;
 float fAnimationFPS;
 float fCurrentTime;
 int iTotalFrames;
 std::vector<ms3d_joint_t> arrJoints;

public:
 CMS3DFileI()
 : fAnimationFPS(24.0f),
  fCurrentTime(0.0f),
  iTotalFrames(0)
 {
 }
};

CMS3DFile::CMS3DFile()
{
 _i = new CMS3DFileI();
}

CMS3DFile::~CMS3DFile()
{
 delete _i;
}

bool CMS3DFile::LoadFromFile(const char* lpszFileName)
{
 FILE *fp = fopen(lpszFileName, "rb");
 if (!fp)
  return false;

 size_t i;
 ms3d_header_t header;
 fread(&header, 1, sizeof(ms3d_header_t), fp);

 if (strncmp(header.id, "MS3D000000", 10) != 0)
  return false;

 if (header.version != 4)
  return false;

 // vertices
 word nNumVertices;
 fread(&nNumVertices, 1, sizeof(word), fp);
 _i->arrVertices.resize(nNumVertices);
 fread(&_i->arrVertices[0], nNumVertices, sizeof(ms3d_vertex_t), fp);

 // triangles
 word nNumTriangles;
 fread(&nNumTriangles, 1, sizeof(word), fp);
 _i->arrTriangles.resize(nNumTriangles);
 fread(&_i->arrTriangles[0], nNumTriangles, sizeof(ms3d_triangle_t), fp);

 // edges
 std::set<unsigned int> setEdgePair;
 for (i = 0; i < _i->arrTriangles.size(); i++)
 {
  word a, b;
  a = _i->arrTriangles[i].vertexIndices[0];
  b = _i->arrTriangles[i].vertexIndices[1];
  if (a > b)
   std::swap(a, b);
  if (setEdgePair.find(MAKEDWORD(a, b)) == setEdgePair.end())
   setEdgePair.insert(MAKEDWORD(a, b));

  a = _i->arrTriangles[i].vertexIndices[1];
  b = _i->arrTriangles[i].vertexIndices[2];
  if (a > b)
   std::swap(a, b);
  if (setEdgePair.find(MAKEDWORD(a, b)) == setEdgePair.end())
   setEdgePair.insert(MAKEDWORD(a, b));

  a = _i->arrTriangles[i].vertexIndices[2];
  b = _i->arrTriangles[i].vertexIndices[0];
  if (a > b)
   std::swap(a, b);
  if (setEdgePair.find(MAKEDWORD(a, b)) == setEdgePair.end())
   setEdgePair.insert(MAKEDWORD(a, b));
 }

 for(std::set<unsigned int>::iterator it = setEdgePair.begin(); it != setEdgePair.end(); ++it)
 {
  unsigned int EdgePair = *it;
  ms3d_edge_t Edge;
  Edge.edgeIndices[0] = (word) EdgePair;
  Edge.edgeIndices[1] = (word) ((EdgePair >> 16) & 0xFFFF);
  _i->arrEdges.push_back(Edge);
 }

 // groups
 word nNumGroups;
 fread(&nNumGroups, 1, sizeof(word), fp);
 _i->arrGroups.resize(nNumGroups);
 for (i = 0; i < nNumGroups; i++)
 {
  fread(&_i->arrGroups[i].flags, 1, sizeof(byte), fp);
  fread(&_i->arrGroups[i].name, 32, sizeof(char), fp);
  fread(&_i->arrGroups[i].numtriangles, 1, sizeof(word), fp);
  _i->arrGroups[i].triangleIndices = new word[_i->arrGroups[i].numtriangles];
  fread(_i->arrGroups[i].triangleIndices, _i->arrGroups[i].numtriangles, sizeof(word), fp);
  fread(&_i->arrGroups[i].materialIndex, 1, sizeof(char), fp);
 }

 // materials
 word nNumMaterials;
 fread(&nNumMaterials, 1, sizeof(word), fp);
 _i->arrMaterials.resize(nNumMaterials);
 fread(&_i->arrMaterials[0], nNumMaterials, sizeof(ms3d_material_t), fp);

 fread(&_i->fAnimationFPS, 1, sizeof(float), fp);
 fread(&_i->fCurrentTime, 1, sizeof(float), fp);
 fread(&_i->iTotalFrames, 1, sizeof(int), fp);

 // joints
 word nNumJoints;
 fread(&nNumJoints, 1, sizeof(word), fp);
 _i->arrJoints.resize(nNumJoints);
 for (i = 0; i < nNumJoints; i++)
 {
  fread(&_i->arrJoints[i].flags, 1, sizeof(byte), fp);
  fread(&_i->arrJoints[i].name, 32, sizeof(char), fp);
  fread(&_i->arrJoints[i].parentName, 32, sizeof(char), fp);
  fread(&_i->arrJoints[i].rotation, 3, sizeof(float), fp);
  fread(&_i->arrJoints[i].position, 3, sizeof(float), fp);
  fread(&_i->arrJoints[i].numKeyFramesRot, 1, sizeof(word), fp);
  fread(&_i->arrJoints[i].numKeyFramesTrans, 1, sizeof(word), fp);
  _i->arrJoints[i].keyFramesRot = new ms3d_keyframe_rot_t[_i->arrJoints[i].numKeyFramesRot];
  _i->arrJoints[i].keyFramesTrans = new ms3d_keyframe_pos_t[_i->arrJoints[i].numKeyFramesTrans];
  fread(_i->arrJoints[i].keyFramesRot, _i->arrJoints[i].numKeyFramesRot, sizeof(ms3d_keyframe_rot_t), fp);
  fread(_i->arrJoints[i].keyFramesTrans, _i->arrJoints[i].numKeyFramesTrans, sizeof(ms3d_keyframe_pos_t), fp);
 }

 fclose(fp);

 return true;
}

void CMS3DFile::Clear()
{
 _i->arrVertices.clear();
 _i->arrTriangles.clear();
 _i->arrEdges.clear();
 _i->arrGroups.clear();
 _i->arrMaterials.clear();
 _i->arrJoints.clear();
}

int CMS3DFile::GetNumVertices()
{
 return (int) _i->arrVertices.size();
}

void CMS3DFile::GetVertexAt(int nIndex, ms3d_vertex_t **ppVertex)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrVertices.size())
  *ppVertex = &_i->arrVertices[nIndex];
}

int CMS3DFile::GetNumTriangles()
{
 return (int) _i->arrTriangles.size();
}

void CMS3DFile::GetTriangleAt(int nIndex, ms3d_triangle_t **ppTriangle)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrTriangles.size())
  *ppTriangle = &_i->arrTriangles[nIndex];
}

int CMS3DFile::GetNumEdges()
{
 return (int) _i->arrEdges.size();
}

void CMS3DFile::GetEdgeAt(int nIndex, ms3d_edge_t **ppEdge)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrEdges.size())
  *ppEdge = &_i->arrEdges[nIndex];
}

int CMS3DFile::GetNumGroups()
{
 return (int) _i->arrGroups.size();
}

void CMS3DFile::GetGroupAt(int nIndex, ms3d_group_t **ppGroup)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrGroups.size())
  *ppGroup = &_i->arrGroups[nIndex];
}

int CMS3DFile::GetNumMaterials()
{
 return (int) _i->arrMaterials.size();
}

void CMS3DFile::GetMaterialAt(int nIndex, ms3d_material_t **ppMaterial)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrMaterials.size())
  *ppMaterial = &_i->arrMaterials[nIndex];
}

int CMS3DFile::GetNumJoints()
{
 return (int) _i->arrJoints.size();
}

void CMS3DFile::GetJointAt(int nIndex, ms3d_joint_t **ppJoint)
{
 if (nIndex >= 0 && nIndex < (int) _i->arrJoints.size())
  *ppJoint = &_i->arrJoints[nIndex];
}

int CMS3DFile::FindJointByName(const char* lpszName)
{
 for (size_t i = 0; i < _i->arrJoints.size(); i++)
 {
  if (!strcmp(_i->arrJoints[i].name, lpszName))
   return i;
 }

 return -1;
}

float CMS3DFile::GetAnimationFPS()
{
 return _i->fAnimationFPS;
}

float CMS3DFile::_GetCurrentTime()
{
 return _i->fCurrentTime;
}

int CMS3DFile::GetTotalFrames()
{
 return _i->iTotalFrames;
}

 

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/whoismickey/archive/2009/01/13/3767899.aspx

http://blog.csdn.net/guokeno1/archive/2006/10/11/1330764.aspx

分享到:
评论

相关推荐

    ms3d文件分析

    ms3d文件结构描述,可以用于OpenGL的渲染。

    ms3d程序代码ms3d程序代码

    MS3D文件格式的主要组成部分包括: 1. **顶点**:每个顶点包含位置、法线、纹理坐标等信息。 2. **三角面**:模型由多个三角面构成,每个三角面由三个顶点组成,并可能包含颜色信息。 3. **关节/骨骼**:用于实现...

    用OPENGL读取MS3D文件

    用OPENGL读取MS3D文件,包括程序,可运行文件,MS3D模型文件,相应的BMP图片。

    Java3d MS3D加载器(含源码,模型,加载器)

    1. **MS3D文件格式**:MS3D文件由多个部分组成,包括顶点数据、三角形信息、骨骼、关节、关键帧和动画数据等。加载器需要理解这些结构,才能正确地解析文件并构建出3D模型。 2. **模型解析**:加载器首先读取文件头...

    ms3d教程一套

    1. **MS3D格式详解**:理解MS3D文件结构,包括顶点、面、骨骼、动画帧等组成部分,以及它们在模型数据中的表示方式。 2. **3D建模基础**:学习基本的3D几何体创建、编辑和组合,以及如何进行平滑组和UV映射,以实现...

    ms3d-loader

    MS3D文件包含了模型的顶点信息、三角形、骨骼、关节、动画等元素。在"MS3D.cpp"中,代码会解析这些数据结构,将模型加载到内存中。这通常涉及到读取二进制文件,解析头信息,然后逐个处理顶点、纹理坐标、法线、颜色...

    opengl加载.ms3d格式的三维模型

    该代码是在linux系统下opengl编程实现的.ms3d文件格式的三维模型的加载,包含纹理贴体,材质属性等

    演示ms3d动画的例子

    这涉及到理解MS3D文件的二进制格式,解析顶点、面、纹理坐标、骨骼和动画关键帧等信息。 3. **3D矩阵运算**:`matrix.c`包含用于处理3D空间变换的函数,如旋转、平移和缩放。这些矩阵运算对于正确地定位和绘制3D...

    MS3D1.8.5{告别晴窗}汉化免杀版

    为了满足不断增长的市场需求,专业的三维建模工具软件应运而生,而“MS3D1.8.5{告别晴窗}汉化免杀版”便是其中一款引人瞩目的产品,它不仅为中文用户提供了便利,也展现了软件在易用性和安全性方面的独特考量。...

    ms3d格式帮助文档

    ms3d格式,全称为“MilkShape 3D”模型格式,是由瑞士软件公司Virtual World Entertainment开发的一款三维建模工具MilkShape 3D所使用的专属模型文件格式。这个格式在游戏开发领域,尤其是初学者中较为流行,因为它...

    Hands On MilkShape 的MS3D模型文件

    MS3D(MilkShape 3D)模型文件格式是专为游戏设计而优化的,它以紧凑和高效的方式保存数据,便于在游戏引擎中快速加载和渲染。通过学习这些模型文件,读者可以了解如何创建、编辑和导出3D模型,以及如何设置骨骼动画...

    MS3D模型骨骼动画

    5. **文件结构解析**:MS3D格式文件中包含了模型顶点、面、骨骼等信息,需要编写专门的解析代码来读取这些数据。 #### 六、结论 综上所述,骨骼动画相比于顶点动画具有更多优势,尤其是在处理复杂角色动画时表现...

    MS3D人物骨骼动画

    MILKSPACE 3D是一款专门用来打开和编辑MS3D文件的软件。它提供了一个直观的界面,让使用者可以方便地查看和修改骨骼结构,创建和调整动画关键帧。此外,该软件还支持动画预览,使得艺术家能在实际操作中直观看到动画...

    3dmax加密脚本mse解密为非加密ms格式工具.rar

    3dmax加密脚本mse解密为非加密ms格式工具.rar 内附使用方法

    读取ms3d格式的三维模型,含动画显示的源代码.zip

    为了显示动画,程序需要解析MS3D文件中的关键帧数据,通过插值计算每个关节在每一帧的位置和旋转,然后应用这些变化到相应的骨骼上,完成模型的动态变形。 7. **矩阵运算**: 矩阵在3D图形学中用于表示几何变换。...

    <3D GameEngine Programming> MS3D To CBF

    MS3D文件支持包括顶点、纹理坐标、骨骼动画在内的多种3D模型元素。这种格式因其轻便和兼容性而被许多游戏开发者采用,特别是在较小规模的游戏项目中。 CBF格式,虽然名字未在描述中明确定义,但通常情况下,它是指...

    ms3d1.8.2

    4. **导出功能**:Milkshape 3D的一个强项是它的导出选项,它支持许多游戏引擎的文件格式,如Valve的 Source Engine (VTF, VMT)、Blender的OBJ、3D Studio Max的3DS,以及Unreal Engine的ASE等。 "ms3d182setup.exe...

    加载milk3D文件的程序

    对于程序员来说,能够有效地加载和处理ms3D文件是一项重要的技能。 加载milk3D文件的程序通常涉及到以下几个关键步骤: 1. 文件解析:首先,程序需要解析ms3D文件的二进制格式。这个过程包括识别文件头信息,确定...

    安川机器人3D模型 MS165

    描述中的“安川yaskawa机器人 MS165 stp格式3D模型及dwg 动作范围尺寸等”提到了模型的两种文件格式:STP和DWG。STP(STEP)是一种国际标准的3D模型交换格式,能够保持几何数据的精度和完整性,适用于不同CAD软件...

    3D格式总结

    在3D图形编程领域,特别是在移动平台如Android上的游戏开发中,了解和使用不同的3D模型文件格式是至关重要的。本文主要介绍两种常见的3D模型格式:MD2和MS3D。 一、MD2:MD2(Quake2 Model Format)是由Quake2游戏...

Global site tag (gtag.js) - Google Analytics