/// <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 Effect CreateEffect(MaterialContent srcMaterial, bool isSkinned) { var pbrMaterial = new MaterialContentConverter(srcMaterial, GetTexture); var isUnlit = srcMaterial.PreferredShading == "Unlit"; var effect = isUnlit ? _CreateUnlitEffect(pbrMaterial) : _CreatePBREffect(pbrMaterial); if (srcMaterial.Mode == MaterialBlendMode.Blend) { effect.AlphaBlend = true; } if (srcMaterial.Mode == MaterialBlendMode.Mask) { effect.AlphaCutoff = srcMaterial.AlphaCutoff; } if (effect is PBREffect pbrEffect) { pbrEffect.NormalMode = srcMaterial.DoubleSided ? GeometryNormalMode.DoubleSided : GeometryNormalMode.Reverse; } return(effect); }
private void ProcessTextures(MaterialContent input, SkinnedModelMaterialContent skinnedModelMaterial, ContentProcessorContext context) { foreach (string key in input.Textures.Keys) { ExternalReference<TextureContent> texture = input.Textures[key]; if (!String.IsNullOrEmpty(texturePath)) { string fullFilePath; if (texturePathType == PathType.Relative) { // If relative path string sourceAssetPath = Path.GetDirectoryName(input.Identity.SourceFilename); fullFilePath = Path.GetFullPath( Path.Combine(sourceAssetPath, texturePath)); } else { fullFilePath = texturePath; } texture.Filename = Path.Combine(fullFilePath, Path.GetFileName(texture.Filename)); } ProcessTexture(key, texture, skinnedModelMaterial, context); } }
public virtual void DoModifyFileOperations(string rootPath, MaterialFileOeprationInfo fileOperation, MaterialContent content) { var task = new InvokeServiceTask() { TaskID = UuidHelper.NewUuidString(), TaskTitle = string.Format(this.taskTitleTemplate, fileOperation.Material.OriginalName, fileOperation.Material.ID), }; var parameters = new WfServiceOperationParameterCollection { new WfServiceOperationParameter("rootPath", rootPath), new WfServiceOperationParameter("fileOperation", fileOperation.Operation.ToString()), new WfServiceOperationParameter("materialConnectionName", DbConnectionMappingContext.GetMappedConnectionName(MaterialAdapter.Instance.GetConnectionName())), new WfServiceOperationParameter("contentConnectionName", DbConnectionMappingContext.GetMappedConnectionName(MaterialContentAdapter.Instance.ConnectionName)), new WfServiceOperationParameter("materialId", fileOperation.Material.ID), new WfServiceOperationParameter("url", fileOperation.Material.ShowFileUrl) }; task.SvcOperationDefs.Add(new WfServiceOperationDefinition( new WfServiceAddressDefinition(WfServiceRequestMethod.Post, null, ResourceUriSettings.GetConfig().Paths[this.resourceUri].Uri.ToString()), "DoFileToDocService", parameters, "ReturnValue") ); DbConnectionMappingContext.DoMappingAction( DbConnectionMappingContext.GetMappedConnectionName(InvokeServiceTaskAdapter.Instance.ConnectionName), InvokeServiceTaskAdapter.Instance.ConnectionName, () => { InvokeServiceTaskAdapter.Instance.Update(task); }); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { EffectMaterialContent normalMappingMaterial = new EffectMaterialContent(); normalMappingMaterial.Effect = new ExternalReference <EffectContent> (Path.Combine("Effects/renderGBuffer.fx")); OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters["ColorKeyColor"] = this.ColorKeyColor; processorParameters["ColorKeyEnabled"] = this.ColorKeyEnabled; processorParameters["TextureFormat"] = this.TextureFormat; processorParameters["GenerateMipmaps"] = this.GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; // copy the textures in the original material to the new normal mapping // material. this way the diffuse texture is preserved. The // PreprocessSceneHierarchy function has already added the normal map // texture to the Textures collection, so that will be copied as well. foreach (KeyValuePair <String, ExternalReference <TextureContent> > texture in material.Textures) { normalMappingMaterial.Textures.Add(texture.Key, texture.Value); } // and convert the material using the NormalMappingMaterialProcessor, // who has something special in store for the normal map. return(context.Convert <MaterialContent, MaterialContent> (normalMappingMaterial, typeof(DeferredMaterialProcessor).Name, processorParameters)); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { var customMaterial = new EffectMaterialContent(); customMaterial.Effect = new ExternalReference<EffectContent>(effectPath); //var basicMaterial = (BasicMaterialContent) material; //if (basicMaterial.Texture != null) //{ // customMaterial.Textures.Add(skyMapKey, basicMaterial.Texture); //} foreach (var texture in material.Textures) { customMaterial.Textures.Add(texture.Key, texture.Value); } var parameters = new OpaqueDataDictionary(); parameters["ColorKeyColor"] = ColorKeyColor; parameters["ColorKeyEnabled"] = ColorKeyEnabled; parameters["TextureFormat"] = TextureFormat; parameters["GenerateMipmaps"] = GenerateMipmaps; parameters["ResizeTexturesToPowerOfTwo"] = ResizeTexturesToPowerOfTwo; return context.Convert<MaterialContent, MaterialContent>( customMaterial, typeof(MaterialProcessor).Name, parameters); }
/// <summary> /// 从数据库得到对象的图片 /// </summary> /// <param name="id"></param> /// <param name="propertyName"></param> /// <param name="timePoint"></param> /// <returns></returns> public SchemaObjectPhoto LoadObjectPhoto(string id, string propertyName, DateTime timePoint) { SchemaObjectPhoto result = null; SchemaObjectBase obj = SchemaObjectAdapter.Instance.Load(id, timePoint); if (obj != null) { if (obj.Properties.ContainsKey(propertyName)) { ImageProperty imgInfo = JSONSerializerExecute.Deserialize <ImageProperty>(obj.Properties[propertyName].StringValue); if (imgInfo != null) { MaterialContent mc = MaterialContentAdapter.Instance.Load(builder => builder.AppendItem("CONTENT_ID", imgInfo.ID)).FirstOrDefault(); if (mc != null) { result = new SchemaObjectPhoto() { ImageInfo = imgInfo, ContentData = mc.ContentData } } ; } } } return(result); }
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)); } }
/// <summary> /// Converts a <see cref="BasicMaterialContent"/> to an equivalent /// <see cref="SkinnedMaterialContent"/>. /// </summary> /// <param name="material">The <see cref="BasicMaterialContent"/>.</param> /// <returns>The <see cref="SkinnedMaterialContent"/>.</returns> public static SkinnedMaterialContent ConvertToSkinnedMaterial(MaterialContent material) { var skinnedMaterial = material as SkinnedMaterialContent; if (skinnedMaterial != null) { return(skinnedMaterial); } var basicMaterial = material as BasicMaterialContent; if (basicMaterial != null) { skinnedMaterial = new SkinnedMaterialContent { Name = basicMaterial.Name, Identity = basicMaterial.Identity, Alpha = basicMaterial.Alpha, DiffuseColor = basicMaterial.DiffuseColor, EmissiveColor = basicMaterial.EmissiveColor, SpecularColor = basicMaterial.SpecularColor, SpecularPower = basicMaterial.SpecularPower, WeightsPerVertex = null }; skinnedMaterial.Textures.AddRange(basicMaterial.Textures); return(skinnedMaterial); } return(null); }
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)); } }
/// <summary> /// Creates new material with the new effect file. /// </summary> public override MaterialContent Process(MaterialContent input, ContentProcessorContext context) { if (string.IsNullOrEmpty(customEffect)) throw new ArgumentException("Custom Effect not set to an effect file"); // Create a new effect material. EffectMaterialContent customMaterial = new EffectMaterialContent(); // Point the new material at the custom effect file. string effectFile = Path.GetFullPath(customEffect); customMaterial.Effect = new ExternalReference<EffectContent>(effectFile); // Loop over the textures in the current material adding them to // the new material. foreach (KeyValuePair<string, ExternalReference<TextureContent>> textureContent in input.Textures) { customMaterial.Textures.Add(textureContent.Key, textureContent.Value); } // Loop over the opaque data in the current material adding them to // the new material. foreach (KeyValuePair<string, Object> opaqueData in input.OpaqueData) { customMaterial.OpaqueData.Add(opaqueData.Key, opaqueData.Value); } // Call the base material processor to continue the rest of the processing. return base.Process(customMaterial, context); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { OpaqueDataDictionary pparams = new OpaqueDataDictionary( ); pparams["ColorKeyEnabled"] = false; pparams["GenerateMipmaps"] = this.GenerateMipmaps; pparams["TextureFormat"] = this.TextureFormat; pparams["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; pparams["PremultiplyTextureAlpha"] = false; string exePath = Application.ExecutablePath; string appDir = exePath.Replace(Path.GetFileName(exePath), string.Empty); string shaderPath = Path.Combine(appDir, DATA_DIR + @"\game.fx"); EffectMaterialContent vixenMaterial = new EffectMaterialContent( ); vixenMaterial.Effect = new ExternalReference <EffectContent>(shaderPath); vixenMaterial.CompiledEffect = context.BuildAsset <EffectContent, CompiledEffectContent>(vixenMaterial.Effect, "EffectProcessor"); foreach (KeyValuePair <string, ExternalReference <TextureContent> > texture in material.Textures) { switch (texture.Key) { case C4D_DMAP: vixenMaterial.Textures.Add(KEY_DMAP, texture.Value); break; case C4D_NMAP: vixenMaterial.Textures.Add(KEY_NMAP, texture.Value); break; case C4D_SMAP: vixenMaterial.Textures.Add(KEY_SMAP, texture.Value); break; case C4D_EMAP: vixenMaterial.Textures.Add(KEY_EMAP, texture.Value); break; } } if (!vixenMaterial.Textures.ContainsKey(KEY_DMAP)) { vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\dmap.tga")); } if (!vixenMaterial.Textures.ContainsKey(KEY_NMAP)) { vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\nmap.tga")); } if (!vixenMaterial.Textures.ContainsKey(KEY_SMAP)) { vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\smap.tga")); } if (!vixenMaterial.Textures.ContainsKey(KEY_EMAP)) { vixenMaterial.Textures[KEY_DMAP] = new ExternalReference <TextureContent>(Path.Combine(appDir, DATA_DIR + @"\emap.tga")); } return(context.Convert <MaterialContent, MaterialContent>(vixenMaterial, typeof(MaterialProcessor).Name, pparams)); }
/// <summary> /// Extract any defines we need from the original material, like alphaMasked, fresnel, reflection, etc, and pass it into /// the opaque data /// </summary> /// <param name="lppMaterial"></param> /// <param name="material"></param> /// <param name="context"></param> private void ExtractDefines(EffectMaterialContent lppMaterial, MaterialContent material, ContentProcessorContext context) { string defines = ""; if (material.OpaqueData.ContainsKey("alphaMasked") && material.OpaqueData["alphaMasked"].ToString() == "True") { context.Logger.LogMessage("Alpha masked material found"); lppMaterial.OpaqueData.Add("AlphaReference", (float)material.OpaqueData["AlphaReference"]); defines += "ALPHA_MASKED;"; } if (material.OpaqueData.ContainsKey("reflectionEnabled") && material.OpaqueData["reflectionEnabled"].ToString() == "True") { context.Logger.LogMessage("Reflection enabled"); defines += "REFLECTION_ENABLED;"; } if (_isSkinned) { context.Logger.LogMessage("Skinned mesh found"); defines += "SKINNED_MESH;"; } if (material.OpaqueData.ContainsKey("dualLayerEnabled") && material.OpaqueData["dualLayerEnabled"].ToString() == "True") { context.Logger.LogMessage("Dual layer material found"); defines += "DUAL_LAYER;"; } if (!String.IsNullOrEmpty(defines)) { lppMaterial.OpaqueData.Add("Defines", defines); } }
public override void SaveMaterialContent(MaterialContent content) { if (content.ContentData == null) SaveMaterialContentFromFile(content); else SaveMaterialContentFromData(content); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { EffectMaterialContent myMaterial = new EffectMaterialContent(); if (material is BasicMaterialContent) { return(base.ConvertMaterial(material, context)); } else if (material is EffectMaterialContent) { EffectMaterialContent effectMaterialContent = (EffectMaterialContent)material; // // remap effect // myMaterial.Effect = new ExternalReference <EffectContent>(effectMaterialContent.Effect.Filename); // textures foreach (KeyValuePair <string, ExternalReference <TextureContent> > pair in effectMaterialContent.Textures) { string textureKey = pair.Key; ExternalReference <TextureContent> textureContent = pair.Value; if (!string.IsNullOrEmpty(textureContent.Filename)) { myMaterial.Textures.Add(textureKey, material.Textures[textureKey]); } } } return(base.ConvertMaterial(myMaterial, context)); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { MaterialData mat = incomingMaterials.Single(m => m.Name == material.Name); EffectMaterialContent emc = new EffectMaterialContent(); emc.Effect = new ExternalReference<EffectContent>(Path.Combine(contentPath, mat.CustomEffect)); emc.Name = material.Name; emc.Identity = material.Identity; foreach (KeyValuePair<String, ExternalReference<TextureContent>> texture in material.Textures) { if (texture.Key == "Texture") { emc.Textures.Add(texture.Key, texture.Value); } else { context.Logger.LogWarning(null, material.Identity, "There were some other textures referenced by the model, but we can't properly assign them to the correct effect parameter."); } } foreach (EffectParam ep in mat.EffectParams) { if (ep.Category == EffectParamCategory.OpaqueData) { emc.OpaqueData.Add(ep.Name, ep.Value); } else if (ep.Category == EffectParamCategory.Texture) { emc.Textures.Add(ep.Name, new ExternalReference<TextureContent>((string)(ep.Value))); } } return base.ConvertMaterial(emc, context); }
private void ProcessTextures(MaterialContent input, SkinnedModelMaterialContent skinnedModelMaterial, ContentProcessorContext context) { foreach (string key in input.Textures.Keys) { ExternalReference <TextureContent> texture = input.Textures[key]; if (!String.IsNullOrEmpty(texturePath)) { string fullFilePath; if (texturePathType == PathType.Relative) { // If relative path string sourceAssetPath = Path.GetDirectoryName(input.Identity.SourceFilename); fullFilePath = Path.GetFullPath( Path.Combine(sourceAssetPath, texturePath)); } else { fullFilePath = texturePath; } texture.Filename = Path.Combine(fullFilePath, Path.GetFileName(texture.Filename)); } ProcessTexture(key, texture, skinnedModelMaterial, context); } }
protected override MaterialContent ConvertMaterial( MaterialContent material, ContentProcessorContext context) { EffectMaterialContent deferredShadingMaterial = new EffectMaterialContent(); deferredShadingMaterial.Effect = new ExternalReference <EffectContent> (effectDirectory + "RenderGBuffer.fx"); // copy the textures in the original material to the new normal mapping // material, if they are relevant to our renderer. The // LookUpTextures function has added the normal map and specular map // textures to the Textures collection, so that will be copied as well. foreach (KeyValuePair <String, ExternalReference <TextureContent> > texture in material.Textures) { if ((texture.Key == "Texture") || (texture.Key == "NormalMap") || (texture.Key == "SpecularMap")) { deferredShadingMaterial.Textures.Add(texture.Key, texture.Value); } } return(context.Convert <MaterialContent, MaterialContent>(deferredShadingMaterial, typeof(MaterialProcessor).Name)); }
/// <summary> /// Creates new material with the new effect file. /// </summary> public override MaterialContent Process(MaterialContent input, ContentProcessorContext context) { if (string.IsNullOrEmpty(customEffect)) { throw new ArgumentException("Custom Effect not set to an effect file"); } // Create a new effect material. EffectMaterialContent customMaterial = new EffectMaterialContent(); // Point the new material at the custom effect file. string effectFile = Path.GetFullPath(customEffect); customMaterial.Effect = new ExternalReference <EffectContent>(effectFile); // Loop over the textures in the current material adding them to // the new material. foreach (KeyValuePair <string, ExternalReference <TextureContent> > textureContent in input.Textures) { customMaterial.Textures.Add(textureContent.Key, textureContent.Value); } // Loop over the opaque data in the current material adding them to // the new material. foreach (KeyValuePair <string, Object> opaqueData in input.OpaqueData) { customMaterial.OpaqueData.Add(opaqueData.Key, opaqueData.Value); } // Call the base material processor to continue the rest of the processing. return(base.Process(customMaterial, context)); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { var myMaterial = new EffectMaterialContent(); var effectPath = Path.GetFullPath("Effect/Phong.fx"); myMaterial.Effect = new ExternalReference<EffectContent>(effectPath); // マテリアル名をエフェクトに渡す(TODO: これ渡せてないなあ・・・) Console.WriteLine("Material name : " + material.Name); myMaterial.Effect.Name = material.Name; if (material is BasicMaterialContent) { var basicMaterial = (BasicMaterialContent)material; myMaterial.OpaqueData.Add("DiffuseColor", basicMaterial.DiffuseColor); myMaterial.OpaqueData.Add("Alpha", basicMaterial.Alpha); myMaterial.OpaqueData.Add("EmissiveColor", basicMaterial.EmissiveColor); myMaterial.OpaqueData.Add("SpecularColor", basicMaterial.SpecularColor); myMaterial.OpaqueData.Add("SpecularPower", 4.0f); } else if (material is EffectMaterialContent) { var effectMaterial = (EffectMaterialContent)material; } else { throw new Exception("unknown material"); } return base.ConvertMaterial(myMaterial, context); }
/// <summary> /// Converts a <see cref="BasicMaterialContent"/> to an equivalent /// <see cref="SkinnedMaterialContent"/>. /// </summary> /// <param name="material">The <see cref="BasicMaterialContent"/>.</param> /// <returns>The <see cref="SkinnedMaterialContent"/>.</returns> public static SkinnedMaterialContent ConvertToSkinnedMaterial(MaterialContent material) { var skinnedMaterial = material as SkinnedMaterialContent; if (skinnedMaterial != null) return skinnedMaterial; var basicMaterial = material as BasicMaterialContent; if (basicMaterial != null) { skinnedMaterial = new SkinnedMaterialContent { Name = basicMaterial.Name, Identity = basicMaterial.Identity, Alpha = basicMaterial.Alpha, DiffuseColor = basicMaterial.DiffuseColor, EmissiveColor = basicMaterial.EmissiveColor, SpecularColor = basicMaterial.SpecularColor, SpecularPower = basicMaterial.SpecularPower, WeightsPerVertex = null }; skinnedMaterial.Textures.AddRange(basicMaterial.Textures); return skinnedMaterial; } return null; }
/// <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( "InstancedSkinnedModelProcessor 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("SkinnedModelInstancing.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); }
/// <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> /// 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 void ExtractTextures(EffectMaterialContent lppMaterial, MaterialContent material) { foreach (KeyValuePair <String, ExternalReference <TextureContent> > texture in material.Textures) { if (texture.Key.ToLower().Equals("diffusemap") || texture.Key.ToLower().Equals("texture")) { lppMaterial.Textures.Add(DiffuseMapKey, texture.Value); } if (texture.Key.ToLower().Equals("normalmap")) { lppMaterial.Textures.Add(NormalMapKey, texture.Value); } if (texture.Key.ToLower().Equals("specularmap")) { lppMaterial.Textures.Add(SpecularMapKey, texture.Value); } if (texture.Key.ToLower().Equals("emissivemap") || texture.Key.ToLower().Equals("emissive")) { lppMaterial.Textures.Add(EmissiveMapKey, texture.Value); } if (texture.Key.ToLower().Equals("seconddiffusemap")) { lppMaterial.Textures.Add(SecondDiffuseMapKey, texture.Value); } if (texture.Key.ToLower().Equals("secondnormalmap")) { lppMaterial.Textures.Add(SecondNormalMapKey, texture.Value); } if (texture.Key.ToLower().Equals("secondspecularmap")) { lppMaterial.Textures.Add(SecondSpecularMapKey, texture.Value); } if (texture.Key.ToLower().Equals("reflectionmap")) { lppMaterial.Textures.Add(ReflectionMapKey, texture.Value); } } ExternalReference <TextureContent> externalRef; if (!lppMaterial.Textures.TryGetValue(DiffuseMapKey, out externalRef)) { lppMaterial.Textures[DiffuseMapKey] = new ExternalReference <TextureContent>("textures/default_diffuse.tga"); } if (!lppMaterial.Textures.TryGetValue(NormalMapKey, out externalRef)) { lppMaterial.Textures[NormalMapKey] = new ExternalReference <TextureContent>("textures/default_normal.tga"); } if (!lppMaterial.Textures.TryGetValue(SpecularMapKey, out externalRef)) { lppMaterial.Textures[SpecularMapKey] = new ExternalReference <TextureContent>("textures/default_specular.tga"); } if (!lppMaterial.Textures.TryGetValue(EmissiveMapKey, out externalRef)) { lppMaterial.Textures[EmissiveMapKey] = new ExternalReference <TextureContent>("textures/default_emissive.tga"); } }
/// <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("Effects\\PreEffects\\TexturingEffect.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("DefaultTexture", 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); }
protected override MaterialContent Convert(Assimp.Material srcMaterial) { var dstMaterial = new MaterialContent(); dstMaterial.Name = srcMaterial.Name; dstMaterial.DoubleSided = srcMaterial.HasTwoSided; dstMaterial.Mode = srcMaterial.BlendMode == Assimp.BlendMode.Default ? MaterialBlendMode.Opaque : MaterialBlendMode.Blend; dstMaterial.AlphaCutoff = 0.5f; if (srcMaterial.IsPBRMaterial) { dstMaterial.PreferredShading = "MetallicRoughness"; SetTexture(dstMaterial, "Normals", srcMaterial.PBR.TextureNormalCamera); SetTexture(dstMaterial, "BaseColor", srcMaterial.PBR.TextureBaseColor); SetTexture(dstMaterial, "MetallicRoughness", srcMaterial.PBR.TextureMetalness); SetTexture(dstMaterial, "Emissive", srcMaterial.PBR.TextureEmissionColor); } else { dstMaterial.PreferredShading = "MetallicRoughness"; SetTexture(dstMaterial, "BaseColor", srcMaterial.TextureDiffuse); } return(dstMaterial); }
private void Upload(MaterialContent data) { data.ContentID = UuidHelper.NewUuidString(); string sql = ORMapping.GetInsertSql(data, TSqlBuilder.Instance); DbHelper.RunSql(db => db.ExecuteNonQuery(CommandType.Text, sql), "UAT"); }
/// <summary> /// Converts an input material to use our custom InstancedModel effect. /// </summary> MaterialContent ProcessMaterial(MaterialContent material) { // Have we already processed this material? if (!processedMaterials.ContainsKey(material)) { // If not, process it now. EffectMaterialContent instancedMaterial = new EffectMaterialContent(); // Set the material to use our custom instancing effect. instancedMaterial.Effect = new ExternalReference <EffectContent>( "InstancedModel.fx", rootNode.Identity); // Copy across the texture setting from the input material. if (!material.Textures.ContainsKey("Texture")) { throw new InvalidContentException( "Material has no texture, but the InstancedModel " + "effect does not support untextured materials."); } instancedMaterial.Textures.Add("Texture", material.Textures["Texture"]); // Chain to the built-in MaterialProcessor, which will // build the effect and texture referenced by this material. processedMaterials[material] = context.Convert <MaterialContent, MaterialContent>(instancedMaterial, "MaterialProcessor"); } return(processedMaterials[material]); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { EffectMaterialContent lppMaterial = new EffectMaterialContent(); OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters["ColorKeyColor"] = this.ColorKeyColor; processorParameters["ColorKeyEnabled"] = false; processorParameters["TextureFormat"] = this.TextureFormat; processorParameters["GenerateMipmaps"] = this.GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; processorParameters["PremultiplyTextureAlpha"] = false; processorParameters["ColorKeyEnabled"] = false; lppMaterial.Effect = new ExternalReference <EffectContent>(_customFx.Length == 0 ? "shaders/LPPMainEffect.fx" : _customFx); lppMaterial.CompiledEffect = context.BuildAsset <EffectContent, CompiledEffectContent>(lppMaterial.Effect, "EffectProcessor"); // copy the textures in the original material to the new lpp // material ExtractTextures(lppMaterial, material); //extract the extra parameters ExtractDefines(lppMaterial, material, context); // and convert the material using the NormalMappingMaterialProcessor, // who has something special in store for the normal map. return(context.Convert <MaterialContent, MaterialContent> (lppMaterial, typeof(LightPrePassMaterialProcessor).Name, processorParameters)); }
protected override MaterialContent Convert(SharpGLTF.Schema2.Material srcMaterial) { var dstMaterial = new MaterialContent(); dstMaterial.Name = srcMaterial.Name; dstMaterial.Tag = _TagConverter?.Invoke(srcMaterial); dstMaterial.DoubleSided = srcMaterial.DoubleSided; dstMaterial.AlphaCutoff = srcMaterial.AlphaCutoff; switch (srcMaterial.Alpha) { case SharpGLTF.Schema2.AlphaMode.OPAQUE: dstMaterial.Mode = MaterialBlendMode.Opaque; break; case SharpGLTF.Schema2.AlphaMode.MASK: dstMaterial.Mode = MaterialBlendMode.Mask; break; case SharpGLTF.Schema2.AlphaMode.BLEND: dstMaterial.Mode = MaterialBlendMode.Blend; break; } if (srcMaterial.Unlit) { dstMaterial.PreferredShading = "Unlit"; } else if (srcMaterial.FindChannel("SpecularGlossiness") != null) { dstMaterial.PreferredShading = "SpecularGlossiness"; } else if (srcMaterial.FindChannel("MetallicRoughness") != null) { dstMaterial.PreferredShading = "MetallicRoughness"; } foreach (var srcChannel in srcMaterial.Channels) { var dstChannel = dstMaterial.UseChannel(srcChannel.Key); dstChannel.Value = ParamToArray(srcChannel); if (srcChannel.Texture != null) { var imgData = srcChannel.Texture.PrimaryImage.Content.Content.ToArray(); var texContent = new ImageContent(imgData); dstChannel.TextureIndex = UseTexture(texContent); dstChannel.Sampler = ToXna(srcChannel.Texture.Sampler); } else { dstChannel.Sampler = SamplerStateContent.CreateDefault(); } dstChannel.VertexIndexSet = srcChannel.TextureCoordinate; dstChannel.Transform = (srcChannel.TextureTransform?.Matrix ?? System.Numerics.Matrix3x2.Identity).ToXna(); } return(dstMaterial); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { string effectFile = this.effectFileName; if (string.IsNullOrEmpty(effectFile)) { if (string.IsNullOrEmpty(this.normalMapTexture)) { if (string.IsNullOrEmpty(this.diffuseTexture)) { effectFile = "Effects\\DefaultSolidColor.fx"; } else { effectFile = "Effects\\Default.fx"; } } else { effectFile = "Effects\\DefaultNormalMap.fx"; } } EffectMaterialContent normalMappingMaterial = new EffectMaterialContent(); normalMappingMaterial.Effect = new ExternalReference <EffectContent>(Path.Combine(directory, effectFile)); OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters["ColorKeyColor"] = this.ColorKeyColor; processorParameters["ColorKeyEnabled"] = this.ColorKeyEnabled; processorParameters["TextureFormat"] = this.TextureFormat; processorParameters["PremultiplyTextureAlpha"] = this.PremultiplyTextureAlpha; processorParameters["PremultiplyVertexColors"] = this.PremultiplyVertexColors; processorParameters["GenerateMipmaps"] = this.GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; // copy the textures in the original material to the new normal mapping // material. this way the diffuse texture is preserved. The // PreprocessSceneHierarchy function has already added the normal map // texture to the Textures collection, so that will be copied as well. foreach (KeyValuePair <String, ExternalReference <TextureContent> > texture in material.Textures) { normalMappingMaterial.Textures.Add(texture.Key, texture.Value); } if (!string.IsNullOrEmpty(diffuseTexture)) { normalMappingMaterial.Textures.Add("DiffuseTexture", new ExternalReference <TextureContent>(Path.Combine(directory, diffuseTexture))); } // and convert the material using the NormalMappingMaterialProcessor, // who has something special in store for the normal map. #if MONOGAME return(context.Convert <MaterialContent, MaterialContent>(normalMappingMaterial, typeof(MGMaterialProcessor).Name, processorParameters)); #else return(context.Convert <MaterialContent, MaterialContent>(normalMappingMaterial, typeof(MaterialProcessor).Name, processorParameters)); #endif }
public TerrainModelContentBuilder(int patchSize, HeightMapContent heightMap, MaterialContent material, int detailTextureTiling, int horizontalScale) { _patchSize = patchSize; _heightMap = heightMap; _material = material; _detailTextureTiling = detailTextureTiling; _horizontalScale = horizontalScale; }
/// <summary> /// Converts a single piece of input geometry into our instanced format. /// </summary> void ProcessGeometry(GeometryContent geometry) { int indexCount = geometry.Indices.Count; int vertexCount = geometry.Vertices.VertexCount; // Validate that the number of vertices is suitable for instancing. if (vertexCount > ushort.MaxValue) { throw new InvalidContentException( string.Format("Geometry contains {0} vertices: " + "this is too many to be instanced.", vertexCount)); } if (vertexCount > ushort.MaxValue / 8) { context.Logger.LogWarning(null, rootNode.Identity, "Geometry contains {0} vertices: " + "this will only allow it to be instanced " + "{1} times per batch. A model with fewer " + "vertices would be more efficient.", vertexCount, ushort.MaxValue / vertexCount); } // Validate that the vertex channels we are going to use to pass // through our instancing data aren't already in use. VertexChannelCollection vertexChannels = geometry.Vertices.Channels; for (int i = 1; i <= 4; i++) { if (vertexChannels.Contains(VertexChannelNames.TextureCoordinate(i))) { throw new InvalidContentException( string.Format("Model already contains data for texture " + "coordinate channel {0}, but instancing " + "requires this channel for its own use.", i)); } } // Flatten the flexible input vertex channel data into // a simple GPU style vertex buffer byte array. VertexBufferContent vertexBufferContent; VertexElement[] vertexElements; geometry.Vertices.CreateVertexBuffer(out vertexBufferContent, out vertexElements, context.TargetPlatform); int vertexStride = VertexDeclaration.GetVertexStrideSize(vertexElements, 0); // Convert the input material. MaterialContent material = ProcessMaterial(geometry.Material); // Add the new piece of geometry to our output model. outputModel.AddModelPart(indexCount, vertexCount, vertexStride, vertexElements, vertexBufferContent, geometry.Indices, material); }
/// <summary> /// Constructor /// </summary> /// <param name="effect">Effect content</param> public Material(MaterialContent effect) { this.EmissiveColor = effect.EmissionColor; this.AmbientColor = effect.AmbientColor; this.DiffuseColor = effect.DiffuseColor; this.SpecularColor = effect.SpecularColor; this.Shininess = effect.Shininess; this.IsTransparent = effect.IsTransparent; }
internal SkinnedModelMeshContent(int numVertices, int numTriangles, VertexBufferContent vertices, IndexCollection indices, MaterialContent material) { this.numVertices = numVertices; this.numTriangles = numTriangles; this.vertices = vertices; this.indices = indices; this.material = material; }
private void InitializeEmitter() { MaterialContent mat = MaterialContent.Default; mat.EmissionColor = Color.White; GeometryUtil.CreateSphere( 0.1f, 16, 5, out Vector3[] v, out Vector3[] n, out Vector2[] uv, out uint[] ix);
public override MaterialContent Process(MaterialContent input, ContentProcessorContext context) { if (context.Parameters.ContainsKey("Defines")) context.Parameters.Remove("Defines"); if (input.OpaqueData.ContainsKey("Defines")) context.Parameters.Add("Defines", input.OpaqueData["Defines"]); return base.Process(input, context); }
private static MeshContent CreateBasicMesh(MaterialContent material) { var builder = MeshBuilder.StartMesh("Mesh1"); builder.SetMaterial(material); CreatePositions(builder); AddVertices(builder); return(builder.FinishMesh()); }
private string FindTexture(MeshContent mesh, MaterialContent material, params string[] possibleKeys) { foreach (var key in possibleKeys) { // search in existing material textures foreach (var item in material.Textures) { if (item.Key.ToLowerInvariant() == key) { return(item.Value.Filename); } } // search in material opaque data foreach (var item in material.OpaqueData) { if (item.Key.ToLowerInvariant() == key && item.Value.GetType() == typeof(string)) { var file = item.Value as string; if (!Path.IsPathRooted(file)) { file = Path.Combine(directory, file); } return(file); } } // search in mesh opaque data foreach (var item in mesh.OpaqueData) { if (item.Key.ToLowerInvariant() == key && item.Value.GetType() == typeof(string)) { var file = item.Value as string; if (!Path.IsPathRooted(file)) { file = Path.Combine(directory, file); } return(file); } } } // try and find the file in the meshs' directory foreach (var key in possibleKeys) { foreach (var file in Directory.EnumerateFiles(directory, mesh.Name + "_" + key + ".*", SearchOption.AllDirectories)) { return(file); } } // cant find anything return(null); }
public override void SaveMaterialContent(MaterialContent content) { SourceFileInfo.NullCheck("SourceFileInfo"); DestFileInfo.NullCheck("DestFileInfo"); if (CheckSourceFileExists) ExceptionHelper.FalseThrow(SourceFileInfo.Exists, string.Format(Resource.FileNotFound, SourceFileInfo.Name)); MoveFile(SourceFileInfo, DestFileInfo); }
public MaterialContent CreateMaterial(ContentProcessorContext context, Dictionary <string, object> parameters) { MaterialContent content = new MaterialContent() { Name = _name }; int i = 0; foreach (PassTemplate template in _passes) { MaterialContent.Pass pass = new MaterialContent.Pass(string.IsNullOrEmpty(template.Name) ? string.Format("{0}_Pass_{1}", _name, i) : template.Name); pass.VertexShaderSources.AddRange(template.VertexShaders.Select(s => new ExternalReferenceContent <ShaderSourceContent>(s))); pass.FragmentShaderSources.AddRange(template.FragmentShaders.Select(s => new ExternalReferenceContent <ShaderSourceContent>(s))); foreach (UniformDefinition def in template.Variables) { UniformValueContent value = null; object o; if (!parameters.TryGetValue(def.Name, out o)) { foreach (string name in def.Aliases) { if (parameters.TryGetValue(name, out o)) { break; } } } if (o != null) { value = GetAsUniformValueContent(def.Type, def.Name, o, context); } if (value == null) // no match, or not able to convert to uniform type { value = def.Value; } pass.Parameters[def.Name] = value; } foreach (UniformDefinition def in template.Constants) { pass.Parameters[def.Name] = def.Value; } pass.ComparisonParameters = template.ComparisonParameters; i++; content.Passes.Add(pass); } return(content); }
private string FindSpecularTexture(MeshContent mesh, MaterialContent material) { if (string.IsNullOrEmpty(SpecularTexture)) { return(FindTexture(mesh, material, "specularmap", "specular", "spec", "s") ?? "null_specular.tga"); } else { return(Path.Combine(directory, SpecularTexture)); } }
MaterialContent ProcessMaterial(MaterialContent material) { // Have we already processed this material? if (!processedMaterials.ContainsKey(material)) { // If not, process it now. processedMaterials[material] = context.Convert <MaterialContent, MaterialContent>(material, "MaterialProcessor"); } return(processedMaterials[material]); }
public static void Save(MaterialContent content) { IMaterialContentPersistManager manager = MaterialContentSettings.GetConfig().PersistManager; string path = GetUploadRootPath("ImageUploadRootPath"); string fileName = Path.Combine(path + @"Temp\", content.FileName); if (manager is FileMaterialContentPersistManager) manager.DestFileInfo = new System.IO.FileInfo(Path.Combine(path, content.FileName)); manager.SourceFileInfo = new System.IO.FileInfo(fileName); manager.SaveMaterialContent(content); }
public override MaterialContent Process(MaterialContent input, ContentProcessorContext context) { SkinnedModelMaterialContent skinnedModelMaterialContent = new SkinnedModelMaterialContent(); // Processes all textures ProcessTextures(input, skinnedModelMaterialContent, context); // Processes surface material ProcessMaterial(input, skinnedModelMaterialContent, context); return skinnedModelMaterialContent; }
/// <summary> /// Use our custom material processor /// to convert selected materials in this model. /// </summary> protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { if (CustomMaterialProcessor == "") return base.ConvertMaterial(material, context); OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters.Add("Section", section); return context.Convert<MaterialContent, MaterialContent>(material, CustomMaterialProcessor, processorParameters); }
/// <summary> /// Override the ConvertMaterial method to apply our custom InstancedModel.fx shader. /// </summary> protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { EffectMaterialContent newMaterial = new EffectMaterialContent(); newMaterial.Effect = new ExternalReference<EffectContent>("SKraftShader.fx", rootIdentity); BasicMaterialContent basicMaterial = material as BasicMaterialContent; if ((basicMaterial != null) && (basicMaterial.Texture != null)) { newMaterial.Textures.Add("Texture", basicMaterial.Texture); } return base.ConvertMaterial(newMaterial, context); }
private static MaterialContent PrepareMaterialContent(string contentID, string relativeID) { MaterialContent content = new MaterialContent(); content.ContentID = contentID; content.RelativeID = relativeID; content.Class = "MaterialTest"; string data = string.Format("Have a good day '{0}'!", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")); content.ContentData = Encoding.UTF8.GetBytes(data); return content; }
/// <summary> /// Use our custom EnvironmentMappedMaterialProcessor /// to convert all the materials on this model. /// </summary> protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters["ColorKeyColor"] = ColorKeyColor; processorParameters["ColorKeyEnabled"] = ColorKeyEnabled; processorParameters["TextureFormat"] = TextureFormat; processorParameters["GenerateMipmaps"] = GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = ResizeTexturesToPowerOfTwo; return context.Convert<MaterialContent, MaterialContent>(material, "TankModelMaterialProcessor", processorParameters); }
protected virtual DRMaterialContent OnConvertMaterial(MaterialContent material, ContentProcessorContext context) { //var processorParameters = new OpaqueDataDictionary //{ // { "ColorKeyColor", ColorKeyColor }, // { "ColorKeyEnabled", ColorKeyEnabled }, // { "GenerateMipmaps", GenerateMipmaps }, // { "PremultiplyTextureAlpha", PremultiplyTextureAlpha }, // { "ResizeTexturesToPowerOfTwo", ResizeTexturesToPowerOfTwo }, // { "TextureFormat", TextureFormat }, // { "DefaultEffectType", DefaultEffectType }, // { "DefaultEffectFile", DefaultEffectFile }, //}; return context.Convert<MaterialContent, DRMaterialContent>(material, typeof(DRMaterialProcessor).Name/*, processorParameters*/); }
/// <summary> /// Use the CustomEffectMaterialProcessor for all of the materials in the model. /// We pass the processor parameter along to the material processor for the /// effect file name. /// </summary> protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters.Add("CustomEffect", customEffect); processorParameters["ColorKeyColor"] = this.ColorKeyColor; processorParameters["ColorKeyEnabled"] = this.ColorKeyEnabled; processorParameters["TextureFormat"] = this.TextureFormat; processorParameters["GenerateMipmaps"] = this.GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; return context.Convert<MaterialContent, MaterialContent>(material, "CustomEffectMaterialProcessor", processorParameters); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { var customMaterial = new EffectMaterialContent(); var effectPath = Path.GetFullPath(effectFilename); customMaterial.Effect = new ExternalReference<EffectContent>(effectPath); var parameters = new OpaqueDataDictionary(); parameters["ColorKeyColor"] = ColorKeyColor; parameters["ColorKeyEnabled"] = ColorKeyEnabled; parameters["TextureFormat"] = TextureFormat; parameters["GenerateMipmaps"] = GenerateMipmaps; parameters["ResizeTexturesToPowerOfTwo"] = ResizeTexturesToPowerOfTwo; return context.Convert<MaterialContent, MaterialContent>( customMaterial, typeof(MaterialProcessor).Name, parameters); }
private void SaveMaterialContentFromData(MaterialContent content) { content.FileSize = content.ContentData.Length; using (TransactionScope scope = TransactionScopeFactory.Create()) { using (MemoryStream stream = new MemoryStream(content.ContentData)) { MaterialContentAdapter.Instance.Update(content, stream); TransactionScopeFactory.AttachCommittedAction(new Action<TransactionEventArgs>(Current_TransactionCompleted), false); } scope.Complete(); } }
public override MaterialContent Process(MaterialContent input, ContentProcessorContext context) { // Create a new material effect EffectMaterialContent customMaterial = new EffectMaterialContent(); // Access the input as a basic material BasicMaterialContent basicMaterial = (BasicMaterialContent)input; // If Texture is null, we are not using texture mapping. Otherwise, we are if (skinned) { string effectFile = Path.GetFullPath("SkinnedEffect.fx"); customMaterial.Effect = new ExternalReference<EffectContent>(effectFile); customMaterial.Textures.Add("Texture", basicMaterial.Texture); section = 1; } else if (basicMaterial.Texture == null) { // I don't know why, but sometimes you get an invalid material. So, // I just let the base processor handle it. if (basicMaterial.DiffuseColor == null) return base.Process(input, context); string effectFile = Path.GetFullPath("PhibesEffect1.fx"); customMaterial.Effect = new ExternalReference<EffectContent>(effectFile); customMaterial.OpaqueData.Add("DiffuseColor", basicMaterial.DiffuseColor); } else { string effectFile = Path.GetFullPath("PhibesEffect2.fx"); customMaterial.Effect = new ExternalReference<EffectContent>(effectFile); customMaterial.Textures.Add("Texture", basicMaterial.Texture); } customMaterial.OpaqueData.Add("Light1Location", LightInfo(section, 0)); customMaterial.OpaqueData.Add("Light1Color", LightInfo(section, 1)); customMaterial.OpaqueData.Add("Light2Location", LightInfo(section, 2)); customMaterial.OpaqueData.Add("Light2Color", LightInfo(section, 3)); customMaterial.OpaqueData.Add("Light3Location", LightInfo(section, 4)); customMaterial.OpaqueData.Add("Light3Color", LightInfo(section, 5)); // Chain to the base material processor. return base.Process(customMaterial, context); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { EffectMaterialContent lppMaterial = new EffectMaterialContent(); OpaqueDataDictionary processorParameters = new OpaqueDataDictionary(); processorParameters["ColorKeyColor"] = this.ColorKeyColor; processorParameters["ColorKeyEnabled"] = this.ColorKeyEnabled; processorParameters["TextureFormat"] = this.TextureFormat; processorParameters["GenerateMipmaps"] = this.GenerateMipmaps; processorParameters["ResizeTexturesToPowerOfTwo"] = this.ResizeTexturesToPowerOfTwo; processorParameters["PremultiplyTextureAlpha"] = false; processorParameters["ColorKeyEnabled"] = false; lppMaterial.Effect = new ExternalReference<EffectContent>("shaders/LPPMainEffect.fx"); lppMaterial.CompiledEffect = context.BuildAsset<EffectContent, CompiledEffectContent>(lppMaterial.Effect, "EffectProcessor"); //extract the extra parameters ExtractDefines(lppMaterial, material, context); // copy the textures in the original material to the new normal mapping // material. this way the diffuse texture is preserved. The // PreprocessSceneHierarchy function has already added the normal map // texture to the Textures collection, so that will be copied as well. foreach (KeyValuePair<String, ExternalReference<TextureContent>> texture in material.Textures) { lppMaterial.Textures.Add(texture.Key, texture.Value); } try { lppMaterial.OpaqueData.Add("DiffuseColor", new Vector4((Vector3)material.OpaqueData["DiffuseColor"], (float)material.OpaqueData["Alpha"])); lppMaterial.OpaqueData.Add("SpecularColor", material.OpaqueData["SpecularColor"]); lppMaterial.OpaqueData.Add("SpecularPower", material.OpaqueData["SpecularPower"]); } catch (Exception ex) { Console.WriteLine(ex); } // and convert the material using the NormalMappingMaterialProcessor, // who has something special in store for the normal map. return context.Convert<MaterialContent, MaterialContent> (lppMaterial, typeof(LightPrePassMaterialProcessor).Name, processorParameters); }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { BasicMaterialContent basicMaterialContent = material as BasicMaterialContent; bool texture = basicMaterialContent != null; if (texture) { EffectMaterialContent effectMaterialContent = new EffectMaterialContent(); string fullPath = Path.GetFullPath("SkinnedModel.fx"); effectMaterialContent.Effect = new ExternalReference<EffectContent>(fullPath); texture = basicMaterialContent.Texture == null; if (!texture) { effectMaterialContent.Textures.Add("Texture", basicMaterialContent.Texture); } MaterialContent materialContent = base.ConvertMaterial(effectMaterialContent, context); return materialContent; } else { throw new InvalidContentException(string.Format("SkinnedModelProcessor only supports BasicMaterialContent, but input mesh uses {0}.", material.GetType())); } }
protected override MaterialContent ConvertMaterial(MaterialContent material, ContentProcessorContext context) { if (string.IsNullOrEmpty(StitchedEffect)) throw new Exception("Stitched Effect property must be set for StitchUp Model Processor."); string fullPath = Path.GetFullPath(Path.Combine(new FileInfo(material.Identity.SourceFilename).DirectoryName, StitchedEffect)); context.AddDependency(fullPath); EffectMaterialContent effectMaterial = new EffectMaterialContent { CompiledEffect = context.BuildAsset<StitchedEffectContent, CompiledEffectContent>(new ExternalReference<StitchedEffectContent>(fullPath), typeof(StitchedEffectProcessor).Name), Identity = material.Identity, Name = material.Name }; return effectMaterial; }
/// <summary> /// Helper function used by the CustomModelProcessor /// to add new ModelPart information. /// </summary> public void AddModelPart( int triangleCount, int vertexCount, int vertexStride, VertexElement[] vertexElements, VertexBufferContent vertexBufferContent, IndexCollection indexCollection, MaterialContent materialContent) { ModelPart modelPart = new ModelPart(); modelPart.TriangleCount = triangleCount; modelPart.VertexCount = vertexCount; modelPart.VertexStride = vertexStride; modelPart.VertexElements = vertexElements; modelPart.VertexBufferContent = vertexBufferContent; modelPart.IndexCollection = indexCollection; modelPart.MaterialContent = materialContent; modelParts.Add( modelPart ); }
public void UpdateMaterialContent() { const string template = "Hello world !"; MaterialContent content = new MaterialContent(); content.ContentID = UuidHelper.NewUuidString(); content.RelativeID = UuidHelper.NewUuidString(); content.ContentData = PrepareSimpleData(template); MaterialContentAdapter.Instance.Update(content); MaterialContentCollection contentLoaded = MaterialContentAdapter.Instance.Load(builder => builder.AppendItem("CONTENT_ID", content.ContentID)); Assert.IsTrue(contentLoaded.Count > 0); string dataRead = Encoding.UTF8.GetString(contentLoaded[0].ContentData); Assert.AreEqual(template, dataRead); }