/// <summary>
/// Creats a new instance of PaletteInfo.
/// </summary>
/// <param name="sourceCode">The source code for the BasicPaletteEffect</param>
/// <param name="paletteSize">The size of the matrix palette</param>
/// <param name="basicContent">The BasicMaterialContent that stores the parameters
/// to copy to BasicPaletteEffect</param>
public PaletteInfo(string sourceCode, int paletteSize,
BasicMaterialContent basicContent)
{
this.sourceCode = sourceCode;
this.paletteSize = paletteSize;
this.basicContent = basicContent;
}
/// <summary>
/// Processes a PaletteInfo object into a PaletteMaterialContent object.
/// </summary>
/// <param name="input">The PaletteInfo to process.</param>
/// <param name="context">The processor context.</param>
/// <returns>The processed PaletteMaterialContent</returns>
public override PaletteMaterialContent Process(PaletteInfo input,
ContentProcessorContext context)
{
#if XNA4
throw new NotImplementedException();
#else
// Set all the variables based on the input.
EffectProcessor effectProcessor = new EffectProcessor();
EffectContent effectContent = new EffectContent();
effectContent.EffectCode = input.SourceCode;
CompiledEffect compiled;
if (context.TargetPlatform == TargetPlatform.Xbox360)
{
compiled = Effect.CompileEffectFromSource(
input.SourceCode, null, null, CompilerOptions.None, TargetPlatform.Xbox360);
}
else
{
compiled = effectProcessor.Process(effectContent, context);
}
PaletteMaterialContent content = new PaletteMaterialContent();
content.PaletteSize = input.PaletteSize;
content.ByteCode = compiled.GetEffectCode();
BasicMaterialContent basic = input.BasicContent;
content.Alpha = basic.Alpha;
content.DiffuseColor = basic.DiffuseColor;
content.EmissiveColor = basic.EmissiveColor;
content.Name = basic.Name;
content.SpecularColor = basic.SpecularColor;
content.SpecularPower = basic.SpecularPower;
content.Texture = basic.Texture;
content.VertexColorEnabled = basic.VertexColorEnabled;
return(content);
#endif
}
/// <summary>
/// Called when a basic effect is encountered and potentially replaced by
/// BasicPaletteEffect (if not overridden). This is called afer effects have been processed.
/// </summary>
/// <param name="skinningType">The the skinning type of the meshpart.</param>
/// <param name="meshPart">The MeshPart that contains the BasicMaterialContent.</param>
protected virtual void ReplaceBasicEffect(SkinningType skinningType,
ModelMeshPartContent meshPart)
{
BasicMaterialContent basic = meshPart.Material as BasicMaterialContent;
if (basic != null)
{
// Create a new PaletteSourceCode object and set its palette size
// based on the platform since xbox has fewer registers.
PaletteSourceCode source;
if (context.TargetPlatform != TargetPlatform.Xbox360)
{
source = new PaletteSourceCode(56);
}
else
{
source = new PaletteSourceCode(40);
}
// Process the material and set the meshPart material to the new
// material.
PaletteInfoProcessor processor = new PaletteInfoProcessor();
meshPart.Material = processor.Process(
new PaletteInfo(source.SourceCode4BonesPerVertex,
source.PALETTE_SIZE, basic), context);
}
}
/// <summary>
/// Processes a PaletteInfo object into a PaletteMaterialContent object.
/// </summary>
/// <param name="input">The PaletteInfo to process.</param>
/// <param name="context">The processor context.</param>
/// <returns>The processed PaletteMaterialContent</returns>
public override PaletteMaterialContent Process(PaletteInfo input,
ContentProcessorContext context)
{
// Set all the variables based on the input.
EffectProcessor effectProcessor = new EffectProcessor();
EffectContent effectContent = new EffectContent();
effectContent.EffectCode = input.SourceCode;
CompiledEffect compiled = effectProcessor.Process(effectContent, context);
PaletteMaterialContent content = new PaletteMaterialContent();
content.PaletteSize = input.PaletteSize;
content.ByteCode = compiled.GetEffectCode();
BasicMaterialContent basic = input.BasicContent;
content.Alpha = basic.Alpha;
content.DiffuseColor = basic.DiffuseColor;
content.EmissiveColor = basic.EmissiveColor;
content.Name = basic.Name;
content.SpecularColor = basic.SpecularColor;
content.SpecularPower = basic.SpecularPower;
content.Texture = basic.Texture;
content.VertexColorEnabled = basic.VertexColorEnabled;
return(content);
}
/// <summary>
/// Changes all the materials to use our skinned model effect.
/// </summary>
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
BasicMaterialContent basicMaterial = material as BasicMaterialContent;
if (basicMaterial == null)
{
throw new InvalidContentException(string.Format(
"SkinnedModelProcessor only supports BasicMaterialContent, " +
"but input mesh uses {0}.", material.GetType()));
}
EffectMaterialContent effectMaterial = new EffectMaterialContent();
// Store a reference to our skinned mesh effect.
string effectPath = Path.GetFullPath("SkinnedModel.fx");
effectMaterial.Effect = new ExternalReference <EffectContent>(effectPath);
// Copy texture settings from the input
// BasicMaterialContent over to our new material.
if (basicMaterial.Texture != null)
{
effectMaterial.Textures.Add("Texture", basicMaterial.Texture);
}
// Chain to the base ModelProcessor converter.
return(base.ConvertMaterial(effectMaterial, context));
}
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
BasicMaterialContent basicMaterial = material as BasicMaterialContent;
if (basicMaterial == null)
{
context.Logger.LogImportantMessage("This mesh doesn't have a valid basic material.");
}
// Only process meshs with basic material
// Otherwise the mesh must be using the correct shader (AnimatedModel.fx)
if (basicMaterial != null)
{
EffectMaterialContent effectMaterial = new EffectMaterialContent();
effectMaterial.Effect = new ExternalReference <EffectContent>(EFFECTS_PATH +
EFFECT_FILENAME);
// Correct the texture path
if (basicMaterial.Texture != null)
{
string textureFileName = Path.GetFileName(basicMaterial.Texture.Filename);
effectMaterial.Textures.Add("diffuseTexture1",
new ExternalReference <TextureContent>(TEXTURES_PATH + textureFileName));
}
return(base.ConvertMaterial(effectMaterial, context));
}
else
{
return(base.ConvertMaterial(material, context));
}
}
private static Dictionary <Material, MaterialContent> GetMaterials(Scene scene)
{
Dictionary <Material, MaterialContent> materials = new Dictionary <Material, MaterialContent>();
foreach (Material material in scene.Materials)
{
BasicMaterialContent materialContent = new BasicMaterialContent
{
Name = material.Name,
Identity = new ContentIdentity(material.FileName),
Alpha = material.Transparency,
DiffuseColor = ConvertColorRgbF(material.DiffuseColor),
SpecularColor = ConvertColorRgbF(material.SpecularColor),
SpecularPower = material.Shininess,
VertexColorEnabled = false,
};
if (!string.IsNullOrEmpty(material.DiffuseTextureName))
{
materialContent.Texture = new ExternalReference <TextureContent>(material.DiffuseTextureName);
}
materials.Add(material, materialContent);
}
return(materials);
}
/// <summary>
/// Converts a material.
/// </summary>
public override MaterialContent Process(MaterialContent input,
ContentProcessorContext context)
{
// Create a new effect material.
EffectMaterialContent customMaterial = new EffectMaterialContent();
// Point the new material at our custom effect file.
string effectFile = Path.GetFullPath("Shaders/ShipEffect.fx");
customMaterial.Effect = new ExternalReference <EffectContent>(effectFile);
// Copy texture data across from the original material.
BasicMaterialContent basicMaterial = (BasicMaterialContent)input;
if (basicMaterial.Texture != null)
{
customMaterial.Textures.Add("DiffuseTexture", basicMaterial.Texture);
customMaterial.OpaqueData.Add("TextureEnabled", true);
}
// Add in the Normal and Specular maps
string normalTexture = basicMaterial.Texture.Filename.Replace("_c", "_n");
string specularTexture = basicMaterial.Texture.Filename.Replace("_c", "_s");
string emissiveTexture = basicMaterial.Texture.Filename.Replace("_c", "_i");
customMaterial.Textures.Add("SpecularTexture",
new ExternalReference <TextureContent>(specularTexture));
customMaterial.Textures.Add("NormalTexture",
new ExternalReference <TextureContent>(normalTexture));
customMaterial.Textures.Add("EmissiveTexture",
new ExternalReference <TextureContent>(emissiveTexture));
// Chain to the base material processor.
return(base.Process(customMaterial, context));
}
/// <summary>
/// Adds for each texture the corresponding normal map to the material textures list
/// the normal map name is generated from the texture name:
/// [texture_name].tga => [texture_name]_normal.tga
/// </summary>
private void LookUpNormalMapAndAddToTextures(NodeContent node)
{
MeshContent mesh = node as MeshContent;
if (mesh != null)
{
// for all geometry contents in the mesh
foreach (GeometryContent geometry in mesh.Geometry)
{
// does the geometry content contain a texture, and haven't we already processed it?
if (geometry.Material.Textures.Count > 0 &&
!geometry.Material.Textures.ContainsKey(NormalMapKey))
{
// extract the texture name
BasicMaterialContent basicMaterial = (BasicMaterialContent)geometry.Material;
// replace .tga with _normal.tga
string normalMapPath = basicMaterial.Texture.Filename.Replace(".tga", "_normal.tga");
// add the texture to the textures list
geometry.Material.Textures.Add(
NormalMapKey,
new ExternalReference <TextureContent>(normalMapPath)
);
}
}
}
// recurse to all children
foreach (NodeContent child in node.Children)
{
LookUpNormalMapAndAddToTextures(child);
}
}
/// <summary>
/// Converts a material.
/// </summary>
public override MaterialContent Process(MaterialContent input,
ContentProcessorContext context)
{
// Create a new effect material.
EffectMaterialContent customMaterial = new EffectMaterialContent();
// Point the new material at our custom effect file.
string effectFile = Path.GetFullPath("EnvironmentMap.fx");
customMaterial.Effect = new ExternalReference <EffectContent>(effectFile);
// Copy texture data across from the original material.
BasicMaterialContent basicMaterial = (BasicMaterialContent)input;
if (basicMaterial.Texture != null)
{
customMaterial.Textures.Add("Texture", basicMaterial.Texture);
customMaterial.OpaqueData.Add("TextureEnabled", true);
}
// Add the reflection texture.
string envmap = Path.GetFullPath(EnvironmentMap);
customMaterial.Textures.Add("EnvironmentMap",
new ExternalReference <TextureContent>(envmap));
// Chain to the base material processor.
return(base.Process(customMaterial, context));
}
private MaterialContent GetMaterial(aiMesh aiMesh)
{
aiString difuse = new aiString();
scene.mMaterials[(int)aiMesh.mMaterialIndex].GetTextureDiffuse0(difuse);
if (!String.IsNullOrEmpty(difuse.Data))
{
String original = difuse.Data;
difuse.Data = Path.GetFileName(difuse.Data);
importerContext.AddDependency(Path.Combine(directory, difuse.Data));
try
{
BasicMaterialContent materialContent = new BasicMaterialContent();
materialContent.Name = difuse.Data;
materialContent.Texture = new ExternalReference <TextureContent>(difuse.Data);
return(materialContent);
}
catch (InvalidContentException)
{
// InvalidContentExceptions do not need further processing
throw;
}
catch (Exception e)
{
// Wrap exception with content identity (includes line number)
throw new InvalidContentException(e.ToString());
}
}
return(null);
}
protected virtual void ProcessGeometryUsingMaterial(MaterialContent material,
IEnumerable <GeometryContent> geometryCollection,
ContentProcessorContext context)
{
if (material == null)
{
material = new BasicMaterialContent();
}
foreach (var geometry in geometryCollection)
{
ProcessBasicMaterial(material as BasicMaterialContent, geometry);
var vertexBuffer = geometry.Vertices.CreateVertexBuffer();
var primitiveCount = geometry.Vertices.PositionIndices.Count;
var parts = new List <ModelMeshPartContent>
{
new ModelMeshPartContent(vertexBuffer, geometry.Indices, 0, primitiveCount, 0,
primitiveCount / 3)
};
var parent = geometry.Parent;
var bounds = BoundingSphere.CreateFromPoints(geometry.Vertices.Positions);
_meshes.Add(new ModelMeshContent(parent.Name, geometry.Parent, null, bounds, parts));
}
}
public void SetMaterialDoesNotClearChannels()
{
var mb = MeshBuilder.StartMesh("Test");
var mat = new BasicMaterialContent();
mb.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
mb.SetMaterial(mat);
Assert.DoesNotThrow(() => mb.SetVertexChannelData(0, Vector2.Zero));
}
private DRModelNodeContent CreateModel(Texture2DContent input, ContentProcessorContext context, HeightField heightField)
{
// We use the XNA MeshBuilder to create the model.
MeshBuilder meshBuilder = MeshBuilder.StartMesh(input.Name);
int numberOfSamplesX = heightField.NumberOfSamplesX;
int numberOfSamplesZ = heightField.NumberOfSamplesZ;
int numberOfCellsInX = numberOfSamplesX - 1;
int numberOfCellsInZ = numberOfSamplesZ - 1;
// Add vertex positions.
for (int z = 0; z < numberOfSamplesZ; z++)
{
for (int x = 0; x < numberOfSamplesX; x++)
{
meshBuilder.CreatePosition((float)x / numberOfCellsInX * heightField.WidthX,
heightField.Samples[z * numberOfSamplesX + x],
(float)z / numberOfCellsInZ * heightField.WidthZ);
}
}
// Set a BasicMaterial for the model.
var material = new BasicMaterialContent
{
SpecularColor = Vector3.Zero,
Texture = new ExternalReference <TextureContent>(TextureFilename, input.Identity)
};
meshBuilder.SetMaterial(material);
// Add texture coordinates. Each height field cell consists of two triangles.
int textureChannelId = meshBuilder.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
for (int x = 0; x < numberOfCellsInX; x++)
{
for (int z = 0; z < numberOfCellsInZ; z++)
{
// First triangle.
AddVertex(meshBuilder, textureChannelId, x, z, numberOfSamplesX, numberOfSamplesZ);
AddVertex(meshBuilder, textureChannelId, x + 1, z, numberOfSamplesX, numberOfSamplesZ);
AddVertex(meshBuilder, textureChannelId, x, z + 1, numberOfSamplesX, numberOfSamplesZ);
// Second triangle.
AddVertex(meshBuilder, textureChannelId, x, z + 1, numberOfSamplesX, numberOfSamplesZ);
AddVertex(meshBuilder, textureChannelId, x + 1, z, numberOfSamplesX, numberOfSamplesZ);
AddVertex(meshBuilder, textureChannelId, x + 1, z + 1, numberOfSamplesX, numberOfSamplesZ);
}
}
// Create MeshContent. FinishMesh() automatically computes normal vectors.
MeshContent meshContent = meshBuilder.FinishMesh();
// Call the DRModelProcessor to convert the MeshContent to DRModelNodeContent.
DRModelNodeContent model = context.Convert <MeshContent, DRModelNodeContent>(meshContent, "DRModelProcessor");
return(model);
}
private static List <MaterialContent> ImportMaterials(ContentIdentity identity, Scene scene)
{
var materials = new List <MaterialContent>();
foreach (var sceneMaterial in scene.Materials)
{
var material = new BasicMaterialContent
{
Name = sceneMaterial.Name,
Identity = identity,
};
if (sceneMaterial.HasTextureDiffuse)
{
var texture = new ExternalReference <TextureContent>(sceneMaterial.TextureDiffuse.FilePath, identity);
texture.OpaqueData.Add("TextureCoordinate", string.Format("TextureCoordinate{0}", sceneMaterial.TextureDiffuse.UVIndex));
material.Textures.Add("Texture", texture);
}
if (sceneMaterial.HasTextureOpacity)
{
var texture = new ExternalReference <TextureContent>(sceneMaterial.TextureOpacity.FilePath, identity);
texture.OpaqueData.Add("TextureCoordinate", string.Format("TextureCoordinate{0}", sceneMaterial.TextureOpacity.UVIndex));
material.Textures.Add("Transparency", texture);
}
if (sceneMaterial.HasColorDiffuse)
{
material.DiffuseColor = ToXna(sceneMaterial.ColorDiffuse);
}
if (sceneMaterial.HasColorEmissive)
{
material.EmissiveColor = ToXna(sceneMaterial.ColorEmissive);
}
if (sceneMaterial.HasOpacity)
{
material.Alpha = sceneMaterial.Opacity;
}
if (sceneMaterial.HasColorSpecular)
{
material.SpecularColor = ToXna(sceneMaterial.ColorSpecular);
}
if (sceneMaterial.HasShininessStrength)
{
material.SpecularPower = sceneMaterial.ShininessStrength;
}
materials.Add(material);
}
return(materials);
}
/// <summary>
/// If a node is skinned, we need to use the skinned model
/// effect rather than basic effect. This function runs through the
/// geometry and finds the meshes that have bone weights associated
/// and swaps in the skinned effect.
/// </summary>
/// <param name="node"></param>
void SwapSkinnedMaterial(NodeContent node)
{
// It has to be a MeshContent node
MeshContent mesh = node as MeshContent;
if (mesh != null)
{
// In the geometry we have to find a vertex channel that
// has a bone weight collection
foreach (GeometryContent geometry in mesh.Geometry)
{
bool swap = false;
foreach (VertexChannel vchannel in geometry.Vertices.Channels)
{
if (vchannel is VertexChannel <BoneWeightCollection> )
{
swap = true;
break;
}
}
if (swap)
{
if (toSkinnedMaterial.ContainsKey(geometry.Material))
{
// We have already swapped it
geometry.Material = toSkinnedMaterial[geometry.Material];
}
else
{
SkinnedMaterialContent smaterial = new SkinnedMaterialContent();
BasicMaterialContent bmaterial = geometry.Material as BasicMaterialContent;
// Copy over the data
smaterial.Alpha = bmaterial.Alpha;
smaterial.DiffuseColor = bmaterial.DiffuseColor;
smaterial.EmissiveColor = bmaterial.EmissiveColor;
smaterial.SpecularColor = bmaterial.SpecularColor;
smaterial.SpecularPower = bmaterial.SpecularPower;
smaterial.Texture = bmaterial.Texture;
smaterial.WeightsPerVertex = 4;
toSkinnedMaterial[geometry.Material] = smaterial;
geometry.Material = smaterial;
}
}
}
}
foreach (NodeContent child in node.Children)
{
SwapSkinnedMaterial(child);
}
}
public override ModelContent Process(Texture2DContent input, ContentProcessorContext context)
{
var builder = MeshBuilder.StartMesh("terrain");
input.ConvertBitmapType(typeof(PixelBitmapContent <float>));
var heightField = (PixelBitmapContent <float>)input.Mipmaps[0];
for (var y = 0; y < heightField.Height; y++)
{
for (var x = 0; x < heightField.Width; x++)
{
Vector3 position;
position.X = TerrainScale * (x - (heightField.Width - 1) / 2.0f);
position.Z = TerrainScale * (y - (heightField.Height - 1) / 2.0f);
position.Y = (heightField.GetPixel(x, y) - 1) * TerrainBumpiness;
builder.CreatePosition(position);
}
}
var material = new BasicMaterialContent {
SpecularColor = new Vector3(.4f, .4f, .4f)
};
var directory = Path.GetDirectoryName(input.Identity.SourceFilename);
var texture = Path.Combine(directory, TerrainTexture);
material.Texture = new ExternalReference <TextureContent>(texture);
builder.SetMaterial(material);
var texCoordId = builder.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
for (var y = 0; y < heightField.Height - 1; y++)
{
for (var x = 0; x < heightField.Width - 1; x++)
{
AddVertex(builder, texCoordId, heightField.Width, x, y);
AddVertex(builder, texCoordId, heightField.Width, x + 1, y);
AddVertex(builder, texCoordId, heightField.Width, x + 1, y + 1);
AddVertex(builder, texCoordId, heightField.Width, x, y);
AddVertex(builder, texCoordId, heightField.Width, x + 1, y + 1);
AddVertex(builder, texCoordId, heightField.Width, x, y + 1);
}
}
var terrainMesh = builder.FinishMesh();
var model = context.Convert <MeshContent, ModelContent>(terrainMesh, "ModelProcessor");
model.Tag = new HeightMapInfoContent(heightField, TerrainScale, TerrainBumpiness);
return(model);
}
public override HeightMapInfoContent Process(Texture2DContent input, ContentProcessorContext context)
{
MeshBuilder meshBuilder = MeshBuilder.StartMesh("terrain");
input.ConvertBitmapType(typeof(PixelBitmapContent <float>));
PixelBitmapContent <float> item = (PixelBitmapContent <float>)input.Mipmaps[0];
for (int i = 0; i < item.Height; i++)
{
for (int j = 0; j < item.Width; j++)
{
Vector3 width = new Vector3(
mScale * (j - (item.Width - 1) / 2f),
width.Y = (item.GetPixel(j, i) - 1f) * Bumpiness,
width.Z = mScale * (i - (item.Height - 1) / 2f)
);
meshBuilder.CreatePosition(width);
}
}
BasicMaterialContent basicMaterialContent = new BasicMaterialContent();
basicMaterialContent.SpecularColor = new Vector3(0.4f, 0.4f, 0.4f);
if (!string.IsNullOrEmpty(TerrainTexture))
{
string directoryName = Path.GetDirectoryName(input.Identity.SourceFilename);
string str = Path.Combine(directoryName, TerrainTexture);
basicMaterialContent.Texture = new ExternalReference <TextureContent>(str);
}
meshBuilder.SetMaterial(basicMaterialContent);
int num = meshBuilder.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
int num1 = 0;
while (num1 < item.Height - 1)
{
for (int k = 0; k < item.Width - 1; k++)
{
AddVertex(meshBuilder, num, item.Width, k, num1);
AddVertex(meshBuilder, num, item.Width, k + 1, num1);
AddVertex(meshBuilder, num, item.Width, k + 1, num1 + 1);
AddVertex(meshBuilder, num, item.Width, k, num1);
AddVertex(meshBuilder, num, item.Width, k + 1, num1 + 1);
AddVertex(meshBuilder, num, item.Width, k, num1 + 1);
}
num1++;
}
MeshContent meshContent = meshBuilder.FinishMesh();
ModelContent modelContent = context.Convert <MeshContent, ModelContent>(meshContent, "ModelProcessor");
return(new HeightMapInfoContent(modelContent, meshContent, mScale, item.Width, item.Height));
}
void parseMtlLine(string[] lineTokens)
{
switch (lineTokens[0].ToLower( ))
{
case "newmtl":
if (materialContent != null)
{
materials.Add(materialContent.Name, materialContent);
}
materialContent = new BasicMaterialContent( );
materialContent.Identity = new ContentIdentity(mtlFileIdentity.SourceFilename);
materialContent.Name = lineTokens[1];
break;
case "kd":
materialContent.DiffuseColor = parseVector3(lineTokens);
break;
case "map_kd":
materialContent.Texture = new ExternalReference <TextureContent>(lineTokens[1], mtlFileIdentity);
break;
case "ka":
break;
case "ks":
materialContent.SpecularColor = parseVector3(lineTokens);
break;
case "ns":
materialContent.SpecularPower = float.Parse(lineTokens[1], CultureInfo.InvariantCulture);
break;
case "ke":
materialContent.EmissiveColor = parseVector3(lineTokens);
break;
case "d":
materialContent.Alpha = float.Parse(lineTokens[1], CultureInfo.InvariantCulture);
break;
case "illum":
materialContent.OpaqueData.Add("Illumination mode", int.Parse(lineTokens[1], CultureInfo.InvariantCulture));
break;
default:
throw new InvalidContentException("Unsupported or invalid line type '" + lineTokens[0] + "'", mtlFileIdentity);
}
}
void SetSkinnedEffect(NodeContent node)
{
MeshContent mesh = node as MeshContent;
if (mesh != null)
{
foreach (GeometryContent geometry in mesh.Geometry)
{
bool swap = false;
foreach (VertexChannel vchannel in geometry.Vertices.Channels)
{
if (vchannel is VertexChannel <BoneWeightCollection> )
{
swap = true;
break;
}
}
if (swap)
{
if (toSkinnedMaterial.ContainsKey(geometry.Material))
{
geometry.Material = toSkinnedMaterial[geometry.Material];
}
else
{
SkinnedMaterialContent smaterial = new SkinnedMaterialContent();
BasicMaterialContent bmaterial = geometry.Material as BasicMaterialContent;
smaterial.Alpha = bmaterial.Alpha;
smaterial.DiffuseColor = bmaterial.DiffuseColor;
smaterial.EmissiveColor = bmaterial.EmissiveColor;
smaterial.SpecularColor = bmaterial.SpecularColor;
smaterial.SpecularPower = bmaterial.SpecularPower;
smaterial.Texture = bmaterial.Texture;
smaterial.WeightsPerVertex = 4;
toSkinnedMaterial[geometry.Material] = smaterial;
geometry.Material = smaterial;
}
}
}
}
foreach (NodeContent child in node.Children)
{
SetSkinnedEffect(child);
}
}
protected virtual void ProcessMaterial(MaterialContent input,
SkinnedModelMaterialContent skinnedModelMaterial, ContentProcessorContext context)
{
BasicMaterialContent basicMaterial = input as BasicMaterialContent;
//if (basicMaterial != null)
//{
// skinnedModelMaterial.EmissiveColor = basicMaterial.EmissiveColor.GetValueOrDefault(
// Vector3.Zero);
// skinnedModelMaterial.DiffuseColor = basicMaterial.DiffuseColor.GetValueOrDefault(
// Vector3.One);
// skinnedModelMaterial.SpecularColor = basicMaterial.SpecularColor.GetValueOrDefault(
// Vector3.One);
// skinnedModelMaterial.SpecularPower = basicMaterial.SpecularPower.GetValueOrDefault(
// 16);
//}
}
public void OnlyUseOnce()
{
var mb = MeshBuilder.StartMesh("Test");
var mat = new BasicMaterialContent();
mb.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
mb.CreatePosition(0f, 0f, 0f);
var mesh = mb.FinishMesh();
Assert.DoesNotThrow(() => mb.SetMaterial(mat));
Assert.DoesNotThrow(() => mb.SetVertexChannelData(0, Vector2.Zero));
Assert.AreSame(mesh, mb.FinishMesh());
Assert.Throws <InvalidOperationException>(() => mb.CreatePosition(1f, 2f, 3f));
Assert.Throws <InvalidOperationException>(() => mb.AddTriangleVertex(0));
Assert.Throws <InvalidOperationException>(() => mb.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(1)));
}
public void AddModelPart(
int triangleCount,
IndexCollection indexCollection,
CpuVertex[] vertices,
BasicMaterialContent material)
{
if (material == null)
{
throw new ArgumentNullException("material");
}
ModelParts.Add(new CpuSkinnedModelPartContent
{
TriangleCount = triangleCount,
IndexCollection = indexCollection,
Vertices = vertices,
Material = material,
});
}
private NodeContent buildFloorMesh(PixelBitmapContent <Color> bitmap)
{
MeshBuilder mb = MeshBuilder.StartMesh("floor");
// Create a material, and point it at the world section texture
BasicMaterialContent material = new BasicMaterialContent();
material.Textures.Add(LightPrePassProcessor.DiffuseMapKey, new ExternalReference <TextureContent>(floortexturefile));
material.Textures.Add(LightPrePassProcessor.NormalMapKey, new ExternalReference <TextureContent>(floortexturenormalfile));
mb.SetMaterial(material);
// Create data channels
int channel_texCoord0 = mb.CreateVertexChannel <Vector2>(VertexChannelNames.TextureCoordinate(0));
// First create vertex data
// loop through all the pixels
int quadcount = 0;
for (int y = 0; y < 32; y++)
{
for (int x = 0; x < 32; x++)
{
if (IsFloorTile(bitmap, x, y))
{
quadcount += AddQuadVertexPositions(mb, new Vector3(-16 + x, 0, -16 + y), new Vector3(-16 + x + 1.0f, 0, -16 + y + 1.0f));
}
}
}
Random r = new Random();
for (int q = 0; q < quadcount; q++)
{
Vector2[] tex = quarters[r.Next(4)];
AddTriangleVertices(mb, q, channel_texCoord0, tex);
}
return(mb.FinishMesh());
}
/// <summary>
/// Adds material to mesh being built.
/// </summary>
/// <param name="subMesh">Index of submesh in source.</param>
private void AddMaterial(int subMesh, ContentImporterContext context)
{
// Get submesh
ModelData.SubMeshData sm = model.SubMeshes[subMesh];
// Get relative path to texture
string relativePath = Path.Combine(textureSubPath, sm.MaterialKey) + ".dfb";
// Create material
BasicMaterialContent material = new BasicMaterialContent();
material.Name = sm.MaterialKey;
material.Texture = new ExternalReference <TextureContent>(relativePath, rootNode.Identity);
// Add dependency to texture
//context.AddDependency(material.Texture.Filename);
// Assign material
meshBuilder.SetMaterial(material);
}
/// <summary>
/// Override the ConvertMaterial method to apply our custom InstancedModel.fx shader.
/// </summary>
protected override MaterialContent ConvertMaterial(MaterialContent material,
ContentProcessorContext context)
{
// Create a new material.
EffectMaterialContent newMaterial = new EffectMaterialContent();
// Tell it to use our custom InstancedModel.fx shader.
newMaterial.Effect = new ExternalReference <EffectContent>("../shaders/modelrenderer/default.fx", rootIdentity);
// Copy the texture setting across from the original material.
BasicMaterialContent basicMaterial = material as BasicMaterialContent;
if ((basicMaterial != null) && (basicMaterial.Texture != null))
{
newMaterial.Textures.Add("Texture", basicMaterial.Texture);
}
// Chain to the base ModelProcessor, so it can build our new material.
return(base.ConvertMaterial(newMaterial, context));
}
/// <summary>
/// Changes all the materials to use our skinned model effect.
/// </summary>
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context)
{
BasicMaterialContent basicMaterial = material as BasicMaterialContent;
string effectPath = "";
if (basicMaterial == null)
{
throw new InvalidContentException(string.Format(
"SkinnedModelProcessor only supports BasicMaterialContent, " +
"but input mesh uses {0}.", material.GetType()));
}
EffectMaterialContent effectMaterial = new EffectMaterialContent();
// StoreEffectMaterialContent effectMaterial = new EffectMaterialContent(); a reference to our skinned mesh effect.
/*
* StreamWriter w = new StreamWriter("test.txt");
* w.WriteLine();
* w.Close();
*/
if (File.Exists("Models\\SkinnedModel.fx"))
{
effectPath = Path.GetFullPath("Models\\SkinnedModel.fx");
}
if (effectPath == "")
{
return(base.ConvertMaterial(material, context));
}
effectMaterial.Effect = new ExternalReference <EffectContent>(effectPath);
// Copy texture settings from the input
// BasicMaterialContent over to our new material.
if (basicMaterial.Texture != null)
{
effectMaterial.Textures.Add("Texture", basicMaterial.Texture);
}
// Chain to the base ModelProcessor converter.
return(base.ConvertMaterial(effectMaterial, context));
}
private void ProcessBasicMaterial(BasicMaterialContent basicMaterial, GeometryContent geometry)
{
if (basicMaterial == null)
{
return;
}
// If the basic material specifies a texture, geometry must have coordinates.
if (!geometry.Vertices.Channels.Contains(VertexChannelNames.TextureCoordinate(0)))
{
throw new InvalidContentException(
"Geometry references material with texture, but no texture coordinates were found.",
_identity);
}
// Enable vertex color if the geometry has the channel to support it.
if (geometry.Vertices.Channels.Contains(VertexChannelNames.Color(0)))
{
basicMaterial.VertexColorEnabled = true;
}
}
private static void PrepareMaterial(List <GeometryContent> geometries)
{
var material = geometries[0].Material;
// Assign default material if material is null.
if (material == null)
{
material = new BasicMaterialContent();
foreach (GeometryContent geometry in geometries)
{
geometry.Material = material;
}
}
// All effects, except the stock EnvironmentMap and SkinnedMaterial effect
// can have vertex colors.
if (!(material is EnvironmentMapMaterialContent) && !(material is SkinnedMaterialContent))
{
SetVertexColorEnabled(geometries);
}
}
/// <summary>
/// Converts a material.
/// </summary>
public override MaterialContent Process(MaterialContent input,
ContentProcessorContext context)
{
// Create a new effect material.
EnvironmentMapMaterialContent customMaterial = new EnvironmentMapMaterialContent();
// Copy texture data across from the original material.
BasicMaterialContent basicMaterial = (BasicMaterialContent)input;
if (basicMaterial.Texture != null)
{
customMaterial.Texture = basicMaterial.Texture;
}
// Add the reflection texture.
string envmap = Path.GetFullPath(EnvironmentMap);
customMaterial.EnvironmentMap = new ExternalReference <TextureContent>(envmap);
// Chain to the base material processor.
return(base.Process(customMaterial, context));
}
