public static void Convert(string source, string dest)
{
FileStream fs = File.Open(source, FileMode.Open, FileAccess.Read);
DX.Mesh mesh = DX.Mesh.FromStream(device, fs, DX.MeshFlags.Managed);
DX.ExtendedMaterial[] mats = mesh.GetMaterials();
Material[][] outMats = new Material[mats.Length][];
for (int i = 0; i < mats.Length; i++)
{
outMats[i] = new Material[1];
outMats[i][0] = new Material(null);
DX.Material mat = mats[i].MaterialD3D;
SlimDX.Color4 clr = mat.Ambient;
outMats[i][0].Ambient = new Color4F(clr.Alpha, clr.Red, clr.Green, clr.Blue);
clr = mat.Diffuse;
outMats[i][0].Diffuse = new Color4F(clr.Alpha, clr.Red, clr.Green, clr.Blue);
clr = mat.Specular;
outMats[i][0].Specular = new Color4F(clr.Alpha, clr.Red, clr.Green, clr.Blue);
outMats[i][0].SetTextureFile(0, mats[i].TextureFileName);
}
string name = Path.GetFileNameWithoutExtension(source);
//EditableMesh outMesh = new EditableMesh(name, mesh, outMats);
MeshData data = new MeshData((RenderSystem)null);
data.Name = name;
data.Materials = outMats;
BuildFromMesh(mesh, data, outMats);
EditableModel outMdl = new EditableModel();
//mesh.Dispose();
outMdl.Entities = new MeshData[] { data };
//TransformAnimation transAnim = new TransformAnimation(1);
//transAnim.Nodes[0].Transforms = new Matrix[1] { Matrix.Identity };
//outMdl.SetTransformAnimInst(new TransformAnimationInstance(transAnim));
EditableModel.ToFile(outMdl, dest);
}
public SceneImportResult LoadStaticMesh(string filename)
{
var file = new FileInfo(filename);
VertexDescriptor vd = VertexDescriptor.Get <ModelVertex>();
List <MeshLayer> layers = new List <MeshLayer>();
int[] adjacency;
ExtendedMaterial[] meshMaterials;
Mesh mesh = new Mesh(vd);
List <MeshMaterial> material = new List <MeshMaterial>();
using (SlimDX.Direct3D9.Mesh d3dMesh = SlimDX.Direct3D9.Mesh.FromFile(Engine.Graphics, filename, MeshFlags.Managed))
{
adjacency = d3dMesh.GetAdjacency();
meshMaterials = d3dMesh.GetMaterials();
for (int i = 0; i < meshMaterials.Length; i++)
{
var matd3d = meshMaterials[i].MaterialD3D;
string textureFilename = meshMaterials[i].TextureFileName;
if (textureFilename != null && !Path.IsPathRooted(textureFilename))
{
textureFilename = Path.Combine(Path.GetDirectoryName(filename), textureFilename);
}
material.Add(new MeshMaterial()
{
Name = file.Name + "_material" + i,
Alpha = matd3d.Diffuse.Alpha,
Diffuse = matd3d.Diffuse.ToVector3(),
Specular = matd3d.Specular.ToVector3(),
SpecularPower = Math.Max(1, matd3d.Power),
Reflectivity = 0,
Refractitity = 0,
EmissiveColor = matd3d.Emissive.ToVector3(),
DiffuseMap = textureFilename != null && File.Exists(textureFilename) ?
textureFilename : null
});
}
ModelVertex[] vertexes = new ModelVertex[d3dMesh.VertexCount];
Array indices;
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
indices = new ushort[d3dMesh.FaceCount * 3];
}
else
{
indices = new uint[d3dMesh.FaceCount * 3];
}
DataStream vertexStream = d3dMesh.LockVertexBuffer(0);
VertexDescriptor meshVD = new VertexDescriptor(d3dMesh.GetDeclaration());
int positionOffset = meshVD.GetOffset(DeclarationUsage.Position, 0);
int normalOffset = meshVD.GetOffset(DeclarationUsage.Normal, 0);
int texCoordOffset = meshVD.GetOffset(DeclarationUsage.TextureCoordinate, 0);
byte[] buffer;
unsafe
{
buffer = new byte[vertexStream.Length];
vertexStream.Read(buffer, 0, (int)vertexStream.Length);
fixed(byte *_pter = buffer)
{
byte *pter = _pter;
for (int i = 0; i < d3dMesh.VertexCount; i++)
{
vertexes[i].Position = *((Vector3 *)(pter + positionOffset));
if (normalOffset > 0)
{
vertexes[i].Normal = *((Vector3 *)(pter + normalOffset));
}
if (texCoordOffset > 0)
{
vertexes[i].TexCoord = *((Vector2 *)(pter + texCoordOffset));
}
pter += d3dMesh.BytesPerVertex;
}
}
d3dMesh.UnlockVertexBuffer();
DataStream indexStream = d3dMesh.LockIndexBuffer(0);
GCHandle handler = GCHandle.Alloc(indices, GCHandleType.Pinned);
byte * indexPter = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(indices, 0);
buffer = new byte[indexStream.Length];
indexStream.Read(buffer, 0, (int)indexStream.Length);
for (int i = 0; i < indexStream.Length; i++)
{
indexPter[i] = buffer[i];
}
handler.Free();
d3dMesh.UnlockIndexBuffer();
}
mesh.CreateVertexBuffer(vertexes);
if (d3dMesh.IndexBuffer.Description.Format == Format.Index16)
{
mesh.CreateIndexBuffer((ushort[])indices);
}
else
{
mesh.CreateIndexBuffer((uint[])indices);
}
var d3dComponents = d3dMesh.GetAttributeTable();
if (d3dComponents == null)
{
MeshLayer component = new MeshLayer();
layers.Add(component);
material.Add(MeshMaterial.CreateDefaultMaterial(file.Name + "_default"));
component.materialIndex = 0;
component.primitiveCount = mesh.FaceCount;
component.startIndex = 0;
component.startVertex = 0;
component.vertexCount = mesh.VertexCount;
}
else
{
for (int i = 0; i < d3dComponents.Length; i++)
{
AttributeRange ar = d3dComponents[i];
MeshLayer component = new MeshLayer();
layers.Add(component);
component.materialIndex = ar.AttribId;
component.primitiveCount = ar.FaceCount;
component.startIndex = ar.FaceStart * 3;
component.startVertex = ar.VertexStart;
component.vertexCount = ar.VertexCount;
}
}
mesh.Materials = material.ToArray();
mesh.SetLayers(layers.ToArray());
if (normalOffset < 0)
{
mesh.ComputeNormals();
}
if (texCoordOffset < 0)
{
mesh.ComputeTextureCoords(CoordMappingType.Spherical);
}
mesh.ComputeTangents();
meshVD.Dispose();
}
StaticMeshSceneNode meshNode = new StaticMeshSceneNode(file.Name, mesh);
return(new SceneImportResult {
VisualSceneRoot = meshNode, VisualMaterials = material
});
}
