public void AreNotEqual_DifferentVersionCount()
{
var name1 = ".NETFramework";
var platform = new TargetPlatform
{
Name = name1,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = name1 },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = name1 },
}.OrderBy(x => x.Version).ToList()
};
var compared = new TargetPlatform
{
Name = name1,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("2.8"), PlatformName = name1 },
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = name1 },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = name1 },
}.OrderBy(x => x.Version).ToList()
};
Assert.NotEqual(platform, compared);
// We are expecting that `platform` should come after `compared`
// because the second version number is greater in `platform`
Assert.True(platform.CompareTo(compared) == 1);
Assert.True(compared.CompareTo(platform) == -1);
}
private static FileStreamInfo VCLibsFromResources(TargetPlatform platform, DependencyConfiguration configuration, SdkVersion sdkVersion)
{
var vclibVersion = "";
switch (sdkVersion)
{
case SdkVersion.SDK_10_0_10586_0: vclibVersion = "14.00"; break;
default:
return null;
}
var platformString = "";
switch (platform)
{
case TargetPlatform.X86: platformString = "x86"; break;
case TargetPlatform.ARM: platformString = "ARM"; break;
default:
return null;
}
var appxFilename = string.Format(CultureInfo.InvariantCulture, "Microsoft.VCLibs.{0}.{1}.{2}.appx", platformString, configuration.ToString(), vclibVersion);
var assemblyName = typeof(CPlusPlusUwpDependency).Assembly.GetName().Name;
var convertedPath = assemblyName + @".Resources.VCLibs." + platformString + "." + appxFilename;
return new FileStreamInfo()
{
AppxRelativePath = appxFilename,
Stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(convertedPath)
};
}
public void TestAreEqual()
{
const string frameworkName = ".NETFramework";
var platform = new TargetPlatform
{
Name = frameworkName,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = frameworkName },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = frameworkName },
}.OrderBy(x => x.Version).ToList()
};
var compared = new TargetPlatform
{
Name = frameworkName,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = frameworkName },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = frameworkName },
}.OrderBy(x => x.Version).ToList()
};
Assert.Equal(platform, compared);
Assert.True(platform.CompareTo(compared) == 0);
Assert.True(compared.CompareTo(platform) == 0);
}
public static string GetPlatformStaticLibraryExtension(TargetPlatform Platform)
{
if (Target.IsWinAPIPlatform(Platform))
return ".lib";
return ".a";
}
public void AreNotEqual_DifferentName()
{
var name1 = ".NETFramework";
var platform = new TargetPlatform
{
Name = name1,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = name1 },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = name1 },
}.OrderBy(x => x.Version).ToList()
};
var name2 = ".NETFramework_Not";
var compared = new TargetPlatform
{
Name = name2,
Versions = new[] {
new TargetPlatformVersion { Version = new Version("1.0"), PlatformName = name2 },
new TargetPlatformVersion { Version = new Version("5.8.3"), PlatformName = name2 },
}.OrderBy(x => x.Version).ToList()
};
Assert.NotEqual(platform, compared);
Assert.Equal(string.CompareOrdinal(name1, name2), platform.CompareTo(compared));
Assert.Equal(string.CompareOrdinal(name2, name1), compared.CompareTo(platform));
}
public TestAttributionHandler(DeviceUtil deviceUtil, IAssert assert, TargetPlatform targetPlatform)
: base(deviceUtil, assert)
{
TargetPlatform = targetPlatform;
TestActivityPackage.Assert = Assert;
TestActivityPackage.TargetPlatform = TargetPlatform;
}
/// <summary>
/// Generate a DPWSHostedService source file from a Wsdl service description.
/// </summary>
/// <param name="serviceDesc">A valid wsdl service description.</param>
public void GenerateHostedService(ServiceDescription serviceDesc, TargetPlatform platform)
{
// Well here's a nasty used in an attempt to make up a name
string hostedServiceClassName = serviceDesc.Name;
string hostedServiceNs = CodeGenUtils.GenerateDotNetNamespace(serviceDesc.TargetNamespace);
string filename = serviceDesc.Name + "HostedService.cs";
HostedServices hostedServices = new HostedServices(hostedServiceNs);
foreach (PortType portType in serviceDesc.PortTypes)
{
HostedService hostedService = new HostedService(portType.Name, hostedServiceNs, platform);
foreach (Operation operation in portType.Operations)
{
// Create action names
// Apply special naming rules if this is a notification (event) operation
string inAction = serviceDesc.TargetNamespace + "/" + operation.Name + "Request";
string outAction = serviceDesc.TargetNamespace + "/" + operation.Name + ((operation.Messages.Flow == OperationFlow.Notification) ? "" : "Response");
hostedService.AddOperation(operation, inAction, outAction);
}
foreach (Message message in serviceDesc.Messages)
{
hostedService.Messages.Add(message);
}
}
HostedServiceGenerator hostedServiceGen = new HostedServiceGenerator();
hostedServiceGen.GenerateCode(filename, hostedServices);
}
internal WinRTSolutionWriter(AssemblyDefinition assembly, TargetPlatform targetPlatform, string targetDir, string solutionFileName,
Dictionary<ModuleDefinition, string> modulesProjectsRelativePaths, Dictionary<ModuleDefinition, Guid> modulesProjectsGuids,
VisualStudioVersion visualStudioVersion, ILanguage language, IEnumerable<string> platforms)
: base(assembly, targetPlatform, targetDir, solutionFileName, modulesProjectsRelativePaths, modulesProjectsGuids, visualStudioVersion, language)
{
this.platforms = platforms;
}
/// <summary>
/// Generate a DPWSClientProxy source file from a wsdl service description.
/// </summary>
/// <param name="serviceDesc">A valid wsdl service description.</param>
public void GenerateClientProxy(ServiceDescription serviceDesc, TargetPlatform platform)
{
// Well here's a nasty used in an attempt to make up a name
string clientProxyClassName = serviceDesc.Name;
string clientProxyNs = CodeGenUtils.GenerateDotNetNamespace(serviceDesc.TargetNamespace);
string filename = serviceDesc.Name + "ClientProxy.cs";
ClientProxies clientProxies = new ClientProxies(clientProxyNs);
foreach (PortType portType in serviceDesc.PortTypes)
{
ClientProxy clientProxy = new ClientProxy(portType.Name, platform);
foreach (Operation operation in portType.Operations)
{
// Create action names
// Apply special naming rules if this is a notification (event) operation
string inAction = serviceDesc.TargetNamespace + "/" + operation.Name + "Request";
string outAction = serviceDesc.TargetNamespace + "/" + operation.Name + ((operation.Messages.Flow == OperationFlow.Notification) ? "" : "Response");
clientProxy.AddOperation(operation, inAction, outAction);
}
foreach (Message message in serviceDesc.Messages)
{
clientProxy.Messages.Add(message);
}
if (clientProxy.ServiceOperations.Count > 0)
clientProxies.Add(clientProxy);
}
ClientProxyGenerator clientProxyGen = new ClientProxyGenerator();
clientProxyGen.GenerateCode(filename, clientProxies);
}
/// <summary>
/// The to mono game platform.
/// </summary>
/// <param name="platform">
/// The platform.
/// </param>
/// <returns>
/// The <see cref="TargetPlatform"/>.
/// </returns>
/// <exception cref="NotSupportedException">
/// </exception>
public static MonoGamePlatform ToMonoGamePlatform(TargetPlatform platform)
{
switch (platform)
{
case TargetPlatform.Windows:
return MonoGamePlatform.Windows;
case TargetPlatform.Xbox360:
return MonoGamePlatform.Xbox360;
case TargetPlatform.WindowsPhone:
return MonoGamePlatform.WindowsPhone;
case TargetPlatform.iOS:
return MonoGamePlatform.iOS;
case TargetPlatform.Android:
return MonoGamePlatform.Android;
case TargetPlatform.Linux:
return MonoGamePlatform.DesktopGL;
case TargetPlatform.MacOSX:
return MonoGamePlatform.MacOSX;
case TargetPlatform.WindowsStoreApp:
return MonoGamePlatform.WindowsStoreApp;
case TargetPlatform.NativeClient:
return MonoGamePlatform.NativeClient;
case TargetPlatform.Ouya:
return MonoGamePlatform.Android;
case TargetPlatform.WindowsPhone8:
return MonoGamePlatform.WindowsPhone8;
case TargetPlatform.RaspberryPi:
return MonoGamePlatform.RaspberryPi;
default:
throw new NotSupportedException();
}
}
internal QueryableModule(ModuleDefinition moduleDefinition, QueryableAssembly assembly)
{
_assembly = assembly;
_name = Utility.ToString(_getName(moduleDefinition));
_fullPath = Utility.ToString(moduleDefinition.FullyQualifiedName);
_moduleType = _getModuleType(moduleDefinition);
_targetRuntimeVersion = Utility.ToString(_getTargetRuntimeVersion(moduleDefinition));
_targetPlatform = _getTargetPlatform(moduleDefinition);
_hasNativeCode = _getHasNativeCode(moduleDefinition);
_isStrongNameSigned = _getIsStrongNameSigned(moduleDefinition);
if (moduleDefinition.Assembly != null && moduleDefinition == moduleDefinition.Assembly.MainModule)
{
_assembly.MainModule = this;
}
foreach (Resource resource in moduleDefinition.Resources)
{
_resources.Add(new QueryableResource(resource, this));
}
foreach (TypeDefinition typeDefinition in moduleDefinition.Types)
{
QueryableType type = new QueryableType(typeDefinition, this, null);
_addTypesAndMethods(type);
}
}
internal SolutionWriter(AssemblyDefinition assembly, TargetPlatform targetPlatform, string targetDir, string solutionFileName,
Dictionary<ModuleDefinition, string> modulesProjectsRelativePaths, Dictionary<ModuleDefinition, Guid> modulesProjectsGuids,
VisualStudioVersion visualStudioVersion, ILanguage language)
{
this.assembly = assembly;
this.targetPlatform = targetPlatform;
this.targetDir = targetDir;
this.solutionFileName = solutionFileName;
this.modulesProjectsRelativePaths = modulesProjectsRelativePaths;
this.modulesProjectsGuids = modulesProjectsGuids;
if (language is ICSharp)
{
this.languageGuid = new Guid(WinRTProjectBuilder.CSharpGUID);
}
else if (language is IVisualBasic)
{
this.languageGuid = new Guid(WinRTProjectBuilder.VisualBasicGUID);
}
else
{
throw new NotSupportedException();
}
this.visualStudioVersion = visualStudioVersion;
}
public RuntimeEnvironment GetRuntimeEnvironment(
IUnitTestElement element,
RuntimeEnvironment projectRuntimeEnvironment,
TargetPlatform targetPlatform,
IUnitTestLaunch launch)
{
return new RuntimeEnvironment { PlatformType = PlatformType.x86, PlatformVersion = PlatformVersion.v4_0 };
}
public ReadOnlyCollection<FileStreamInfo> GetDependencies(TargetPlatform platform, DependencyConfiguration configuration, SdkVersion sdkVersion)
{
var dependencies = new List<FileStreamInfo>();
var dependency = VCLibsFromResources(platform, configuration, sdkVersion);
if (null != dependency)
{
dependencies.Add(dependency);
}
return new ReadOnlyCollection<FileStreamInfo>(dependencies);
}
/// <summary> Returns true if specified platform`s native API is Cocoa</summary>
public static bool IsCocoaPlatform(TargetPlatform Platform)
{
switch (Platform)
{
case TargetPlatform.iOS: return true;
case TargetPlatform.OSX: return true;
}
return false;
}
public static CompiledEffectContent Compile(EffectContent output, string tempOutputPath, TargetPlatform platform, bool isDebug, string defines)
{
var processor = new EffectProcessor();
var context = new DummyContentProcessorContext(TargetPlatformCast.ToMonoGamePlatform(platform));
context.ActualOutputFilename = tempOutputPath;
processor.DebugMode = isDebug
? EffectProcessorDebugMode.Debug
: EffectProcessorDebugMode.Optimize;
processor.Defines = defines + ";" + GetPlatformDefineForEffect(platform) + ";" +
(isDebug ? "CONFIGURATION_DEBUG" : "CONFIGURATION_RELEASE");
return processor.Process(output, context);
}
internal string ParentDirectory(TargetPlatform runtime)
{
if (runtime == TargetPlatform.CLR_4)
{
return string.Format("v4.0_{0}__{1}", Version.ToString(), PublicKeyTokenAsString());
}
else if (runtime == TargetPlatform.CLR_2_3)
{
return string.Format("{0}__{1}", Version.ToString(), PublicKeyTokenAsString());
}
return string.Empty;
}
internal static string GetAssemblyPublicKey(TargetPlatform targetPlatform) {
string str = "PublicKeyToken=";
TargetPlatform targetPlatform1 = targetPlatform;
if (targetPlatform1 == TargetPlatform.Windows) {
str = string.Concat(str, AssemblyHelper.mWindowsPublicKeyTokens);
} else if (targetPlatform1 == TargetPlatform.Xbox360) {
str = string.Concat(str, AssemblyHelper.mXboxPublicKeyTokens);
} else {
throw new ArgumentException("targetPlatform");
}
return str;
}
internal static string GetRuntimeReader(Type type, TargetPlatform targetPlatform)
{
// Type full name
string typeFullName = type.FullName;
// Assembly name tokenized
string fullAssemblyName = type.Assembly.FullName;
string[] assemblyTokens = fullAssemblyName.Split(assemblySplitter, StringSplitOptions.None);
return
typeFullName + ", " + assemblyTokens[0] + ", " + assemblyTokens[1] + ", " +
assemblyTokens[2] + ", " + GetAssemblyPublicKey(targetPlatform);
}
/// <summary>
/// Returns a path string normalized to the current platform standard.
/// </summary>
/// <param name="path">Path to normalize</param>
/// <param name="targetPlatform">The platform to normalize for</param>
/// <returns>The normalized path</returns>
public static string NormalizeOS(string path, TargetPlatform targetPlatform)
{
switch (targetPlatform)
{
case TargetPlatform.Windows:
case TargetPlatform.WindowsPhone8:
case TargetPlatform.WindowsStoreApp:
return NormalizeWindows(path);
default:
return Normalize(path);
}
}
private void BuildEffect(string effectFile, TargetPlatform targetPlatform, string defines = null)
{
var importerContext = new ImporterContext();
var importer = new EffectImporter();
var input = importer.Import(effectFile, importerContext);
Assert.NotNull(input);
var processorContext = new TestProcessorContext(targetPlatform, Path.ChangeExtension(effectFile, ".xnb"));
var processor = new EffectProcessor { Defines = defines };
var output = processor.Process(input, processorContext);
Assert.NotNull(output);
// TODO: Should we test the writer?
}
public static ProcessedContent LoadContent(string file, ContentBuildLogger logger, ContentTypes desiredType, bool process = true, TargetPlatform plat = TargetPlatform.Windows)
{
Content content = new SGDEImport().Import(file, new FakeContentImporterContext(Path.GetFullPath(file), logger));
if (content.Type != desiredType)
{
logger.LogImportantMessage(Resources.DATA_UTIL_LOAD_BADTYPE, content.Type, desiredType);
return null;
}
if (process)
{
FakeContentProcessorContext context = new FakeContentProcessorContext(logger);
context.TPalt = plat;
return new SGDEProcessor().Process(content, context);
}
return new TempProcessedContent(); //Just to prevent a null outptu
}
internal static string GetRuntimeReader(Type type, TargetPlatform targetPlatform) {
string fullName = type.FullName;
string str = type.Assembly.FullName;
string[] strArrays = str.Split(AssemblyHelper.mAssemblySplitter, StringSplitOptions.None);
string[] assemblyPublicKey = new string[9];
assemblyPublicKey[0] = fullName;
assemblyPublicKey[1] = ", ";
assemblyPublicKey[2] = strArrays[0];
assemblyPublicKey[3] = ", ";
assemblyPublicKey[4] = strArrays[1];
assemblyPublicKey[5] = ", ";
assemblyPublicKey[6] = strArrays[2];
assemblyPublicKey[7] = ", ";
assemblyPublicKey[8] = AssemblyHelper.GetAssemblyPublicKey(targetPlatform);
return string.Concat(assemblyPublicKey);
}
public static string GetPlatformCodeName(TargetPlatform Platform)
{
switch(Platform)
{
case TargetPlatform.XBoxOne: return "XBox";
case TargetPlatform.PlayStation4: return "PS4";
case TargetPlatform.Windows: return "Win64";
case TargetPlatform.OSX: return "OSX";
case TargetPlatform.Linux: return "Linux";
case TargetPlatform.WindowsPhone: return "WP";
case TargetPlatform.iOS: return "iOS";
case TargetPlatform.Android: return "Android";
case TargetPlatform.HTML5: return "js";
}
throw new ArgumentException();
}
internal static string GetAssemblyPublicKey(TargetPlatform targetPlatform)
{
string publicKey = "PublicKeyToken=";
switch (targetPlatform)
{
case TargetPlatform.Windows:
publicKey += windowsPublicKeyTokens;
break;
case TargetPlatform.Xbox360:
publicKey += xboxPublicKeyTokens;
break;
default:
throw new ArgumentException("targetPlatform");
}
return publicKey;
}
internal string[] SupportedVersions(TargetPlatform runtime)
{
switch (runtime)
{
case TargetPlatform.CLR_2_3:
case TargetPlatform.CLR_4:
return SystemInformation.CLR_GAC_VERSIONS;
case TargetPlatform.WindowsPhone:
return SystemInformation.WINDOWS_PHONE_VERSIONS;
case TargetPlatform.WindowsCE:
return SystemInformation.WINDOWS_CE_VERSIONS;
case TargetPlatform.Silverlight:
return SystemInformation.SILVERLIGHT_VERSIONS;
default:
return new string[0];
}
}
internal static string GetRuntimeReader(Type type, TargetPlatform targetPlatform)
{
// Type full name
string typeFullName = type.FullName;
// Assembly name tokenized
string fullAssemblyName = type.Assembly.FullName;
string[] assemblyTokens = fullAssemblyName.Split(assemblySplitter, StringSplitOptions.None);
#if DEBUG
return
//typeFullName + ", " + assemblyTokens[0] + ", " + assemblyTokens[1] + ", " +
//assemblyTokens[2] + ", " + GetAssemblyPublicKey(targetPlatform);
typeFullName + ", " + "PloobsEngineDebug" + ", " + assemblyTokens[1] + ", " +
assemblyTokens[2] + ", " + GetAssemblyPublicKey(targetPlatform);
#else
//typeFullName + ", " + "PloobsEngine" + ", " + assemblyTokens[1] + ", " +
// assemblyTokens[2] + ", " + GetAssemblyPublicKey(targetPlatform);
typeFullName + ", " + "PloobsEngineDebug" + ", " + assemblyTokens[1] + ", " +
assemblyTokens[2] + ", " + GetAssemblyPublicKey(targetPlatform);
#endif
}
public ContentBuilder(string contentProjectFile, GraphicsProfile graphicsProfile = GraphicsProfile.HiDef, TargetPlatform targetPlatform = TargetPlatform.Windows, bool compressContent = true, LoggerVerbosity loggerVerbosity = LoggerVerbosity.Normal, bool rebuildContent = false)
{
FileInfo fileInfo = new FileInfo(contentProjectFile);
_contentProjectFile = Path.GetFullPath(fileInfo.FullName);
if (fileInfo.Extension != ".contentproj")
throw new NotSupportedException(string.Format("The file '{0}' is not a XNA content project.", _contentProjectFile));
if (!fileInfo.Exists)
throw new FileNotFoundException(String.Format("The file '{0}' does not exist.", _contentProjectFile, _contentProjectFile));
GraphicsProfile = graphicsProfile;
TargetPlatform = targetPlatform;
CompressContent = compressContent;
LoggerVerbosity = loggerVerbosity;
RebuildContent = rebuildContent;
if (!_globalProperties.ContainsKey("XnaProfile"))
_globalProperties.Add("XnaProfile", GraphicsProfile.ToString());
if (!_globalProperties.ContainsKey("XNAContentPipelineTargetPlatform"))
_globalProperties.Add("XNAContentPipelineTargetPlatform", TargetPlatform.ToString());
if (!_globalProperties.ContainsKey("XnaCompressContent"))
_globalProperties.Add("XnaCompressContent", CompressContent.ToString());
if (!_globalProperties.ContainsKey("OutputhPath"))
_globalProperties.Add("OutputPath", OutputPath);
if (!_globalProperties.ContainsKey("ContentRootDirectory"))
_globalProperties.Add("ContentRootDirectory", ContentRootDirectory);
}
private static string GetPlatformDefineForEffect(TargetPlatform platform)
{
switch (platform)
{
case TargetPlatform.Windows:
return "PLATFORM_WINDOWS";
case TargetPlatform.Xbox360:
return "PLATFORM_XBOX360";
case TargetPlatform.WindowsPhone:
return "PLATFORM_WINDOWSPHONE";
case TargetPlatform.iOS:
return "PLATFORM_IOS";
case TargetPlatform.Android:
return "PLATFORM_ANDROID";
case TargetPlatform.Linux:
return "PLATFORM_LINUX";
case TargetPlatform.MacOSX:
return "PLATFORM_MACOSX";
case TargetPlatform.WindowsStoreApp:
return "PLATFORM_WINDOWSSTOREAPP";
case TargetPlatform.NativeClient:
return "PLATFORM_NATIVECLIENT";
case TargetPlatform.Ouya:
return "PLATFORM_OUYA";
case TargetPlatform.PlayStationMobile:
return "PLATFORM_PSMOBILE";
case TargetPlatform.WindowsPhone8:
return "PLATFORM_WINDOWSPHONE8";
case TargetPlatform.RaspberryPi:
return "PLATFORM_RASPBERRYPI";
case TargetPlatform.Web:
return "PLATFORM_WEB";
default:
return String.Empty;
}
}
/// <summary>
/// Tells the content pipeline what worker type
/// will be used to load the sky data.
/// </summary>
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return("EGGEngine.Rendering.SkyReader, " +
"EGGEngine, Version=1.0.0.0, Culture=neutral");
}
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return("GeonBit.Extend.Animation.Content.ClipReader, " +
typeof(GeonBit.Extend.Animation.Content.ClipReader).Assembly.FullName);
}
/// <summary>
/// Gets the assembly qualified name of the runtime target type.
/// </summary>
/// <param name="targetPlatform">The target platform.</param>
/// <returns>The qualified name.</returns>
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return(typeof(TriangleShape).AssemblyQualifiedName);
}
public TargetPlatform GetTargetPlatform(string assemblyFilePath, ModuleDefinition moduleDef)
{
TargetPlatform targetPlatform = this.DefaultTargetPlatform;
if (string.IsNullOrEmpty(assemblyFilePath))
{
return(targetPlatform);
}
if (this.assemblyFrameworkResolverCache.AssemblyPathToTargetPlatform.ContainsKey(assemblyFilePath))
{
return(this.assemblyFrameworkResolverCache.AssemblyPathToTargetPlatform[assemblyFilePath]);
}
else
{
Task <TargetPlatform> targetPlatformFromDepsJson = null;
string moduleLocation = moduleDef.FullyQualifiedName ?? moduleDef.FilePath;
string depsJsonLocation = Directory.GetFiles(Path.GetDirectoryName(moduleLocation), "*.deps.json").FirstOrDefault();
if (File.Exists(depsJsonLocation))
{
targetPlatformFromDepsJson = Task.Factory.StartNew(() =>
{
return(this.GetPlatformTargetFromDepsJson(moduleLocation));
});
}
///*Telerik Authorship*/
if (moduleDef.Assembly != null)
{
targetPlatform = this.GetTargetPlatform(moduleDef);
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
return(targetPlatform);
}
}
AssemblyNameReference msCorlib = moduleDef.AssemblyReferences.FirstOrDefault(a => a.Name == "mscorlib");
if (msCorlib == null)
{
AssemblyNameReference systemRuntimeReference = moduleDef.AssemblyReferences.FirstOrDefault(x => x.Name == "System.Runtime");
targetPlatform = this.GetTargetPlatform(systemRuntimeReference);
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
this.assemblyFrameworkResolverCache.AddAssemblySystemRuntimeReference(assemblyFilePath, systemRuntimeReference);
return(targetPlatform);
}
// the next line is only to keep the old functionality
msCorlib = moduleDef.Assembly.Name;
}
if (moduleDef.Assembly != null && moduleDef.Assembly.Name.IsWindowsRuntime || msCorlib.IsFakeMscorlibReference())
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, TargetPlatform.WinRT);
return(TargetPlatform.WinRT);
}
/*AssemblyName assemblyName = new AssemblyName(msCorlib.Name,
* msCorlib.FullName,
* msCorlib.Version,
* msCorlib.PublicKeyToken,
* Path.GetDirectoryName(assemliyFilePath)) { TargetArchitecture = moduleDef.GetModuleArchitecture() };
* IEnumerable<string> foundPaths = GetAssemblyPaths(assemblyName);
*
* return GetTargetPlatform(foundPaths.FirstOrDefault());*/
/*Telerik Authorship*/
if (targetPlatformFromDepsJson != null)
{
targetPlatformFromDepsJson.Wait();
targetPlatform = targetPlatformFromDepsJson.Result;
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
return(targetPlatform);
}
}
/*Telerik Authorship*/
TargetArchitecture moduleArchitecture = moduleDef.GetModuleArchitecture();
/*Telerik Authorship*/
foreach (KeyValuePair <AssemblyName, TargetPlatform> pair in Mscorlibs)
{
if (AssemblyNameComparer.AreVersionEquals(pair.Key.Version, msCorlib.Version) &&
AssemblyNameComparer.ArePublicKeyEquals(pair.Key.PublicKeyToken, msCorlib.PublicKeyToken) &&
moduleArchitecture.CanReference(pair.Key.TargetArchitecture))
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, pair.Value);
return(pair.Value);
}
}
/*Telerik Authorship*/
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, this.DefaultTargetPlatform);
return(this.DefaultTargetPlatform);
}
}
public async Task CompileAsync(IAssetFsFile assetFile, IAssetDependencies assetDependencies, TargetPlatform platform, IWritableSerializedAsset output)
{
var code = string.Empty;
using (var reader = new StreamReader(await assetFile.GetContentStream().ConfigureAwait(false)))
{
code = await reader.ReadToEndAsync().ConfigureAwait(false);
}
if (!code.Contains("// uber"))
{
// Do nothing with this file.
return;
}
var dirName = Path.GetDirectoryName(assetFile.Name.Replace(".", "/"));
code = await ResolveIncludes(assetDependencies, dirName.Replace(Path.DirectorySeparatorChar, '.'), code).ConfigureAwait(false);
var allPassed = true;
var effectCodes = new Dictionary <string, Tuple <string, byte[], byte[]> >();
foreach (var rawLine in code.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries))
{
var line = rawLine.Trim();
if (line.StartsWith("#line"))
{
continue;
}
if (!line.StartsWith("// uber "))
{
break;
}
var components = line.Substring("// uber ".Length).Split(':');
var name = components[0].Trim();
var defines = components[1].Trim();
Console.WriteLine();
Console.Write("Compiling uber shader variant " + name + "... ");
var effectOutput = new EffectContent();
effectOutput.EffectCode = this.GetEffectPrefixCode() + code;
string tempPath = null, tempOutputPath = null;
try
{
tempPath = Path.GetTempFileName();
tempOutputPath = Path.GetTempFileName();
using (var writer = new StreamWriter(tempPath))
{
writer.Write(effectOutput.EffectCode);
}
effectOutput.Identity = new ContentIdentity(tempPath);
var debugContent = EffectCompilerHelper.Compile(
effectOutput,
tempOutputPath,
platform,
true,
defines);
var releaseContent = EffectCompilerHelper.Compile(
effectOutput,
tempOutputPath,
platform,
false,
defines);
effectCodes[name] = new Tuple <string, byte[], byte[]>(defines, debugContent.GetEffectCode(), releaseContent.GetEffectCode());
Console.Write("done.");
}
catch (InvalidContentException ex)
{
Console.WriteLine("failed.");
Console.Write(ex.Message.Trim());
allPassed = false;
}
finally
{
if (tempOutputPath != null)
{
File.Delete(tempOutputPath);
}
if (tempOutputPath != null)
{
File.Delete(tempPath);
}
}
}
Console.WriteLine();
Console.Write("Finalizing uber shader compilation... ");
if (!allPassed)
{
throw new Exception("One or more uber shader variants failed to compile (see above!)");
}
using (var memory = new MemoryStream())
{
using (var writer = new BinaryWriter(memory))
{
writer.Write((uint)2);
writer.Write((uint)effectCodes.Count);
foreach (var kv in effectCodes)
{
writer.Write(kv.Key);
writer.Write(kv.Value.Item1);
writer.Write(kv.Value.Item2.Length);
writer.Write(kv.Value.Item2);
writer.Write(kv.Value.Item3.Length);
writer.Write(kv.Value.Item3);
}
var len = memory.Position;
var data = new byte[len];
memory.Seek(0, SeekOrigin.Begin);
memory.Read(data, 0, data.Length);
output.SetLoader <IAssetLoader <UberEffectAsset> >();
output.SetPlatform(platform);
output.SetByteArray("Data", data);
}
}
}
private void OnUpload(TargetPlatform targetPlatform)
{
OVRPlatformTool.log = string.Empty;
SetDirtyOnGUIChange();
ExecuteCommand(targetPlatform);
}
/// <summary> /// Returns true if this profile supports audio processing for this platform. /// </summary> public abstract bool Supports(TargetPlatform platform);
public UnityRuntimeEnvironment(TargetPlatform targetPlatform)
{
TargetPlatform = targetPlatform;
}
/// <summary>
/// Gets the dependency packages binaries folder.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="platform">The target platform.</param>
/// <returns>The absolute path to the deps folder for the given platform and architecture configuration.</returns>
public static string GetBinariesFolder(BuildOptions options, TargetPlatform platform)
{
return(Path.Combine(options.PlatformsFolder, platform.ToString(), "Binaries"));
}
/// <summary>
/// Gets the dependency third-party packages binaries folder.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="platform">The target platform.</param>
/// <param name="architecture">The target architecture.</param>
/// <returns>The absolute path to the deps folder for the given platform and architecture configuration.</returns>
public static string GetThirdPartyFolder(BuildOptions options, TargetPlatform platform, TargetArchitecture architecture)
{
return(Path.Combine(options.PlatformsFolder, platform.ToString(), "Binaries", "ThirdParty", architecture.ToString()));
}
/// <summary>
/// Runs the cmake tool.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="platform">The output platform.</param>
/// <param name="architecture">The output architecture.</param>
/// <param name="customArgs">The custom arguments for the CMake.</param>
/// <param name="envVars">Custom environment variables to pass to the child process.</param>
public static void RunCmake(string path, TargetPlatform platform, TargetArchitecture architecture, string customArgs = null, Dictionary <string, string> envVars = null)
{
string cmdLine;
switch (platform)
{
case TargetPlatform.Windows:
case TargetPlatform.XboxOne:
case TargetPlatform.XboxScarlett:
case TargetPlatform.UWP:
{
string arch;
switch (architecture)
{
case TargetArchitecture.x86:
arch = string.Empty;
break;
case TargetArchitecture.x64:
arch = " Win64";
break;
case TargetArchitecture.ARM:
arch = " ARM";
break;
case TargetArchitecture.ARM64:
arch = " ARM64";
break;
default: throw new InvalidArchitectureException(architecture);
}
cmdLine = string.Format("CMakeLists.txt -G \"Visual Studio 14 2015{0}\"", arch);
break;
}
case TargetPlatform.Linux:
case TargetPlatform.PS4:
{
cmdLine = "CMakeLists.txt";
break;
}
case TargetPlatform.Switch:
{
cmdLine = string.Format("-DCMAKE_TOOLCHAIN_FILE=\"{1}\\Source\\Platforms\\Switch\\Data\\Switch.cmake\" -G \"NMake Makefiles\" -DCMAKE_MAKE_PROGRAM=\"{0}..\\..\\VC\\bin\\nmake.exe\"", Environment.GetEnvironmentVariable("VS140COMNTOOLS"), Globals.EngineRoot);
break;
}
case TargetPlatform.Android:
{
var ndk = AndroidNdk.Instance.RootPath;
var abi = AndroidToolchain.GetAbiName(architecture);
var hostName = AndroidSdk.GetHostName();
cmdLine = string.Format("-DCMAKE_TOOLCHAIN_FILE=\"{0}/build/cmake/android.toolchain.cmake\" -DANDROID_NDK=\"{0}\" -DANDROID_STL=c++_shared -DANDROID_ABI={1} -DANDROID_PLATFORM=android-{2} -G \"MinGW Makefiles\" -DCMAKE_MAKE_PROGRAM=\"{0}/prebuilt/{3}/bin/make.exe\"", ndk, abi, Configuration.AndroidPlatformApi, hostName);
break;
}
default: throw new InvalidPlatformException(platform);
}
if (customArgs != null)
{
cmdLine += " " + customArgs;
}
Utilities.Run("cmake", cmdLine, null, path, Utilities.RunOptions.None, envVars);
}
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
//TiledMapProcessor.logger.LogMessage( "--- GetRuntimeReader: {0}", typeof( Nez.Tiled.TiledMapReader ).AssemblyQualifiedName );
return(typeof(Nez.Tiled.TiledMapReader).AssemblyQualifiedName);
}
/// <summary>
/// Gets the assembly qualified name of the runtime loader for this type.
/// </summary>
/// <param name="targetPlatform">Name of the platform.</param>
/// <returns>Name of the runtime loader.</returns>
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return(typeof(Path3FReader).AssemblyQualifiedName);
}
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return("GeonBit.Extend.Animation.Clip, " +
typeof(GeonBit.Extend.Animation.Clip).Assembly.FullName);
}
/// <summary>
/// Tells the content pipeline what CLR type the sky
/// data will be loaded into at runtime.
/// </summary>
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return("EGGEngine.Rendering.Sky, " +
"TRA_Game, Version=1.0.0.0, Culture=neutral");
}
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
// TODO: change this to the name of your ContentTypeReader
// class which will be used to load this data.
return(typeof(WeaponContentReader).AssemblyQualifiedName);
}
///////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return(typeof(SkinXmlDocument).AssemblyQualifiedName);
}
private static bool genUploadCommand(TargetPlatform targetPlatform, out string command)
{
bool success = true;
command = "";
switch (targetPlatform)
{
case TargetPlatform.Rift:
command = "upload-rift-build";
break;
case TargetPlatform.OculusGoGearVR:
command = "upload-mobile-build";
break;
case TargetPlatform.Quest:
command = "upload-quest-build";
break;
default:
OVRPlatformTool.log += "ERROR: Invalid target platform selected";
success = false;
break;
}
// Add App ID
ValidateTextField(AppIDFieldValidator, OVRPlatformToolSettings.AppID, "App ID", ref success);
command += " --app-id \"" + OVRPlatformToolSettings.AppID + "\"";
// Add App Token
ValidateTextField(GenericFieldValidator, OVRPlatformToolSettings.AppToken, "App Token", ref success);
command += " --app-secret \"" + OVRPlatformToolSettings.AppToken + "\"";
// Add Platform specific fields
if (targetPlatform == TargetPlatform.Rift)
{
// Add Rift Build Directory
ValidateTextField(DirectoryValidator, OVRPlatformToolSettings.RiftBuildDirectory, "Rift Build Directory", ref success);
command += " --build-dir \"" + OVRPlatformToolSettings.RiftBuildDirectory + "\"";
// Add Rift Launch File
ValidateTextField(FileValidator, OVRPlatformToolSettings.RiftLaunchFile, "Rift Launch File Path", ref success);
command += " --launch-file \"" + OVRPlatformToolSettings.RiftLaunchFile + "\"";
// Add Rift Build Version
ValidateTextField(GenericFieldValidator, OVRPlatformToolSettings.RiftBuildVersion, "Build Version", ref success);
command += " --version \"" + OVRPlatformToolSettings.RiftBuildVersion + "\"";
// Add Rift Launch Parameters
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.RiftLaunchParams))
{
ValidateTextField(LaunchParameterValidator, OVRPlatformToolSettings.RiftLaunchParams, "Launch Parameters", ref success);
command += " --launch_params \"" + OVRPlatformToolSettings.RiftLaunchParams + "\"";
}
// Add 2D Launch File
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.Rift2DLaunchFile))
{
ValidateTextField(FileValidator, OVRPlatformToolSettings.Rift2DLaunchFile, "2D Launch File", ref success);
command += " --launch_file_2d \"" + OVRPlatformToolSettings.Rift2DLaunchFile + "\"";
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.Rift2DLaunchParams))
{
ValidateTextField(LaunchParameterValidator, OVRPlatformToolSettings.Rift2DLaunchParams, "2D Launch Parameters", ref success);
command += " --launch_params_2d \"" + OVRPlatformToolSettings.Rift2DLaunchParams + "\"";
}
}
// Add Firewall Exception
if (OVRPlatformToolSettings.RiftFirewallException)
{
command += " --firewall_exceptions true";
}
// Add Redistributable Packages
List <string> redistCommandIds = new List <string>();
for (int i = 0; i < OVRPlatformToolSettings.RiftRedistPackages.Count; i++)
{
if (OVRPlatformToolSettings.RiftRedistPackages[i].include)
{
redistCommandIds.Add(OVRPlatformToolSettings.RiftRedistPackages[i].id);
}
}
if (redistCommandIds.Count > 0)
{
command += " --redistributables \"" + string.Join(",", redistCommandIds.ToArray()) + "\"";
}
// Add Gamepad Emulation
if (OVRPlatformToolSettings.RiftGamepadEmulation > OVRPlatformToolSettings.GamepadType.OFF &&
OVRPlatformToolSettings.RiftGamepadEmulation <= OVRPlatformToolSettings.GamepadType.LEFT_D_PAD)
{
command += " --gamepad-emulation ";
switch (OVRPlatformToolSettings.RiftGamepadEmulation)
{
case OVRPlatformToolSettings.GamepadType.TWINSTICK: command += "TWINSTICK"; break;
case OVRPlatformToolSettings.GamepadType.RIGHT_D_PAD: command += "RIGHT_D_PAD"; break;
case OVRPlatformToolSettings.GamepadType.LEFT_D_PAD: command += "LEFT_D_PAD"; break;
default: command += "OFF"; break;
}
}
// Add Rift Language Pack Directory
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.LanguagePackDirectory))
{
ValidateTextField(DirectoryValidator, OVRPlatformToolSettings.LanguagePackDirectory, "Language Pack Directory", ref success);
command += " --language_packs_dir \"" + OVRPlatformToolSettings.LanguagePackDirectory + "\"";
}
}
else
{
// Add APK Build Path
ValidateTextField(FileValidator, OVRPlatformToolSettings.ApkBuildPath, "APK Build Path", ref success);
command += " --apk \"" + OVRPlatformToolSettings.ApkBuildPath + "\"";
// Add OBB File Path
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.ObbFilePath))
{
ValidateTextField(FileValidator, OVRPlatformToolSettings.ObbFilePath, "OBB File Path", ref success);
command += " --obb \"" + OVRPlatformToolSettings.ObbFilePath + "\"";
}
if (OVRPlatformToolSettings.TargetPlatform == TargetPlatform.OculusGoGearVR)
{
// Go and Gear VR specific commands
}
else if (OVRPlatformToolSettings.TargetPlatform == TargetPlatform.Quest)
{
// Quest specific commands
}
}
// Add Assets Directory
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.AssetsDirectory))
{
ValidateTextField(DirectoryValidator, OVRPlatformToolSettings.AssetsDirectory, "Assets Directory", ref success);
command += " --assets-dir \"" + OVRPlatformToolSettings.AssetsDirectory + "\"";
// Add Asset Configurations
if (OVRPlatformToolSettings.AssetConfigs.Count > 0)
{
List <string> assetConfigs = new List <string>();
for (int i = 0; i < OVRPlatformToolSettings.AssetConfigs.Count; i++)
{
List <string> configParameters = new List <string>();
AssetConfig config = OVRPlatformToolSettings.AssetConfigs[i];
if (config.required)
{
configParameters.Add("\"required\": true");
}
if (config.type > AssetConfig.AssetType.DEFAULT)
{
string typeCommand = "\"type\": ";
switch (config.type)
{
case AssetConfig.AssetType.LANGUAGE_PACK:
configParameters.Add(typeCommand + "LANGUAGE_PACK");
break;
case AssetConfig.AssetType.STORE:
configParameters.Add(typeCommand + "STORE");
break;
default:
configParameters.Add(typeCommand + "DEFAULT");
break;
}
}
if (!string.IsNullOrEmpty(config.sku))
{
configParameters.Add("\"sku\": " + config.sku);
}
if (configParameters.Count > 0)
{
string configString = "\"" + config.name + "\": {" + string.Join(",", configParameters.ToArray()) + "}";
assetConfigs.Add(configString);
}
}
if (assetConfigs.Count > 0)
{
command += " --asset_files_config='{" + string.Join(",", assetConfigs.ToArray()) + "}'";
}
}
}
// Add Release Channel
ValidateTextField(GenericFieldValidator, OVRPlatformToolSettings.ReleaseChannel, "Release Channel", ref success);
command += " --channel \"" + OVRPlatformToolSettings.ReleaseChannel + "\"";
// Add Notes
if (!string.IsNullOrEmpty(OVRPlatformToolSettings.ReleaseNote))
{
string sanatizedReleaseNote = OVRPlatformToolSettings.ReleaseNote;
sanatizedReleaseNote = sanatizedReleaseNote.Replace("\"", "\"\"");
command += " --notes \"" + sanatizedReleaseNote + "\"";
}
return(success);
}
/// <summary>
/// Gets the assembly qualified name of the runtime target type.
/// </summary>
/// <param name="targetPlatform">The target platform.</param>
/// <returns>The qualified name.</returns>
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return(typeof(BlendGroup).AssemblyQualifiedName);
}
public static ParticleSystemCompiledShaderData BuildGpuLogicPixelShader(IEnumerable <ParticleSystemLogicStep> steps, LogicType logicType, bool useUserValues, bool useColours, bool storeLifeData, TargetPlatform targetPlatform, bool useUserDataPositionBuffer)
{
if (steps == null)
{
throw new ArgumentNullException();
}
StringBuilder output = new StringBuilder();
Random random = new Random();
foreach (ParticleSystemLogicStep step in steps)
{
BuildStep(step, output, 1, random);
}
string psCode = GpuParticleShaderBuilder.BasePixelShader.Replace(GpuParticleShaderBuilder.replaceMarker, output.ToString()).Replace("_#", "#");
//build the shader header and main method.
string headerPS = "";
string methodHeaderPS = "";
string methodPS = "void PS(float4 texRandIndex : TEXCOORD0";
if (logicType != LogicType.Frame)
{
methodPS += ", float4 lifeIndex : TEXCOORD1";
}
else
{
methodHeaderPS += "float4 lifeIndex = 0;";
}
if (logicType == LogicType.Once)
{
methodPS += ", float4 defaultPosition : TEXCOORD2";
methodPS += ", float4 defaultVelocity : TEXCOORD3";
methodPS += ", float4 defaultColour : TEXCOORD4";
methodPS += ", float4 defaultUserData : TEXCOORD5";
}
else
{
methodHeaderPS += "float4 defaultPosition = 0, defaultVelocity = 0;";
methodHeaderPS += "float4 defaultColour = 1, defaultUserData = 0;";
}
int colIndex = 2;
methodPS += ", out float4 posOut : COLOR0, out float4 velOut : COLOR1";
if (useColours)
{
methodPS += string.Format(", out float4 colOut : COLOR{0}", colIndex++);
}
else
{
methodHeaderPS += "float4 colOut = 1;";
}
if (useUserValues)
{
methodPS += string.Format(", out float4 userOut : COLOR{0}", colIndex++);
}
else
{
methodHeaderPS += "float4 userOut = 0;";
}
methodPS += ")\n{\n\t" + methodHeaderPS;
methodPS += "\n\t" + @"PS_Method(texRandIndex,
lifeIndex, defaultPosition, defaultVelocity, defaultColour, defaultUserData,
posOut, velOut, colOut, userOut);" ;
methodPS += "\n}";
int colourIndex = -1, userIndex = -1, lifeIndex = -1;
if (logicType != LogicType.Once)
{
int samplerIndex = 3;
headerPS = Environment.NewLine + "#define TEXTURE_PARTICLE_METHOD" + Environment.NewLine;
if (useColours)
{
colourIndex = samplerIndex;
headerPS += Environment.NewLine + "#define USER_COLOUR_TEX" + Environment.NewLine;
headerPS += Environment.NewLine + string.Format(@"sampler2D ColourSampler : register(s{0});", samplerIndex++) + Environment.NewLine;
}
if (useUserValues)
{
userIndex = samplerIndex;
headerPS += Environment.NewLine + "#define USER_USER_TEX" + Environment.NewLine;
headerPS += Environment.NewLine + string.Format(@"sampler2D UserSampler : register(s{0});", samplerIndex++) + Environment.NewLine;
}
if (storeLifeData && logicType == LogicType.Frame)
{
lifeIndex = samplerIndex;
headerPS += Environment.NewLine + "#define USER_LIFE_TEX" + Environment.NewLine;
headerPS += Environment.NewLine + string.Format(@"sampler2D LifeSampler : register(s{0});", samplerIndex++) + Environment.NewLine;
}
if (logicType == LogicType.Frame || logicType == LogicType.FrameMove)
{
headerPS += Environment.NewLine + "#define ADD_VELOCITY" + Environment.NewLine;
}
}
if ((logicType == LogicType.OnceClone || logicType == LogicType.Once) &&
useUserDataPositionBuffer)
{
headerPS += Environment.NewLine + "#define WRITE_POS_TO_USER" + Environment.NewLine;
}
psCode = headerPS + Environment.NewLine + psCode + Environment.NewLine + methodPS;
CompiledShader pscs = ShaderCompiler.CompileFromSource(psCode, null, null, CompilerOptions.None, "PS", ShaderProfile.PS_3_0, targetPlatform);
if (!pscs.Success)
{
throw new InvalidOperationException("GPU Particle System Pixel Shader failed to compile:" + Environment.NewLine + pscs.ErrorsAndWarnings);
}
return(new ParticleSystemCompiledShaderData(pscs.GetShaderCode(), colourIndex, userIndex, lifeIndex));
}
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return("TiledLib.MapReader, TiledLib");
}
/// <summary> /// Converts the audio content to work on targeted platform. /// </summary> /// <param name="platform">The platform to build the audio content for.</param> /// <param name="quality">The suggested audio quality level.</param> /// <param name="content">The audio content to convert.</param> /// <returns>The quality used for conversion which could be different from the suggested quality.</returns> public abstract ConversionQuality ConvertAudio(TargetPlatform platform, ConversionQuality quality, AudioContent content);
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return(typeof(OctreeNodeReader <T>).AssemblyQualifiedName);
}
public bool IsCLR4Assembly(ModuleDefinition module)
{
TargetPlatform targetPlatform = this.GetTargetPlatform(module.FilePath, module);
return(targetPlatform == TargetPlatform.CLR_4 ? true : false);
}
public InputProfileDescriptionAttribute(string displayName, TargetPlatform platform)
{
this.DisplayName = displayName;
this.Platform = platform;
}
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return("TiledLib.Map, TiledLib");
}
/// <summary> /// Converts the audio content to a streaming format that works on targeted platform. /// </summary> /// <param name="platform">The platform to build the audio content for.</param> /// <param name="quality">The suggested audio quality level.</param> /// <param name="content">he audio content to convert.</param> /// <param name="outputFileName"></param> /// <returns>The quality used for conversion which could be different from the suggested quality.</returns> public abstract ConversionQuality ConvertStreamingAudio(TargetPlatform platform, ConversionQuality quality, AudioContent content, ref string outputFileName);
public override string GetRuntimeReader(TargetPlatform targetPlatform)
{
return(typeof(Nez.Tiled.TiledMapReader).AssemblyQualifiedName);
}
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return(typeof(QuadTreeNode <T>).AssemblyQualifiedName);
}
public DecompiledCodeResult(IDecompiledDocument[] documents, CompilerMetadataReference[] assemblyReferences, IAssemblyReferenceResolver assemblyReferenceResolver, TargetPlatform platform) {
Documents = documents;
AssemblyReferences = assemblyReferences;
AssemblyReferenceResolver = assemblyReferenceResolver;
Platform = platform;
}
public override string GetRuntimeType(TargetPlatform targetPlatform)
{
return(typeof(TextureAtlasFile).AssemblyQualifiedName);
}
