private static void AssertBasicContentMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
AssertMinimumContentMetaData(xmlMetaData, metaData.Name, metaData.Type.ToString(),
metaData.LastTimeUpdated);
Assert.AreEqual(metaData.LocalFilePath, xmlMetaData.GetAttributeValue("LocalFilePath"));
Assert.AreEqual(metaData.FileSize.ToString(), xmlMetaData.GetAttributeValue("FileSize"));
}
private static ContentMetaData CreateMaterialMetaData(string name)
{
var metaData = new ContentMetaData {
Name = name, Type = ContentType.Material
};
if (!name.Contains("NoShader"))
{
AddShaderNameToMetaData(metaData);
}
if (!name.Contains("NoImage"))
{
if (name.Contains("ImageAnimation"))
{
metaData.Values.Add("ImageOrAnimationName", "ImageAnimation");
}
else if (name.Contains("SpriteSheet"))
{
metaData.Values.Add("ImageOrAnimationName", "SpriteSheet");
}
else
{
metaData.Values.Add("ImageOrAnimationName", "DeltaEngineLogo");
}
}
metaData.Values.Add("LightMapName", "lightMap");
return(metaData);
}
//ncrunch: no coverage start
protected virtual ContentMetaData CreateContentMetaData(string contentFilePath)
{
var metaDataCreator = new ContentMetaDataCreator();
ContentMetaData contentMetaData = metaDataCreator.CreateMetaDataFromFile(contentFilePath);
return(contentMetaData);
} //ncrunch: no coverage end
private static void AssertBasicContentMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
AssertMinimumContentMetaData(xmlMetaData, metaData.Name, metaData.Type.ToString(),
metaData.LastTimeUpdated);
Assert.AreEqual(metaData.LocalFilePath, xmlMetaData.GetAttributeValue("LocalFilePath"));
Assert.AreEqual(metaData.FileSize.ToString(), xmlMetaData.GetAttributeValue("FileSize"));
}
public void Save()
{
if (NewMaterial == null || materialName == "")
{
return;
}
if (materialName == selectedImage) //ncrunch: no coverage start
{
if (GetDialogResultToRenameMaterial())
{
MaterialName += "Material";
}
else
{
return;
}
}
if (MaterialList.Contains(MaterialName))
{
if (!GetDialogResultToSaveMaterial())
{
return;
}
}
var metaDataCreator = new ContentMetaDataCreator();
ContentMetaData contentMetaData = metaDataCreator.CreateMetaDataFromMaterial(materialName,
NewMaterial);
service.UploadContent(contentMetaData);
}
private static ContentMetaData ParseContentMetaData(IEnumerable<XAttribute> attributes)
{
var data = new ContentMetaData();
foreach (var attribute in attributes)
switch (attribute.Name.LocalName)
{
case "Name":
data.Name = attribute.Value;
break;
case "Type":
data.Type = attribute.Value.TryParse(ContentType.Image);
break;
case "LastTimeUpdated":
data.LastTimeUpdated = DateExtensions.Parse(attribute.Value);
break;
case "LocalFilePath":
data.LocalFilePath = attribute.Value;
break;
case "PlatformFileId":
data.PlatformFileId = attribute.Value.Convert<int>();
break;
case "FileSize":
data.FileSize = attribute.Value.Convert<int>();
break;
default:
data.Values.Add(attribute.Name.LocalName, attribute.Value);
break;
}
if (string.IsNullOrEmpty(data.Name))
throw new InvalidContentMetaDataNameIsAlwaysNeeded();
return data;
}
private static void SetDefaultValues(ContentMetaData contentMetaData, string name)
{
contentMetaData.Name = name;
contentMetaData.LastTimeUpdated = DateTime.Now;
contentMetaData.PlatformFileId = 0;
contentMetaData.Language = "en";
}
public long AddAsset(string title, string filename, long folderId, int languageId, long externalTypeid, byte[] filestream, ContentMetaData[] potentialMeta)
{
try
{
assetManager = new AssetManager();
assetManager.ContentLanguage = languageId;
if (string.IsNullOrEmpty(userauthHeader.AuthenticationToken))
throw new SoapException("User not logged in", SoapException.ClientFaultCode);
this.ImpersonateUser(userauthHeader.AuthenticationToken, assetManager.RequestInformation);
ContentAssetData contentassetdata = new ContentAssetData()
{
FolderId = folderId,
Title = title,
File = filestream,
LanguageId = languageId,
ExternalTypeId = externalTypeid,
AssetData = new AssetData { FileName = filename },
MetaData = potentialMeta
};
return assetManager.Add(contentassetdata).Id;
}
catch (Exception ex)
{
throw new SoapException("Error adding an asset:" + ex.Message, SoapException.ClientFaultCode);
}
}
public static ContentMetaDataView ToViewModel(this ContentMetaData source)
{
return(new ContentMetaDataView
{
Tags = source.Tags
});
}
public override ContentMetaData GetMetaData(string contentName, Type contentClassType = null)
{
var metaData = new ContentMetaData { Type = ContentType.Xml };
if (contentName.Contains("WrongPath"))
metaData.LocalFilePath = "No.xml";
return metaData;
}
private static ContentMetaData GetBasicTestContentMetaData()
{
ContentMetaData basicMetaData = GetMinimumTestContentMetaData();
basicMetaData.LocalFilePath = "ImagePixel.data";
basicMetaData.FileSize = 0;
return(basicMetaData);
}
private static ContentMetaData CreateSceneMetaData(string contentName)
{
var metaData = new ContentMetaData {
Name = contentName, Type = ContentType.Scene
};
return(metaData);
}
private static void TryAddImageDataFromBitmapToContentMetaData(string filePath,
ContentMetaData metaData)
{
var bitmap = new Bitmap(filePath);
metaData.Values.Add("PixelSize", "(" + bitmap.Width + "," + bitmap.Height + ")");
if (!HasBitmapAlphaPixels(bitmap))
metaData.Values.Add("BlendMode", "Opaque");
}
private static ContentMetaData CreateSoundData(string contentName)
{
var metaData = new ContentMetaData {
Name = contentName, Type = ContentType.Sound
};
metaData.Values.Add("Length", "1.3");
return(metaData);
}
private static ContentMetaData CreateShaderData(string contentName)
{
var metaData = new ContentMetaData {
Name = contentName, Type = ContentType.Shader
};
metaData.Values.Add("Flags", "UI2D, UV, Color");
return(metaData);
}
public ContentMetaData CreateMetaDataFromParticle(string particleName, byte[] byteArray)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, particleName);
contentMetaData.Type = ContentType.ParticleEmitter;
contentMetaData.LocalFilePath = particleName + ".deltaparticle";
contentMetaData.FileSize = byteArray.Length;
return contentMetaData;
}
public void Upload(ContentMetaData contentMetaData,
Dictionary<string, byte[]> optionalFileData)
{
var fileList = new List<UpdateContent.FileNameAndBytes>();
if (optionalFileData != null)
foreach (var data in optionalFileData)
fileList.Add(new UpdateContent.FileNameAndBytes { name = data.Key, data = data.Value });
connection.Send(new UpdateContent(contentMetaData, fileList.ToArray()));
}
public void ConvertBasicContentMetaDataToXml()
{
ContentMetaData testMetaData = GetBasicTestContentMetaData();
Assert.IsEmpty(projectMetaData.Children);
projectMetaData.AddMetaDataEntry(testMetaData);
Assert.AreEqual(1, projectMetaData.Children.Count);
AssertFullContentMetaDataEntry(projectMetaData.Children[0], testMetaData);
}
public ContentMetaData CreateMetaDataFromLevelData(string levelName, byte[] byteArray)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, levelName);
contentMetaData.Type = ContentType.Level;
contentMetaData.LocalFilePath = levelName + ".xml";
contentMetaData.FileSize = byteArray.Length;
return(contentMetaData);
}
public ContentMetaData CreateMetaDataFromInputData(byte[] byteArray)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, "InputCommands");
contentMetaData.Type = ContentType.InputCommand;
contentMetaData.LocalFilePath = "InputCommands.xml";
contentMetaData.FileSize = byteArray.Length;
return(contentMetaData);
}
protected override ContentMetaData CreateContentMetaData(string contentFilePath)
{
var contentMetaData = new ContentMetaData();
contentMetaData.Name = Path.GetFileNameWithoutExtension(contentFilePath);
contentMetaData.Type = ContentType.JustStore;
contentMetaData.LastTimeUpdated = DateTime.Now;
contentMetaData.LocalFilePath = Path.GetFileName(contentFilePath);
contentMetaData.FileSize = 5;
return contentMetaData;
}
public ContentMetaData CreateMetaDataFromParticle(string particleName, byte[] byteArray)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, particleName);
contentMetaData.Type = ContentType.ParticleEmitter;
contentMetaData.LocalFilePath = particleName + ".deltaparticle";
contentMetaData.FileSize = byteArray.Length;
return(contentMetaData);
}
private static void AddBasicMetaDataValues(XmlData xmlMetaData, ContentMetaData metaData)
{
xmlMetaData.AddAttribute("Name", metaData.Name);
xmlMetaData.AddAttribute("Type", metaData.Type);
xmlMetaData.AddAttribute("LastTimeUpdated", metaData.LastTimeUpdated.GetIsoDateTime());
if (metaData.LocalFilePath == null)
return;
xmlMetaData.AddAttribute("LocalFilePath", metaData.LocalFilePath);
xmlMetaData.AddAttribute("FileSize", metaData.FileSize);
}
public ContentMetaData CreateMetaDataFromUI(string uiName, byte[] byteArray)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, uiName);
contentMetaData.Type = ContentType.Scene;
contentMetaData.LocalFilePath = uiName + ".deltaUI";
contentMetaData.FileSize = byteArray.Length;
return(contentMetaData);
}
private static ContentMetaData CreateImageAnimationNoImagesMetaData(string name)
{
var metaData = new ContentMetaData {
Name = name, Type = ContentType.ImageAnimation
};
metaData.Values.Add("ImageNames", "");
metaData.Values.Add("DefaultDuration", "3");
return(metaData);
}
private static void AssertFullContentMetaDataEntry(XmlData xmlMetaData,
ContentMetaData metaData)
{
AssertBasicContentMetaData(xmlMetaData, metaData);
AssertLanguageInMetaData(xmlMetaData, metaData);
AssertPlatformFileIdInMetaData(xmlMetaData, metaData);
foreach (KeyValuePair<string, string> valuePair in metaData.Values)
Assert.AreEqual(metaData.Values[valuePair.Key],
xmlMetaData.GetAttributeValue(valuePair.Key));
}
public void ConvertMinimumContentMetaDataToXml()
{
ContentMetaData testMetaData = GetMinimumTestContentMetaData();
Assert.IsEmpty(projectMetaData.Children);
projectMetaData.AddMetaDataEntry(testMetaData);
Assert.AreEqual(1, projectMetaData.Children.Count);
AssertMinimumContentMetaData(projectMetaData.Children[0], testMetaData.Name,
testMetaData.Type.ToString(), testMetaData.LastTimeUpdated);
}
public void SaveAnimation(string obj)
{
if (ImageList.Count == 0 || string.IsNullOrEmpty(AnimationName))
{
return;
}
ContentMetaData contentMetaData = SaveImageAnimationOrSpriteSheetAnimation();
service.UploadContent(contentMetaData);
LoadAnimationsFromProject();
}
protected override ContentMetaData CreateContentMetaData(string contentFilePath)
{
var contentMetaData = new ContentMetaData();
contentMetaData.Name = Path.GetFileNameWithoutExtension(contentFilePath);
contentMetaData.Type = ContentType.JustStore;
contentMetaData.LastTimeUpdated = DateTime.Now;
contentMetaData.LocalFilePath = Path.GetFileName(contentFilePath);
contentMetaData.FileSize = 5;
return(contentMetaData);
}
private static ContentMetaData CreateParticleSystemMetaData(string contentName)
{
var metaData = new ContentMetaData
{
Name = contentName,
Type = ContentType.ParticleSystem
};
metaData.Values.Add("EmitterNames", "EmitterAlpha, EmitterBeta");
return(metaData);
}
private static void TryAddImageDataFromBitmapToContentMetaData(string filePath,
ContentMetaData metaData)
{
var bitmap = new Bitmap(filePath);
metaData.Values.Add("PixelSize", "(" + bitmap.Width + "," + bitmap.Height + ")");
if (!HasBitmapAlphaPixels(bitmap))
{
metaData.Values.Add("BlendMode", "Opaque");
}
}
private static ContentMetaData CreateSpriteSheetAnimationMetaData(string name)
{
var metaData = new ContentMetaData {
Name = name, Type = ContentType.SpriteSheetAnimation
};
metaData.Values.Add("ImageName", "EarthImages");
metaData.Values.Add("DefaultDuration", "1.0");
metaData.Values.Add("SubImageSize", "107, 80");
return(metaData);
}
public void ConvertFullContentMetaDataToXml()
{
ContentMetaData testMetaData = GetBasicTestContentMetaData();
testMetaData.Language = "English";
testMetaData.PlatformFileId = 3;
testMetaData.Values.Add("CoolValue", "SuperCool");
testMetaData.Values.Add("AnotherCoolValue", "SuperDuperCool");
projectMetaData.AddMetaDataEntry(testMetaData);
AssertFullContentMetaDataEntry(projectMetaData.Children[0], testMetaData);
}
private static void AssertLanguageInMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
if (metaData.Language == null)
{
Assert.IsFalse(IsAttributeAvailable(xmlMetaData, "Language"));
}
else
{
Assert.AreEqual(metaData.Language, xmlMetaData.GetAttributeValue("Language"));
}
}
private static void RemoveExistingEntry(ContentMetaData entry, XmlData parent)
{
foreach (var child in parent.Children)
{
if (child.GetAttributeValue("Name").Compare(entry.Name))
{
parent.RemoveChild(child);
break;
}
}
}
private static void AddImageDataFromBitmapToContentMetaData(string filePath,
ContentMetaData metaData)
{
try
{
TryAddImageDataFromBitmapToContentMetaData(filePath, metaData);
}
catch (Exception)
{
throw new UnknownImageFormatUnableToAquirePixelSize(filePath);
}
}
private static void AddImageDataFromBitmapToContentMetaData(string filePath,
ContentMetaData metaData)
{
try
{
TryAddImageDataFromBitmapToContentMetaData(filePath, metaData);
}
catch (Exception)
{
throw new UnknownImageFormatUnableToAquirePixelSize(filePath);
}
}
public override ContentMetaData GetMetaData(string contentName, Type contentClassType = null)
{
var metaData = new ContentMetaData {
Type = ContentType.Xml
};
if (contentName.Contains("WrongPath"))
{
metaData.LocalFilePath = "No.xml";
}
return(metaData);
}
private static void AssertPlatformFileIdInMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
if (metaData.PlatformFileId == 0)
{
Assert.IsFalse(IsAttributeAvailable(xmlMetaData, "PlatformFileId"));
}
else
{
Assert.AreEqual(metaData.PlatformFileId.ToString(),
xmlMetaData.GetAttributeValue("PlatformFileId"));
}
}
public ContentMetaData CreateMetaDataFromSpriteSheetAnimation(string animationName,
SpriteSheetAnimation spriteSheetAnimation)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, animationName);
contentMetaData.Type = ContentType.SpriteSheetAnimation;
contentMetaData.Values.Add("DefaultDuration",
spriteSheetAnimation.DefaultDuration.ToString(CultureInfo.InvariantCulture));
contentMetaData.Values.Add("SubImageSize", spriteSheetAnimation.SubImageSize.ToString());
contentMetaData.Values.Add("ImageName", spriteSheetAnimation.Image.Name);
return contentMetaData;
}
private static void AddBasicMetaDataValues(XmlData xmlMetaData, ContentMetaData metaData)
{
xmlMetaData.AddAttribute("Name", metaData.Name);
xmlMetaData.AddAttribute("Type", metaData.Type);
xmlMetaData.AddAttribute("LastTimeUpdated", metaData.LastTimeUpdated.GetIsoDateTime());
if (metaData.LocalFilePath == null)
{
return;
}
xmlMetaData.AddAttribute("LocalFilePath", metaData.LocalFilePath);
xmlMetaData.AddAttribute("FileSize", metaData.FileSize);
}
private static void AssertFullContentMetaDataEntry(XmlData xmlMetaData,
ContentMetaData metaData)
{
AssertBasicContentMetaData(xmlMetaData, metaData);
AssertLanguageInMetaData(xmlMetaData, metaData);
AssertPlatformFileIdInMetaData(xmlMetaData, metaData);
foreach (KeyValuePair <string, string> valuePair in metaData.Values)
{
Assert.AreEqual(metaData.Values[valuePair.Key],
xmlMetaData.GetAttributeValue(valuePair.Key));
}
}
//ncrunch: no coverage start
public ContentMetaData CreateMetaDataFromFile(string filePath)
{
var contentMetaData = new ContentMetaData();
contentMetaData.Name = Path.GetFileNameWithoutExtension(filePath);
contentMetaData.Type = ContentTypeIdentifier.ExtensionToType(filePath);
contentMetaData.LastTimeUpdated = File.GetLastWriteTime(filePath);
contentMetaData.LocalFilePath = Path.GetFileName(filePath);
contentMetaData.PlatformFileId = 0;
contentMetaData.FileSize = (int)new FileInfo(filePath).Length;
if (contentMetaData.Type == ContentType.Image)
AddImageDataFromBitmapToContentMetaData(filePath, contentMetaData);
return contentMetaData;
}
public static void AddMetaDataEntry(this XmlData projectMetaData,
ContentMetaData contentEntry)
{
var newEntry = new XmlData(typeof(ContentMetaData).Name);
AddBasicMetaDataValues(newEntry, contentEntry);
if (contentEntry.Language != null)
newEntry.AddAttribute("Language", contentEntry.Language);
if (contentEntry.PlatformFileId != 0)
newEntry.AddAttribute("PlatformFileId", contentEntry.PlatformFileId);
foreach (KeyValuePair<string, string> valuePair in contentEntry.Values)
newEntry.AddAttribute(valuePair.Key, valuePair.Value);
projectMetaData.AddChild(newEntry);
}
public ContentMetaData CreateMetaDataFromImageAnimation(string animationName,
ImageAnimation animation)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, animationName);
contentMetaData.Type = ContentType.ImageAnimation;
contentMetaData.Values.Add("DefaultDuration",
animation.DefaultDuration.ToString(CultureInfo.InvariantCulture));
string images = "";
for (int index = 0; index < animation.Frames.Length; index++)
images = AddImageToMetaData(animation, index, images);
contentMetaData.Values.Add("ImageNames", images);
return contentMetaData;
}
public override ContentMetaData GetMetaData(string contentName, Type contentClassType = null)
{
if (metaData != null)
return metaData;
metaData = new ContentMetaData { Type = ContentType.Image };
metaData.Values.Add("ImageName", "DeltaEngineLogo");
metaData.Values.Add("UV", Rectangle.One.ToString());
metaData.Values.Add("PadLeft", "0.5");
metaData.Values.Add("PadRight", "0.5");
metaData.Values.Add("PadTop", "0.5");
metaData.Values.Add("PadBottom", "0.5");
metaData.Values.Add("Rotated", "false");
return metaData;
}
public ContentMetaData CreateMetaDataFromMaterial(string materialName, Material material)
{
var contentMetaData = new ContentMetaData();
SetDefaultValues(contentMetaData, materialName);
contentMetaData.Type = ContentType.Material;
contentMetaData.Values.Add("ShaderName", material.Shader.Name);
contentMetaData.Values.Add("BlendMode", material.DiffuseMap.BlendMode.ToString());
if (material.Animation != null)
contentMetaData.Values.Add("ImageOrAnimationName", material.Animation.Name);
else if (material.SpriteSheet != null)
contentMetaData.Values.Add("ImageOrAnimationName", material.SpriteSheet.Name);
else
contentMetaData.Values.Add("ImageOrAnimationName", material.DiffuseMap.Name);
contentMetaData.Values.Add("Color", material.DefaultColor.ToString());
return contentMetaData;
}
private static void RemoveExistingEntry(ContentMetaData entry, XmlData parent)
{
foreach (var child in parent.Children)
if (child.GetAttributeValue("Name").Compare(entry.Name))
{
parent.RemoveChild(child);
break;
}
}
private static ContentMetaData CreateSoundData(string contentName)
{
var metaData = new ContentMetaData { Name = contentName, Type = ContentType.Sound };
metaData.Values.Add("Length", "1.3");
return metaData;
}
public void UploadContent(ContentMetaData metaData,
Dictionary<string, byte[]> optionalFileData = null)
{
editorContent.Upload(metaData, optionalFileData);
}
public void UploadContent(ContentMetaData metaData,
Dictionary<string, byte[]> optionalFileData = null)
{
NumberOfMessagesSent++;
}
private static ContentMetaData CreateModelMetaData(string contentName)
{
var metaData = new ContentMetaData { Name = contentName, Type = ContentType.Model };
if (contentName == "InvalidModel")
return metaData;
metaData.Values.Add("MeshNames", "Mock" + contentName);
return metaData;
}
private static ContentMetaData CreateImageMetaData(string contentName)
{
var metaData = new ContentMetaData { Name = contentName, Type = ContentType.Image };
metaData.Values.Add("PixelSize", contentName == "EarthImages" ? "428, 240" : "128, 128");
if (contentName.Contains("ParticleFire"))
metaData.Values.Add("BlendMode", "Additive");
return metaData;
}
public List<ContentMetaData> Process_GetMetaData()
{
System.Collections.Generic.List<ContentMetaData> lMeta = new System.Collections.Generic.List<ContentMetaData>();
int iValidCounter = 0;
if (Request.Form["frm_validcounter"] != "")
{
iValidCounter = System.Convert.ToInt32(Request.Form["frm_validcounter"]);
}
else
{
iValidCounter = 0;
}
for (int i = 1; i <= iValidCounter; i++)
{
ContentMetaData eMeta = new ContentMetaData();
string MetaSelect;
eMeta.TypeId = Convert.ToInt64(Request.Form["frm_meta_type_id_" + i]);
eMeta.Separator = Request.Form["MetaSeparator_" + i];
MetaSelect = Request.Form["MetaSelect_" + i];
if (!string.IsNullOrEmpty(MetaSelect))
{
eMeta.Text = Strings.Replace(Request.Form["frm_text_" + i], ", ", eMeta.Separator, 1, -1, 0);
if (eMeta.Text != null && eMeta.Text.Substring(0, 1) == eMeta.Separator)
{
eMeta.Text = eMeta.Text.Substring(eMeta.Text.Length - (eMeta.Text.Length - 1), (eMeta.Text.Length - 1));
}
}
else
{
string myMeta = "";
myMeta = Request.Form["frm_text_" + i];
myMeta = Server.HtmlDecode(myMeta);
eMeta.Text = myMeta.Replace(";", eMeta.Separator);
}
lMeta.Add(eMeta);
}
return lMeta;
}
private static void AssertPlatformFileIdInMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
if (metaData.PlatformFileId == 0)
Assert.IsFalse(IsAttributeAvailable(xmlMetaData, "PlatformFileId"));
else
Assert.AreEqual(metaData.PlatformFileId.ToString(),
xmlMetaData.GetAttributeValue("PlatformFileId"));
}
private static void UpdateContentMetaDataFile(ContentMetaData entry, XmlData parent)
{
RemoveExistingEntry(entry, parent);
parent.AddMetaDataEntry(entry);
}
private static ContentMetaData CreateMeshMetaData(string contentName)
{
var metaData = new ContentMetaData { Name = contentName, Type = ContentType.Mesh };
metaData.Values.Add("GeometryName", contentName + "Geometry");
metaData.Values.Add("MaterialName", contentName + "Material");
if (contentName.Contains("Animation"))
metaData.Values.Add("AnimationName", contentName + "Animation");
if (contentName.Contains("CustomTransform"))
metaData.Values.Add("LocalTransform", "2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 1, 3, 5, 1");
return metaData;
}
private static ContentMetaData CreateParticleSystemMetaData(string contentName)
{
var metaData = new ContentMetaData
{
Name = contentName,
Type = ContentType.ParticleSystem
};
metaData.Values.Add("EmitterNames", "EmitterAlpha, EmitterBeta");
return metaData;
}
private static void AssertLanguageInMetaData(XmlData xmlMetaData, ContentMetaData metaData)
{
if (metaData.Language == null)
Assert.IsFalse(IsAttributeAvailable(xmlMetaData, "Language"));
else
Assert.AreEqual(metaData.Language, xmlMetaData.GetAttributeValue("Language"));
}
private static ContentMetaData CreateShaderData(string contentName)
{
var metaData = new ContentMetaData { Name = contentName, Type = ContentType.Shader };
metaData.Values.Add("Flags", "UI2D, UV, Color");
return metaData;
}
