/// <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)); }