private void ParseDxsPrimitive(DxsPrimitive dxsPrim, Node parent, ModelLoaderParameters modelParams)
{
int k = 0;
dxsPrim.CompileMeshes(modelParams.NormalGeneration, modelParams.CreaseAngle, modelParams.SwapWindingOrder);
foreach (DxsMesh dxsMesh in dxsPrim.CompiledMeshes)
{
Mesh mesh;
if (k != 0)
{
mesh = new Mesh(dxsPrim.Name + k);
}
else
{
mesh = new Mesh(dxsPrim.Name);
}
//We transform the vertices to be centered around the origin, rotation/scale can't be determined from DeleD so
//only care about translation
mesh.Translation = dxsMesh.Translation;
MeshData md = mesh.MeshData;
DxsMaterial material = dxsPrim.Materials[dxsMesh.MaterialID];
int vertCount = dxsMesh.Vertices.Count;
DataBuffer <Vector3> positions = new DataBuffer <Vector3>(vertCount);
DataBuffer <Vector2> texCoords = null;
DataBuffer <Vector2> lightMapCoords = null;
DataBuffer <Color> colors = null;
DataBuffer <Vector3> normals = null;
if (material.HasTexture)
{
texCoords = new DataBuffer <Vector2>(vertCount);
}
if (material.HasLightMap)
{
lightMapCoords = new DataBuffer <Vector2>(vertCount);
}
if (dxsPrim.VertexColorEnabled)
{
colors = new DataBuffer <Color>(vertCount);
}
if (modelParams.NormalGeneration != NormalGeneration.None)
{
normals = new DataBuffer <Vector3>(vertCount);
}
foreach (DxsVertex v in dxsMesh.Vertices)
{
positions.Set(v.Position);
if (texCoords != null)
{
texCoords.Set(v.TextureCoordinate);
}
if (lightMapCoords != null)
{
lightMapCoords.Set(v.LightMapCoordinate);
}
if (colors != null)
{
colors.Set(v.VertexColor);
}
if (normals != null)
{
normals.Set(v.Normal);
}
}
md.Positions = positions;
md.Indices = dxsMesh.Indices;
if (texCoords != null)
{
md.TextureCoordinates = texCoords;
}
if (lightMapCoords != null)
{
md.AddBuffer(VertexSemantic.TextureCoordinate, 1, lightMapCoords);
}
if (colors != null)
{
md.Colors = colors;
}
if (normals != null)
{
md.Normals = normals;
}
//Build the material
mesh.Material = BuildMaterial(material, mesh, colors != null, normals != null, modelParams);
md.Reconstruct();
if (modelParams.GenerateTangentBasis)
{
mesh.ComputeTangentBasis();
}
parent.AddChild(mesh);
}
}
private Material BuildMaterial(DxsMaterial material, Mesh mesh, bool hasVertexColors, bool hasNormals, ModelLoaderParameters modelParams)
{
if (modelParams.UserMaterialFile != null)
{
return(ContentManager.Load <Material>(modelParams.UserMaterialFile).Clone());
}
bool hasTexture = material.HasTexture;
bool hasLightMap = material.HasLightMap;
bool useNormalMap = (hasNormals == true) && (modelParams.GenerateTangentBasis == true) && (modelParams.PreferLitMaterials == true);
Material mat;
if (useNormalMap)
{
if (hasVertexColors)
{
mat = ContentManager.Load <Material>("NormalMapVertColor.tem").Clone();
}
else
{
mat = ContentManager.Load <Material>("NormalMap.tem").Clone();
}
int num = 0;
foreach (DxsLayer layer in material.Layers)
{
if (num == 0)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("DiffuseMap", LoadTexture(layer.TextureFile, modelParams));
mat.SetParameter("UseDiffuseMap", true);
}
else if (layer.MaterialType == MaterialType.Color)
{
mat.SetParameter("MatDiffuse", layer.Color.ToVector3());
mat.SetParameter("UseDiffuseMap", false);
}
//Set blendstate
switch (layer.Blend)
{
case BlendType.Modulate:
mat.SetParameter("Alpha", .5f);
mat.SetRenderState(BlendState.AdditiveBlend);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
case BlendType.Add:
mat.SetRenderState(BlendState.AdditiveBlend);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
case BlendType.Alphablend:
mat.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
}
}
else if (num == 1)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("NormalMap", LoadTexture(layer.TextureFile, modelParams));
}
}
else if (num == 2)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("SpecularMap", LoadTexture(layer.TextureFile, modelParams));
mat.SetParameter("UseSpecularMap", true);
}
else
{
mat.SetParameter("UseSpecularMap", false);
}
break;
}
num++;
}
return(mat);
}
if (modelParams.PreferLitMaterials && hasNormals)
{
if (material.HasTexture)
{
if (hasVertexColors)
{
mat = ContentManager.Load <Material>("LitBasicVertColorTexture.tem").Clone();
}
else
{
mat = ContentManager.Load <Material>("LitBasicTexture.tem").Clone();
}
}
else
{
if (hasVertexColors)
{
mat = ContentManager.Load <Material>("LitBasicVertColor.tem").Clone();
}
else
{
mat = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
}
}
int num = 0;
foreach (DxsLayer layer in material.Layers)
{
if (num == 0)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("DiffuseMap", LoadTexture(layer.TextureFile, modelParams));
}
else if (layer.MaterialType == MaterialType.Color)
{
mat.SetParameter("MatDiffuse", layer.Color.ToVector3());
}
//Set blendstate
switch (layer.Blend)
{
case BlendType.Modulate:
mat.SetParameter("Alpha", .5f);
mat.SetRenderState(BlendState.AdditiveBlend);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
case BlendType.Add:
mat.SetRenderState(BlendState.AdditiveBlend);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
case BlendType.Alphablend:
mat.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
mesh.SceneHints.RenderBucketType = RenderBucketType.Transparent;
break;
}
}
else if (num == 1)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("DiffuseMap", LoadTexture(layer.TextureFile, modelParams));
}
break;
}
num++;
}
}
else
{
if (material.HasTexture)
{
if (hasVertexColors)
{
mat = ContentManager.Load <Material>("BasicVertColorTexture.tem").Clone();
}
else
{
mat = ContentManager.Load <Material>("BasicTexture.tem").Clone();
}
}
else
{
if (hasVertexColors)
{
mat = ContentManager.Load <Material>("BasicVertColor.tem").Clone();
}
else
{
mat = ContentManager.Load <Material>("BasicColor.tem").Clone();
}
}
int num = 0;
foreach (DxsLayer layer in material.Layers)
{
if (num == 0)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("DiffuseMap", LoadTexture(layer.TextureFile, modelParams));
}
else
{
if (layer.MaterialType == MaterialType.Color)
{
mat.SetParameter("DiffuseColor", layer.Color.ToVector4());
}
}
//Set blendstate
switch (layer.Blend)
{
case BlendType.Modulate:
if (layer.MaterialType == MaterialType.Color)
{
mat.SetParameter("DiffuseColor", new Color(layer.Color.ToVector3(), .5f).ToVector4());
}
mat.SetRenderState(BlendState.AdditiveBlend);
break;
case BlendType.Add:
mat.SetRenderState(BlendState.AdditiveBlend);
break;
case BlendType.Alphablend:
mat.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
break;
}
}
else if (num == 1)
{
if (layer.MaterialType == MaterialType.Texture)
{
mat.SetParameter("DiffuseMap", LoadTexture(layer.TextureFile, modelParams));
}
break;
}
num++;
}
}
return(mat);
}
