2437 lines
No EOL
88 KiB
C#
2437 lines
No EOL
88 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using JustDance.Engine;
|
|
using Sharpmake;
|
|
using Ubisoft;
|
|
using Optimization = JustDance.Engine.Optimization;
|
|
|
|
namespace JustDance.Tools
|
|
{
|
|
|
|
[Fragment, Flags]
|
|
public enum ScoringToolsPlatform
|
|
{
|
|
None = 1 << 0,
|
|
PS4 = 1 << 1,
|
|
XOne = 1 << 2,
|
|
X360 = 1 << 3,
|
|
NX = 1 << 4,
|
|
}
|
|
|
|
public class ScoringToolsTarget : BaseCppTarget
|
|
{
|
|
public ScoringToolsPlatform ConsolePlatform = ScoringToolsPlatform.None;
|
|
|
|
public ScoringToolsTarget() { }
|
|
|
|
public ScoringToolsTarget(Platform platform, DevEnv devEnv, Engine.Optimization optimization,
|
|
OutputType outputType, ScoringToolsPlatform consolePlatform = ScoringToolsPlatform.None)
|
|
: base(platform, devEnv, optimization, outputType)
|
|
{
|
|
ConsolePlatform = consolePlatform;
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
var name = Optimization.ToString();
|
|
if (ConsolePlatform != ScoringToolsPlatform.None)
|
|
{
|
|
name += "_" + ConsolePlatform;
|
|
}
|
|
return name;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
var target = (ScoringToolsTarget)obj;
|
|
return Name == target.Name &&
|
|
ConsolePlatform == target.ConsolePlatform &&
|
|
ApplicationType == target.ApplicationType &&
|
|
DevEnv == target.DevEnv &&
|
|
Optimization == target.Optimization &&
|
|
Platform == target.Platform;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return this.Name.GetHashCode();
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
public class ScoringToolsNativeApplication : BaseCppProjectGeneric<ScoringToolsTarget>
|
|
{
|
|
public static readonly string ScoringUtilitiesOutput = ToolsPath + @"\extern\ScoringUtilities\";
|
|
|
|
public readonly string ReleasePlatformOutput = ScoringUtilitiesOutput + @"\bin\Release\Tools\ScoringTools\[project.Name]\";
|
|
|
|
public readonly string DebugPlatformOutput = ScoringUtilitiesOutput + @"\bin\Debug\Tools\ScoringTools\[project.Name]\";
|
|
|
|
protected string PlatformArchitecture { get; private set; }
|
|
protected string ZLib { get; private set; }
|
|
protected string ExampleLib { get; private set; }
|
|
protected string TimeLineCacheLib { get; private set; }
|
|
protected string LibraryEndingName { get; private set; }
|
|
|
|
public ScoringToolsNativeApplication()
|
|
{
|
|
RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src");
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64,
|
|
DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release,
|
|
Sharpmake.OutputType.Lib));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectFileName = "[project.Name].[target.DevEnv]";
|
|
conf.IncludePaths.Add(Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "include"));
|
|
conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
|
|
SetCommonLibrariesPath(target);
|
|
|
|
if (target.Optimization.GetLibrarySuffix() == LibrarySuffix.d)
|
|
{
|
|
conf.Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDebugDLL);
|
|
conf.Options.Add(Options.Vc.Linker.Incremental.Enable);
|
|
}
|
|
|
|
if (target.Optimization.GetLibrarySuffix() == LibrarySuffix.r)
|
|
{
|
|
conf.Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDLL);
|
|
conf.Options.Add(Options.Vc.Linker.Incremental.Disable);
|
|
}
|
|
|
|
conf.Options.Add(Options.Vc.Compiler.EnhancedInstructionSet.Disable);
|
|
conf.ProjectPath = SourceRootPath;
|
|
}
|
|
|
|
private void SetCommonLibrariesPath(ScoringToolsTarget target)
|
|
{
|
|
PlatformArchitecture = GetPlatformArchitecture(target);
|
|
|
|
LibraryEndingName = PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix() + ".lib";
|
|
ZLib = Path.Combine(ExternPath, "KinectGesture", "Dependencies", "zlibstatic" + LibraryEndingName);
|
|
ExampleLib = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "ExamplesLib" + LibraryEndingName);
|
|
TimeLineCacheLib = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "TimelineCacheLib" + LibraryEndingName);
|
|
}
|
|
|
|
public void AddPlatformSpecificTargetPath(Configuration conf, Platform platform)
|
|
{
|
|
if (platform == Platform.win64)
|
|
{
|
|
conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "x64");
|
|
}
|
|
else if (platform == Platform.win32) // TODO : better to remove the win32 as all our tools are in x64. NOTE: make sure the sdk and other helper libs compile in x64
|
|
{
|
|
conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib" , "tools", "x86");
|
|
}
|
|
}
|
|
|
|
protected void SetConfigurationTargetPath(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
var librarySuffix = target.Optimization.GetLibrarySuffix();
|
|
switch (librarySuffix)
|
|
{
|
|
case LibrarySuffix.d:
|
|
conf.TargetPath = Path.Combine(DebugPlatformOutput, target.ConsolePlatform.ToString());
|
|
break;
|
|
case LibrarySuffix.r:
|
|
conf.TargetPath = Path.Combine(ReleasePlatformOutput, target.ConsolePlatform.ToString());
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected static string GetPlatformArchitecture(ITarget target)
|
|
{
|
|
switch (target.GetPlatform())
|
|
{
|
|
case Platform.win32: return "_x86";
|
|
case Platform.win64: return "_x64";
|
|
default: return string.Empty;
|
|
}
|
|
}
|
|
|
|
protected virtual void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class ScoringToolLibrary : ScoringToolsNativeApplication
|
|
{
|
|
public ScoringToolLibrary()
|
|
{
|
|
OutputType = Configuration.OutputType.Lib;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib", "tools");
|
|
}
|
|
}
|
|
|
|
public class ScoringToolAplication : ScoringToolsNativeApplication
|
|
{
|
|
protected ScoringToolAplication()
|
|
{
|
|
OutputType = Configuration.OutputType.Exe;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.Options.Add(Options.Vc.General.DebugInformation.ProgramDatabase);
|
|
conf.Options.Add(Options.Vc.Compiler.FloatingPointExceptions.Disable);
|
|
conf.Options.Add(Options.Vc.Linker.EnableCOMDATFolding.DoNotRemoveRedundantCOMDATs);
|
|
conf.Options.Add(Options.Vc.Linker.Reference.KeepUnreferencedData);
|
|
conf.TargetPath = ScoringUtilitiesOutput + @"bin\[conf.Name]\Tools\ScoringTools\[project.Name]\[conf.Platform]\";
|
|
}
|
|
|
|
public void AddAdditioalDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.PS4)
|
|
{
|
|
conf.Defines.Add("TARGET_ORBIS");
|
|
}
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
|
|
{
|
|
conf.Defines.Add("TARGET_DURANGO");
|
|
}
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.X360)
|
|
{
|
|
conf.Defines.Add("TARGET_X360");
|
|
}
|
|
}
|
|
|
|
protected virtual void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class ScoringToolDynamicLib : ScoringToolsNativeApplication
|
|
{
|
|
protected ScoringToolDynamicLib()
|
|
{
|
|
OutputType = Configuration.OutputType.Dll;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
conf.Options.Add(Options.Vc.Compiler.Optimization.MaximizeSpeed);
|
|
conf.Options.Add(Options.Vc.Compiler.Exceptions.EnableWithSEH);
|
|
conf.Options.Add(Options.Vc.Compiler.RuntimeChecks.Default);
|
|
conf.Options.Add(Options.Vc.Compiler.FloatingPointExceptions.Disable);
|
|
conf.Options.Add(Options.Vc.Compiler.RTTI.Enable);
|
|
conf.Options.Add(Options.Vc.SourceFile.PrecompiledHeader.CreatePrecompiledHeader);
|
|
conf.TargetPath = ScoringUtilitiesOutput + @"lib\tools\";
|
|
}
|
|
}
|
|
|
|
public class CommonScoringToolApplication : ScoringToolAplication
|
|
{
|
|
public CommonScoringToolApplication()
|
|
{
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib,
|
|
ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
AddConsoleSpecificDependencies(conf, target.ConsolePlatform);
|
|
|
|
conf.TargetFileName = conf.ProjectName + "_" + target.ConsolePlatform + PlatformArchitecture;
|
|
conf.DependenciesIncludePaths.Add(ExternPath, ExternPath + @"KinectGesture/Inc");
|
|
|
|
var kinectGestureLib = Path.Combine(ExternPath, "KinectGesture", "Lib", "KinectGestureTrainer_" + target.ConsolePlatform + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix() + ".vs2017.lib");
|
|
|
|
conf.AdditionalLinkerOptions.Add( ZLib, kinectGestureLib, ExampleLib);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
SetConfigurationTargetPath(conf, target);
|
|
}
|
|
|
|
protected override void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
|
|
{
|
|
switch (console)
|
|
{
|
|
case ScoringToolsPlatform.PS4:
|
|
conf.DependenciesIncludePaths.Add("$(SCE_ORBIS_SDK_DIR)/target/include_common");
|
|
break;
|
|
case ScoringToolsPlatform.XOne:
|
|
conf.DependenciesIncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um", "$(XboxOneXDKLatest)xdk/include/shared");
|
|
break;
|
|
case ScoringToolsPlatform.X360:
|
|
conf.DependenciesIncludePaths.Add("$(XEDK)/include/win32");
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("GESTURE_TRAINER", "WIN64", "NDEBUG", "_CONSOLE");
|
|
AddAdditioalDefines(conf, target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
public class ExamplesLib : ScoringToolLibrary
|
|
{
|
|
public ExamplesLib()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "ExamplesLib");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ExportAdditionalLibrariesEvenForStaticLib = true;
|
|
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
|
|
|
|
conf.IncludePaths.Clear();
|
|
conf.IncludePaths.Add(ToolsPath + "apps/ScoringTools/PostRecordingPipelineTools/include");
|
|
conf.IncludePaths.Add(BranchRoot + "tools/legacy/ParseExampleTool/ParseExample");
|
|
|
|
conf.DependenciesIncludePaths.Add(ExternPath + "SK_iisu",
|
|
ExternPath + "ZLib",
|
|
ExternPath + "KinectGesture/Inc",
|
|
"$(windowssdk_includepath)",
|
|
"$(XboxOneXDKLatest)xdk/Include/um",
|
|
"$(XboxOneXDKLatest)xdk/Include/shared",
|
|
@"$(DXSDK_DIR)\include",
|
|
"$(DXSDK_DIR)/extras/directshow/include",
|
|
"$(XEDK)/include/win32",
|
|
"$(windowssdkdir)/common/include");
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("EXAMPLES_LIB", "WIN32", "NDEBUG", "_LIB", "EXAMPLELIB_PC", "_UNICODE");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class ExamplesWrapper : ScoringToolDynamicLib
|
|
{
|
|
public ExamplesWrapper()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "Examples.Wrapper");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectName = "Examples.Wrapper";
|
|
conf.TargetFileName = conf.ProjectName;
|
|
|
|
PerformPlatformSpecificActions(conf, target);
|
|
conf.AddPublicDependency<ExamplesLib>(target);
|
|
conf.DependenciesIncludePaths.Add(@"$(DXSDK_DIR)\Include");
|
|
}
|
|
|
|
protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.PerformPlatformSpecificActions(conf, target);
|
|
if (conf.Platform == Platform.win32)
|
|
{
|
|
conf.AdditionalLinkerOptions.Clear();
|
|
}
|
|
else if (conf.Platform == Platform.win64)
|
|
{
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
|
|
conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
|
|
conf.Options.Add(Options.Vc.General.WholeProgramOptimization.LinkTime);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
conf.Options.Add(Options.Vc.Compiler.Optimization.Disable);
|
|
conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
|
|
conf.Defines.Add("EXAMPLESLIB_MANAGED", "EXAMPLELIB_PC", "NDEBUG");
|
|
conf.AdditionalLinkerOptions.Add(ZLib);
|
|
}
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("EXAMPLELIB_ORBIS", "EXAMPLELIB_PC");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class ExampleTransformer : ScoringToolAplication
|
|
{
|
|
public ExampleTransformer()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "ExampleTransformer");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
PerformPlatformSpecificActions(conf, target);
|
|
conf.AddPublicDependency<ExamplesLib>(target);
|
|
}
|
|
|
|
protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
if (conf.Platform == Platform.win32)
|
|
{
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture;
|
|
}
|
|
else if (conf.Platform == Platform.win64)
|
|
{
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
|
|
conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
|
|
conf.AdditionalLinkerOptions.Add(ZLib);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class ExamplesFileViewer : ScoringToolAplication
|
|
{
|
|
public ExamplesFileViewer()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "ExamplesLibUnitTest");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = conf.ProjectName;
|
|
conf.DependenciesOtherLibraryFiles.Add("dxerr.lib",
|
|
"d2d1.lib",
|
|
"dwrite.lib",
|
|
"windowscodecs.lib",
|
|
"dxgi.lib",
|
|
"d3d10_1.lib");
|
|
conf.Options.Add(Options.Vc.Linker.SubSystem.Application);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
PerformPlatformSpecificActions(conf, target);
|
|
conf.AddPublicDependency<ExamplesLib>(target);
|
|
conf.IncludePaths.Clear();
|
|
conf.IncludePaths.Add(Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "include"));
|
|
}
|
|
|
|
protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture;
|
|
|
|
if (conf.Platform == Platform.win64)
|
|
{
|
|
conf.AdditionalLinkerOptions.Add(ZLib);
|
|
conf.LibraryPaths.Clear();
|
|
conf.LibraryPaths.Add("$(DXSDK_DIR)/lib/x64");
|
|
conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GenerateExamples : ScoringToolAplication
|
|
{
|
|
public GenerateExamples()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "GenerateExamples");
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release,
|
|
Sharpmake.OutputType.Lib, ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
AddConsoleSpecificDependencies(conf, target.ConsolePlatform);
|
|
|
|
conf.TargetFileName = conf.ProjectName + "_" + target.ConsolePlatform + PlatformArchitecture;
|
|
conf.DependenciesIncludePaths.Add(ExternPath, ExternPath + @"KinectGesture/Inc");
|
|
|
|
conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
|
|
conf.AddPublicDependency<TimelineCacheLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
|
|
|
|
AddAditionalLinkerLibraries(conf);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
SetConfigurationTargetPath(conf, target);
|
|
}
|
|
|
|
private void AddAditionalLinkerLibraries(Configuration conf)
|
|
{
|
|
conf.AdditionalLinkerOptions.Clear();
|
|
conf.AdditionalLinkerOptions.Add( ZLib, ExampleLib, TimeLineCacheLib);
|
|
}
|
|
|
|
protected override void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
|
|
{
|
|
if (console == ScoringToolsPlatform.XOne)
|
|
{
|
|
conf.LibraryPaths.Add("$(DurangoXDK)PC/lib/amd64");
|
|
conf.IncludePaths.Add("$(DurangoXDK)PC/include");
|
|
conf.IncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um");
|
|
conf.IncludePaths.Add("$(XboxOneXDKLatest)PC/include");
|
|
conf.LibraryPaths.Add("$(XboxOneXDKLatest)PC/lib/amd64");
|
|
conf.LibraryPaths.Add("$(XboxOneXDKLatest)xdk/lib/amd64");
|
|
conf.LibraryFiles.Add("xstudioservice.lib");
|
|
var delayLoadDlLs = new Options.Vc.Linker.DelayLoadDLLs("xstudioservice.dll");
|
|
conf.Options.Add(delayLoadDlLs);
|
|
}
|
|
else if (console == ScoringToolsPlatform.PS4)
|
|
{
|
|
conf.IncludePaths.Add(Path.Combine(ExternPath, @"SK_iisu\include"));
|
|
var skLibsPath = Path.Combine(ExternPath, @"SK_iisu\Win64");
|
|
conf.LibraryPaths.Add(skLibsPath);
|
|
conf.LibraryFiles.Add("skv.lib");
|
|
conf.EventPreBuild.Add(string.Format(@"IF NOT EXIST ""$(OutputPath)skv.dll"" xcopy {0}\skv.dll ""$(OutputPath)""", skLibsPath));
|
|
}
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("NDEBUG", "_CONSOLE");
|
|
if (target.Platform == Platform.win32)
|
|
{
|
|
conf.Defines.Add("WIN32");
|
|
}
|
|
|
|
if (target.Platform == Platform.win64)
|
|
{
|
|
conf.Defines.Add("WIN64");
|
|
}
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.PS4)
|
|
{
|
|
conf.Defines.Add("TARGET_PS4");
|
|
conf.Defines.Add("FORMAT_SKV");
|
|
}
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
|
|
{
|
|
conf.Defines.Add("TARGET_XONE");
|
|
}
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.X360)
|
|
{
|
|
conf.Defines.Add("TARGET_X360");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The generate labeled examples.
|
|
/// </summary>
|
|
[Generate]
|
|
public class GenerateLabeledExamples : CommonScoringToolApplication
|
|
{
|
|
public GenerateLabeledExamples()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "GenerateLabeledExamples");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MicrosoftDirectXControls : ScoringToolDynamicLib
|
|
{
|
|
public MicrosoftDirectXControls()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath , "DirectX.Wrapper", "DirectX.Controls");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectName = "Microsoft.DirectX.Controls";
|
|
conf.TargetFileName = conf.ProjectName;
|
|
conf.AdditionalLinkerOptions.Add("gdi32.lib",
|
|
"user32.lib");
|
|
|
|
conf.ReferencesByName.Add("PresentationCore.dll",
|
|
"PresentationFramework.dll",
|
|
"System.dll",
|
|
"System.Drawing.dll",
|
|
"System.Windows.Forms.dll",
|
|
"WindowsBase.dll");
|
|
AddPlatformSpecificTargetPath(conf, target.Platform);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MicrosoftDirectXWrapper : ScoringToolDynamicLib
|
|
{
|
|
public MicrosoftDirectXWrapper()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "DirectX.Wrapper", "DirectX.Wrapper");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectName = "Microsoft.DirectX.Wrapper";
|
|
conf.TargetFileName = conf.ProjectName;
|
|
conf.AdditionalLinkerOptions.Add("gdi32.lib",
|
|
"user32.lib");
|
|
conf.IncludePaths.Clear();
|
|
conf.IncludePaths.Add(SourceRootPath);
|
|
conf.ForcedIncludes.Add("CodeAnalysis/SourceAnnotations.h");
|
|
AddPlatformSpecificTargetPath(conf, target.Platform);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TimelineCacheWrapper : ScoringToolDynamicLib
|
|
{
|
|
public TimelineCacheWrapper()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "TimelineCacheWrapper");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = conf.ProjectName;
|
|
conf.AddPublicDependency<TimelineCacheLib>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class Ps4TcpServer : ScoringToolDynamicLib
|
|
{
|
|
public Ps4TcpServer()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "PS4TCPServer");
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.orbis, DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = conf.ProjectName;
|
|
conf.AdditionalLinkerOptions.Add("-lScePosix_stub_weak", "-lSceNet_stub_weak", "-lSceNetCtl_stub_weak", "-lSceRtc_stub_weak");
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("PS4TCPSRV", "NDEBUG");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TimelineCacheLib : ScoringToolLibrary
|
|
{
|
|
public TimelineCacheLib()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "TimelineCacheLib");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class SkeletonDumper : ScoringToolAplication
|
|
{
|
|
public SkeletonDumper()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "SkeletonDumper");
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib,
|
|
ScoringToolsPlatform.XOne));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = conf.ProjectName;
|
|
|
|
if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
|
|
{
|
|
conf.IncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um");
|
|
conf.IncludePaths.Add("$(XboxOneXDKLatest)PC/include");
|
|
conf.LibraryFiles.Add("$(XboxOneXDKLatest)xdk/lib/amd64/xstudioclient.lib");
|
|
conf.Options.Add(new Options.Vc.Linker.DelayLoadDLLs("xstudioclient.dll"));
|
|
}
|
|
|
|
conf.DependenciesIncludePaths.Add(ExternPath,
|
|
ExternPath + @"KinectGesture/Inc"
|
|
);
|
|
SetConfigurationTargetPath(conf, target);
|
|
conf.AdditionalLinkerOptions.Add( ZLib, ExampleLib, TimeLineCacheLib);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
}
|
|
|
|
protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureDefines(conf, target);
|
|
conf.Defines.Add("NDEBUG", "_CONSOLE", "TARGET_XONE", "WIN64");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
internal class TrainGesture : CommonScoringToolApplication
|
|
{
|
|
public TrainGesture()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "TrainGesture");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The train gesture script writer.
|
|
/// </summary>
|
|
[Generate]
|
|
class TrainGestureScriptWriter : ScoringToolAplication
|
|
{
|
|
public TrainGestureScriptWriter()
|
|
{
|
|
SourceRootPath = Path.Combine(RootPath, "TrainGestureScriptWriter");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = "TrainGestureScriptWriter";
|
|
conf.Options.Add(Options.Vc.General.CharacterSet.Default);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
public class CoreFunctions : ScoringToolsDotNetApplication
|
|
{
|
|
public CoreFunctions() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Core.Functions");
|
|
AssemblyName = "Core.Functions";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByName.Add("System.Configuration");
|
|
conf.ReferencesByName.Add("System.Windows.Forms");
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
internal class CoreFunctionsSolution : SingleProjectSolution<CoreFunctions>
|
|
{
|
|
public CoreFunctionsSolution()
|
|
{
|
|
ClearTargets();
|
|
AddTargets(new Target(Platform.win64, DevEnv.vs2017,
|
|
Sharpmake.Optimization.Debug | Sharpmake.Optimization.Release,
|
|
Sharpmake.OutputType.Dll, framework: DotNetFramework.v4_7));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFileName = "CoreFunctions";
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "Core.Functions");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The solution that includes the C++ utilities for scoring tools
|
|
/// </summary>
|
|
[Generate]
|
|
public class ScoringUtilitiesSolution : BaseCppSolutionGeneric<ScoringToolsTarget>
|
|
{
|
|
|
|
public ScoringUtilitiesSolution()
|
|
{
|
|
Name = "ScoringUtilities";
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget( Platform.win64 | Platform.orbis, DevEnv.vs2015 | DevEnv.vs2017,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, OutputType.Lib,
|
|
ScoringToolsPlatform.None | ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
|
|
}
|
|
|
|
/// <summary>
|
|
/// From a target, retrieve all possible values
|
|
/// </summary>
|
|
/// <param name="target">A target</param>
|
|
/// <returns></returns>
|
|
private IEnumerable<ITarget> GetPossibleValues(ITarget target)
|
|
{
|
|
var fields = target.GetType().GetFields();
|
|
foreach (var fieldInfo in fields)
|
|
{
|
|
if (fieldInfo.FieldType.IsEnum)
|
|
{
|
|
var flags = ((Enum)fieldInfo.GetValue(target)).GetFlags().Cast<Enum>().ToArray();
|
|
if (flags.Length > 1)
|
|
{
|
|
foreach (var flag in flags)
|
|
{
|
|
var newTarget = (ScoringToolsTarget)target.Clone();
|
|
fieldInfo.SetValue(newTarget, flag);
|
|
var possibleValues = GetPossibleValues(newTarget);
|
|
foreach (var possibleValue in possibleValues)
|
|
{
|
|
yield return possibleValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fields.Where(f => f.FieldType.IsEnum).All(f => ((Enum)f.GetValue(target)).GetFlags().Count() == 1))
|
|
{
|
|
yield return target;
|
|
}
|
|
}
|
|
|
|
private bool IsValidTargetForProject(ScoringToolsTarget target, Type type)
|
|
{
|
|
var project = Activator.CreateInstance(type) as ScoringToolsNativeApplication;
|
|
var targetPossibilities = project.Targets.TargetPossibilities.SelectMany(x => GetPossibleValues(x)).Distinct();
|
|
return targetPossibilities.Contains(target);
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.RegisterProjectsOfType<ScoringToolLibrary>(target, type => IsValidTargetForProject(target, type));
|
|
conf.RegisterProjectsOfType<ScoringToolAplication>(target, type => IsValidTargetForProject(target, type));
|
|
// we are not going to add the projects that are type of ScoringToolDynamicLib and are part of MARS tool.
|
|
// TODO: Eventually all the C++ projects will be in one solution and then we will remove this additional check of 'IsNotMarsProject'
|
|
conf.RegisterProjectsOfType<ScoringToolDynamicLib>(target, type => IsValidTargetForProject(target, type) && IsNotMarsProject(type));
|
|
conf.SolutionPath = Path.Combine(RootPath, "tools", "apps", "ScoringTools");
|
|
}
|
|
|
|
private bool IsNotMarsProject(Type type)
|
|
{
|
|
bool include = !(type == typeof(MoveSpaceScoringTools) || type == typeof(MoveSpaceWrapper));
|
|
|
|
return include;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This class defines the template for scoring pipeline related .net application
|
|
/// </summary>
|
|
public abstract class ScoringToolsDotNetApplication : ApplicationProject
|
|
{
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="sourceRootPath">Path to the folder containing the source code</param>
|
|
/// <param name="outputType">valid value from the OutputType enum to indicate the type of application</param>
|
|
public ScoringToolsDotNetApplication(
|
|
string sourceRootPath,
|
|
Configuration.OutputType outputType = Configuration.OutputType.DotNetConsoleApp,
|
|
bool sourceInSubFolder = false) // TODO : we are not passing the parameters to base class and letting it behave as it wants for now
|
|
{
|
|
|
|
if (outputType == Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
ProjectType = "framework/scoring";
|
|
}
|
|
else
|
|
{
|
|
ProjectType = "apps/scoring";
|
|
}
|
|
|
|
// Assuming that all the .net windows application will have application icon.
|
|
// if the project of type windows app does not have an application Icon. make sure to set this property to empty string in the constructor of the project
|
|
if (outputType == Configuration.OutputType.DotNetWindowsApp)
|
|
ApplicationIcon = @"Resources\[project.Name].ico";
|
|
|
|
SourceRootPath = sourceRootPath + @"\[project.Name]\";
|
|
OutputType = outputType;
|
|
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
// scoring tool related application project should go under the 'scoring' label when seen in solution
|
|
if (OutputType == Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
conf.SolutionFolder = "framework/scoring";
|
|
}
|
|
else
|
|
{
|
|
conf.SolutionFolder = "apps/scoring";
|
|
}
|
|
|
|
conf.ReferencesByName.Add("WindowsBase");
|
|
conf.ReferencesByName.Add("PresentationCore");
|
|
conf.ReferencesByName.Add("PresentationFramework");
|
|
|
|
conf.TargetPath = OutputPath + @"\lib\Tools\ScoringToolLibs\";
|
|
}
|
|
}
|
|
|
|
//************************************* LEGACY SCORING TOOL - BEGIN ***************************************************
|
|
|
|
|
|
[Generate]
|
|
class GenerateDanceCache : ScoringToolsDotNetApplication
|
|
{
|
|
public GenerateDanceCache() : base(ScoringTools_PostRecordingPipelineTools)
|
|
{
|
|
AssemblyName = "GenerateDanceCache";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<JD_Timeline>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
|
|
conf.RegisterWinForms();
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
conf.AddPostBuildCopy(Externs.SandBar);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GenerateDanceCacheSolution : SingleProjectSolution<GenerateDanceCache>
|
|
{
|
|
public GenerateDanceCacheSolution()
|
|
{
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GenerateDanceCache");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GenerateTMLCache : ScoringToolsDotNetApplication
|
|
{
|
|
public GenerateTMLCache() : base(ScoringTools_PostRecordingPipelineTools) { }
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<JD_Application>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GestureBuildLib : ScoringToolsDotNetApplication
|
|
{
|
|
public GestureBuildLib() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
AssemblyName = "GestureBuildLib";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFolder = "framework/scoring";
|
|
conf.Options.Add(Options.CSharp.TreatWarningsAsErrors.Disabled);
|
|
conf.AddPublicDependency<JD_Perforce>(target);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class BuildGestureGUI : ScoringToolsDotNetApplication
|
|
{
|
|
public BuildGestureGUI() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
|
|
{
|
|
SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "BuildGesturesGUI", "BuildGesturesGUI");
|
|
AssemblyName = "BuildGestureGUI";
|
|
Name = GetType().Name;
|
|
ResourcesPath = String.Empty;
|
|
ApplicationIcon = String.Empty;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<JD_Perforce>(target);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class Examples_Viewer : ScoringToolsDotNetApplication
|
|
{
|
|
public Examples_Viewer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
|
|
{
|
|
SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Examples.Viewer");
|
|
AssemblyName = "Examples.Viewer";
|
|
Name = GetType().Name;
|
|
ResourcesPath = String.Empty;
|
|
ApplicationIcon = String.Empty;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
(conf.Project as CSharpProject).RootNamespace = "Examples.Viewer";
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.AddPublicDependency<Examples_Controls>(target);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class Examples_Controls : ScoringToolsDotNetApplication
|
|
{
|
|
public Examples_Controls() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
|
|
{
|
|
SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Examples.Controls");
|
|
AssemblyName = "Examples.Controls";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFolder = "framework/scoring";
|
|
(conf.Project as CSharpProject).RootNamespace = "Examples.Controls";
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\x64\Microsoft.DirectX.Controls.dll");
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\x64\Microsoft.DirectX.Wrapper.dll");
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class ScoringDataBuildHelper : ScoringToolsDotNetApplication
|
|
{
|
|
public ScoringDataBuildHelper() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
|
|
{
|
|
AssemblyName = "ScoringDataBuildHelper";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<JD_Perforce>(target);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class PS4Studio : ScoringToolsDotNetApplication
|
|
{
|
|
public PS4Studio() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
|
|
{
|
|
AssemblyName = "PS4Studio";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
ApplicationIcon = "";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByPath.Add(Externs.OrtMapLib);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class Timeline : ScoringToolsDotNetApplication
|
|
{
|
|
public Timeline() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, true)
|
|
{
|
|
AssemblyName = "Timeline";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFolder = "framework/scoring";
|
|
(conf.Project as CSharpProject).RootNamespace = "TimelineUI";
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.RegisterWinForms();
|
|
conf.AddPublicDependency<JD_Core>(target);
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TimelineUnitTest : ScoringToolsDotNetApplication
|
|
{
|
|
public TimelineUnitTest() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
|
|
{
|
|
AssemblyName = "TimelineUnitTest";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<Timeline>(target);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class SKVPlayer : ScoringToolsDotNetApplication
|
|
{
|
|
public SKVPlayer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetConsoleApp, false)
|
|
{
|
|
AssemblyName = "SKVPlayer";
|
|
Name = GetType().Name;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
// TODO : Rename this project to SnippingTool
|
|
|
|
[Generate]
|
|
class ScoringTool : ScoringToolsDotNetApplication
|
|
{
|
|
public ScoringTool() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
|
|
{
|
|
AssemblyName = "ScoringTool";
|
|
Name = GetType().Name;
|
|
ResourcesPath = String.Empty;
|
|
ApplicationIcon = String.Empty;
|
|
RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<CoreFunctions>(target);
|
|
conf.AddPublicDependency<GestureBuildLib>(target);
|
|
conf.AddPublicDependency<Timeline>(target);
|
|
conf.AddPublicDependency<ScoringDataBuildHelper>(target);
|
|
conf.AddPublicDependency<Examples_Controls>(target);
|
|
conf.AddPublicDependency<JD_Core>(target);
|
|
conf.AddPublicDependency<JD_Asset>(target);
|
|
conf.AddPublicDependency<JD_Perforce>(target);
|
|
conf.AddPublicDependency<JD_Serialization>(target);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
|
|
conf.ReferencesByPath.Add(Externs.NAudio);
|
|
conf.RegisterWinForms();
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
|
|
conf.AddPostBuildDirectoryCopy(@"[project.RootPath]\script", Path.Combine(OutputPath + @"\bin\Release\Tools\ScoringTools\", "script"));
|
|
conf.AddPostBuildDirectoryCopy(@"[project.RootPath]\script", Path.Combine(OutputPath + @"\bin\Debug\Tools\ScoringTools\", "script"));
|
|
}
|
|
}
|
|
|
|
class GestureComparer : ScoringToolsDotNetApplication
|
|
{
|
|
protected Platform Platform { get; set; }
|
|
|
|
public GestureComparer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetConsoleApp ,false)
|
|
{
|
|
// by default making it support XOne
|
|
Platform = Platform.durango;
|
|
SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "GestureComparer");
|
|
AssemblyName = "GestureComparer";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
var fileName = @"\lib\tools\Examples.Wrapper_x64_r.dll";
|
|
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + fileName);
|
|
conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperPs4);
|
|
conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperX360);
|
|
conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperXOne);
|
|
conf.ReferencesByPath.Add(Externs.CameraScoringFilesInfoProvider);
|
|
|
|
var optimization = target.Optimization.ToString();
|
|
var configuration = optimization.Contains("Debug", StringComparison.OrdinalIgnoreCase) ? "Debug" : "Release";
|
|
|
|
string platform = string.Empty;
|
|
|
|
if (Platform == Platform.durango)
|
|
platform = "XOne";
|
|
else if (Platform == Platform.orbis)
|
|
platform = "Ps4";
|
|
else if (Platform == Platform.x360)
|
|
platform = "X360";
|
|
|
|
conf.Defines.Clear();
|
|
conf.Defines.Add("TARGET_" + platform);
|
|
conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
|
|
conf.TargetPath = Path.Combine(OutputPath + @"\bin\[conf.Name]\Tools\ScoringTools\", "GestureComparer", platform.ToString());
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GestureComparerXOne : GestureComparer
|
|
{
|
|
public GestureComparerXOne()
|
|
{
|
|
Platform = Platform.durango;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectFileName = "GestureComparerXone";
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
internal class GestureComparerXOneSolution : SingleProjectSolution<GestureComparerXOne>
|
|
{
|
|
public GestureComparerXOneSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFileName = "GestureComparerXOne";
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GestureComparer");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GestureComparerPs4 : GestureComparer
|
|
{
|
|
public GestureComparerPs4()
|
|
{
|
|
Platform = Platform.orbis;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ProjectFileName = "GestureComparerPs4";
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
internal class GestureComparerPs4Solution : SingleProjectSolution<GestureComparerPs4>
|
|
{
|
|
public GestureComparerPs4Solution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionFileName = "GestureComparerPs4";
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GestureComparer");
|
|
}
|
|
}
|
|
|
|
//************************************* LEGACY SCORING TOOL - END ***************************************************
|
|
|
|
[Generate]
|
|
class CafeCommand : ScoringToolsDotNetApplication
|
|
{
|
|
public CafeCommand() : base(ScoringTools_RecordingPipelineTools)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<WiiULauncherAPI>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class CafeCommandSolution : SingleProjectSolution<CafeCommand>
|
|
{
|
|
public CafeCommandSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "CafeCommand");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class CaptureTool : ScoringToolsDotNetApplication
|
|
{
|
|
public CaptureTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<DKTPServer>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class CaptureToolSolution : SingleProjectSolution<CaptureTool>
|
|
{
|
|
public CaptureToolSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "CaptureTool");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class DevkitRecorderInterface : ScoringToolsDotNetApplication
|
|
{
|
|
public DevkitRecorderInterface() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class DevkitRecorderInterfaceSolution : SingleProjectSolution<DevkitRecorderInterface>
|
|
{
|
|
public DevkitRecorderInterfaceSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "DevkitRecorderInterface");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class DKTPServer : ScoringToolsDotNetApplication
|
|
{
|
|
public DKTPServer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class DKTPServerSolution : SingleProjectSolution<DKTPServer>
|
|
{
|
|
public DKTPServerSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "DKTPServer");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GraphicTools : ScoringToolsDotNetApplication
|
|
{
|
|
public GraphicTools() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
|
|
conf.AddPublicDependency<MSPMatrixVector>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class GraphicToolsSolution : SingleProjectSolution<GraphicTools>
|
|
{
|
|
public GraphicToolsSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "GraphicTools");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRecorder : ScoringToolsDotNetApplication
|
|
{
|
|
public KinectRecorder() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
|
|
conf.AddPostBuildCopy("$(ProjectDir)\\Dependency\\xstudio.dll", "$(TargetDir)");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRecorderSolution : SingleProjectSolution<KinectRecorder>
|
|
{
|
|
public KinectRecorderSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRecorder");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRemoteHost : ScoringToolsDotNetApplication
|
|
{
|
|
public KinectRemoteHost() : base(ScoringTools_RecordingPipelineTools)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
var configFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost", "KinectRemoteHost.exe.config");
|
|
|
|
var postBuildCopyCommand = "xcopy /Y \"" + configFilePath + "\" \"$(TargetDir)\"";
|
|
|
|
conf.EventPostBuild.Add(postBuildCopyCommand);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRemoteHostSolution : SingleProjectSolution<KinectRemoteHost>
|
|
{
|
|
public KinectRemoteHostSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRemoteType : ScoringToolsDotNetApplication
|
|
{
|
|
public KinectRemoteType() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
var xstudioManagedDll = Path.Combine(@"C:\Program Files (x86)\Microsoft Durango XDK", "bin", "XStudioManaged.dll");
|
|
conf.ReferencesByPath.Add(xstudioManagedDll);
|
|
|
|
var configFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MARS", "KinectRemoteType.config");
|
|
|
|
var postBuildCopyCommand = "xcopy /Y \"" + configFilePath + "\" \"$(TargetDir)\"";
|
|
|
|
conf.EventPostBuild.Add(postBuildCopyCommand);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class KinectRemoteTypeSolution : SingleProjectSolution<KinectRemoteType>
|
|
{
|
|
public KinectRemoteTypeSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteType");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class LuaMoveExtractor : ScoringToolsDotNetApplication
|
|
{
|
|
public LuaMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class LuaMoveExtractorSolution : SingleProjectSolution<LuaMoveExtractor>
|
|
{
|
|
public LuaMoveExtractorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "LuaMoveExtractor");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class Mars : ScoringToolsDotNetApplication
|
|
{
|
|
public Mars() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
|
|
{
|
|
StartupObject = "Mars.Program";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.ReferencesByName.Add("Microsoft.VisualBasic");
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
conf.ReferencesByName.Add("System.Runtime.Remoting");
|
|
conf.ReferencesByName.Add("System.Windows.Forms");
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.NewtonsoftJsonNuget);
|
|
conf.RegisterPerforce();
|
|
|
|
var xstudioManagedDll =
|
|
Path.Combine(@"C:\Program Files (x86)\Microsoft Durango XDK", "bin", "XStudioManaged.dll");
|
|
conf.ReferencesByPath.Add(xstudioManagedDll);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");
|
|
|
|
conf.AddPublicDependency<WiiULauncherAPI>(target);
|
|
|
|
conf.AddPublicDependency<JD_Core>(target);
|
|
conf.AddPublicDependency<CaptureTool>(target);
|
|
conf.AddPublicDependency<DKTPServer>(target);
|
|
conf.AddPublicDependency<DevkitRecorderInterface>(target);
|
|
conf.AddPublicDependency<GraphicTools>(target);
|
|
conf.AddPublicDependency<KinectRecorder>(target);
|
|
conf.AddPublicDependency<KinectRemoteHost>(target);
|
|
conf.AddPublicDependency<KinectRemoteType>(target);
|
|
conf.AddPublicDependency<MarsTools>(target);
|
|
conf.AddPublicDependency<MarsRemotingInterfaces>(target);
|
|
conf.AddPublicDependency<MoveSpaceTool>(target);
|
|
conf.AddPublicDependency<MSPClassifier>(target);
|
|
conf.AddPublicDependency<MarsInterfaces>(target);
|
|
conf.AddPublicDependency<MSPStats>(target);
|
|
conf.AddPublicDependency<MSPMatrixVector>(target);
|
|
conf.AddPublicDependency<NotifyIconWpf>(target);
|
|
conf.AddPublicDependency<PS4Recorder>(target);
|
|
conf.AddPublicDependency<LuaMoveExtractor>(target);
|
|
conf.AddPublicDependency<TmlDtapeMoveExtractor>(target);
|
|
conf.AddPublicDependency<TmlMoveExtractor>(target);
|
|
conf.AddPublicDependency<TplMoveExtractor>(target);
|
|
conf.AddPublicDependency<WaveformView>(target);
|
|
conf.AddPublicDependency<WebmPlayer>(target);
|
|
|
|
// copy the project folder from solution folder to the output folder
|
|
var projectConfigurationFiles = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Projects");
|
|
var ffmpegBinaries = Path.Combine(BranchRoot, "extern", "ffmpeg", "scoringToolRelated");
|
|
var toolsFolder = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Tools");
|
|
|
|
// TODO: Need to figure out a neat way of doing the copy of .config files.
|
|
var kinectRemoteTypeConfigFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MARS", "KinectRemoteType.config");
|
|
var kinectRemoteHostConfigFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost", "KinectRemoteHost.exe.config");
|
|
|
|
var postBuildEventCommand = "xcopy /E /Y /D \"" + projectConfigurationFiles + "\" \"$(TargetDir)Projects\\\"";
|
|
var postBuildCommandToCopyFfmpegBinaries = "xcopy /E /Y /D \"" + ffmpegBinaries + "\" \"$(TargetDir)\"";
|
|
var postBuildCommandToCopyToolsFolderToOutput = "xcopy /E /Y /D \"" + toolsFolder + "\" \"$(TargetDir)Tools\\\"";
|
|
var postBuildCopyCommandToCopyKinectConfig = "xcopy /Y \"" + kinectRemoteTypeConfigFilePath + "\" \"$(TargetDir)\"";
|
|
var postBuildCopyCommandToCopyKinectHostConfig = "xcopy /Y \"" + kinectRemoteHostConfigFilePath + "\" \"$(TargetDir)\"";
|
|
|
|
conf.EventPostBuild.Add(postBuildEventCommand);
|
|
conf.EventPostBuild.Add(postBuildCommandToCopyFfmpegBinaries);
|
|
conf.EventPostBuild.Add(postBuildCommandToCopyToolsFolderToOutput);
|
|
conf.EventPostBuild.Add(postBuildCopyCommandToCopyKinectConfig);
|
|
conf.EventPostBuild.Add(postBuildCopyCommandToCopyKinectHostConfig);
|
|
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsSolution : SingleProjectSolution<Mars>
|
|
{
|
|
public MarsSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddProject<MarsServer>(target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars");
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsTools : ScoringToolsDotNetApplication
|
|
{
|
|
public MarsTools() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.ReferencesByName.Add("System.Management");
|
|
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
conf.AddPublicDependency<RecMoveExtractor>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsToolsSolution : SingleProjectSolution<MarsTools>
|
|
{
|
|
public MarsToolsSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsTools");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsInterfaces : ScoringToolsDotNetApplication
|
|
{
|
|
public MarsInterfaces() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
// TODO: this needs to be fixed.. the interfaces should not depend on any MARS related projects
|
|
conf.ReferencesByName.Add("System.Runtime.Remoting");
|
|
conf.AddPublicDependency<RecTool>(target);
|
|
conf.AddPublicDependency<MarsTools>(target);
|
|
conf.AddPublicDependency<MSPClassifier>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsInterfacesSolution : SingleProjectSolution<MarsInterfaces>
|
|
{
|
|
public MarsInterfacesSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsInterfaces");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsServer : ScoringToolsDotNetApplication
|
|
{
|
|
public MarsServer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
|
|
{
|
|
StartupObject = "MarsServer.Program";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
conf.ReferencesByName.Add("System.Runtime.Remoting");
|
|
conf.ReferencesByName.Add("System.Xaml");
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
|
|
conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
|
|
conf.RegisterPerforce();
|
|
|
|
|
|
conf.AddPublicDependency<MarsTools>(target);
|
|
conf.AddPublicDependency<MarsInterfaces>(target);
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
conf.AddPublicDependency<MarsRemotingInterfaces>(target);
|
|
conf.AddPublicDependency<RecMoveExtractor>(target);
|
|
conf.AddPublicDependency<TmlDtapeMoveExtractor>(target);
|
|
conf.AddPublicDependency<TmlMoveExtractor>(target);
|
|
conf.AddPublicDependency<TplMoveExtractor>(target);
|
|
|
|
var projectConfigurationFiles = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Projects");
|
|
var postBuildEventCommand = "xcopy /E /Y /D \"" + projectConfigurationFiles + "\" \"$(TargetDir)Projects\\\"";
|
|
conf.EventPostBuild.Add(postBuildEventCommand);
|
|
|
|
conf.TargetPath = ScoringToolsOuptutPath;
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsServerSolution : SingleProjectSolution<MarsServer>
|
|
{
|
|
public MarsServerSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsServer");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsRemotingInterfaces : ScoringToolsDotNetApplication
|
|
{
|
|
public MarsRemotingInterfaces() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MarsTools>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MarsRemotingInterfacesSolution : SingleProjectSolution<MarsRemotingInterfaces>
|
|
{
|
|
public MarsRemotingInterfacesSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsRemotingInterfaces");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MoveSpaceTool : ScoringToolsDotNetApplication
|
|
{
|
|
public MoveSpaceTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MoveSpaceToolSolution : SingleProjectSolution<MoveSpaceTool>
|
|
{
|
|
public MoveSpaceToolSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpaceTool");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPClassifier : ScoringToolsDotNetApplication
|
|
{
|
|
public MSPClassifier() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MoveSpaceTool>(target);
|
|
conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");
|
|
conf.AddPublicDependency<MSPStats>(target);
|
|
conf.AddPublicDependency<MSPMatrixVector>(target);
|
|
conf.AddPublicDependency<RecMoveExtractor>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPClassifierSolution : SingleProjectSolution<MSPClassifier>
|
|
{
|
|
public MSPClassifierSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPClassifier");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class MoveReaderInterface : ScoringToolsDotNetApplication
|
|
{
|
|
public MoveReaderInterface() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MoveReaderInterfaceSolution : SingleProjectSolution<MoveReaderInterface>
|
|
{
|
|
public MoveReaderInterfaceSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveReaderInterface");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPMatrixVector : ScoringToolsDotNetApplication
|
|
{
|
|
public MSPMatrixVector() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPMatrixVectorSolution : SingleProjectSolution<MSPMatrixVector>
|
|
{
|
|
public MSPMatrixVectorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPMatrixVector");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPStats : ScoringToolsDotNetApplication
|
|
{
|
|
public MSPStats() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MSPMatrixVector>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MSPStatsSolution : SingleProjectSolution<MSPStats>
|
|
{
|
|
public MSPStatsSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPStats");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class RecTool : ScoringToolsDotNetApplication
|
|
{
|
|
public RecTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class RecToolSolution : SingleProjectSolution<RecTool>
|
|
{
|
|
public RecToolSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "RecTool");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class RecMoveExtractor : ScoringToolsDotNetApplication
|
|
{
|
|
public RecMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
conf.AddPublicDependency<RecTool>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class RecMoveExtractorSolution : SingleProjectSolution<RecMoveExtractor>
|
|
{
|
|
public RecMoveExtractorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "RecMoveExtractor");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TmlDtapeMoveExtractor : ScoringToolsDotNetApplication
|
|
{
|
|
public TmlDtapeMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<LuaMoveExtractor>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TmlDtapeMoveExtractorSolution : SingleProjectSolution<TmlDtapeMoveExtractor>
|
|
{
|
|
public TmlDtapeMoveExtractorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TmlDtapeMoveExtractor");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TmlMoveExtractor : ScoringToolsDotNetApplication
|
|
{
|
|
public TmlMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TmlMoveExtractorSolution : SingleProjectSolution<TmlMoveExtractor>
|
|
{
|
|
public TmlMoveExtractorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TmlMoveExtractor");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TplMoveExtractor : ScoringToolsDotNetApplication
|
|
{
|
|
public TplMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddPublicDependency<LuaMoveExtractor>(target);
|
|
conf.AddPublicDependency<MoveReaderInterface>(target);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class TplMoveExtractorSolution : SingleProjectSolution<TplMoveExtractor>
|
|
{
|
|
public TplMoveExtractorSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TplMoveExtractor");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class WebmPlayer : ScoringToolsDotNetApplication
|
|
{
|
|
public WebmPlayer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
OutputType = Configuration.OutputType.DotNetClassLibrary;
|
|
ResourcesPath = SourceRootPath + @"\Resources\";
|
|
ResourceFilesExtensions.Add(".exe");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
|
|
conf.ReferencesByNuGetPackage.Add(Externs.FfmeWindows);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class WebmPlayerSolution : SingleProjectSolution<WebmPlayer>
|
|
{
|
|
public WebmPlayerSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WebmPlayer");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class WiiULauncherAPI : ScoringToolsDotNetApplication
|
|
{
|
|
public WiiULauncherAPI() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class WiiULauncherAPISolution : SingleProjectSolution<WiiULauncherAPI>
|
|
{
|
|
public WiiULauncherAPISolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WiiULauncherAPI");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class NotifyIconWpf : ScoringToolsDotNetApplication
|
|
{
|
|
public NotifyIconWpf() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
OutputType = Configuration.OutputType.DotNetClassLibrary;
|
|
ResourceFiles.Add("DefaultTrayIcon.ico");
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class NotifyIconWpfSolution : SingleProjectSolution<NotifyIconWpf>
|
|
{
|
|
public NotifyIconWpfSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "NotifyIconWpf");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class PS4Recorder : ScoringToolsDotNetApplication
|
|
{
|
|
public PS4Recorder() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.ReferencesByPath.Add(@"C:\Program Files (x86)\SCE\ORBIS\Tools\Target Manager Server\bin\Interop.ORTMAPILib.dll");
|
|
var PS4StudioDllPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "bin", "PS4Studio.dll");
|
|
conf.ReferencesByPath.Add(PS4StudioDllPath);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class PS4RecorderSolution : SingleProjectSolution<PS4Recorder>
|
|
{
|
|
public PS4RecorderSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "PS4Recorder");
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class WaveformView : ScoringToolsDotNetApplication
|
|
{
|
|
public WaveformView() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
|
|
{
|
|
OutputType = Configuration.OutputType.DotNetClassLibrary;
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.ReferencesByName.Add("System.Drawing");
|
|
conf.ReferencesByName.Add("System.xaml");
|
|
|
|
conf.ReferencesByPath.Add(Externs.NAudio);
|
|
conf.ReferencesByPath.Add(Externs.NAudioWindowMediaFormat);
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class WaveformViewSolution : SingleProjectSolution<WaveformView>
|
|
{
|
|
public WaveformViewSolution()
|
|
{
|
|
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WaveformView");
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
class MoveSpaceScoringTools : ScoringToolLibrary
|
|
{
|
|
public MoveSpaceScoringTools()
|
|
{
|
|
RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpace");
|
|
SourceRootPath = RootPath;
|
|
SourceFilesExcludeRegex.Add(".cs");
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.Options.Remove(Options.Vc.General.TreatWarningsAsErrors.Enable);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
|
|
conf.If(Platform.orbis | Platform.nx).AdditionalCompilerOptions.Add(" -w");
|
|
|
|
conf.IncludePaths.Add(RootPath + "/Includes");
|
|
conf.IncludePaths.Add(RootPath);
|
|
|
|
conf.SolutionFolder = "apps/Mars";
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
class MoveSpaceWrapper : ScoringToolDynamicLib
|
|
{
|
|
public MoveSpaceWrapper()
|
|
{
|
|
RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpaceWrapper");
|
|
SourceRootPath = RootPath;
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.Options.Remove(Options.Vc.General.TreatWarningsAsErrors.Enable);
|
|
conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
|
|
|
|
conf.If(Platform.orbis | Platform.nx).AdditionalCompilerOptions.Add(" -w");
|
|
|
|
conf.IncludePaths.Add(RootPath + "/Includes");
|
|
conf.IncludePaths.Add(RootPath);
|
|
|
|
conf.AddPublicDependency<MoveSpaceScoringTools>(target);
|
|
|
|
conf.SolutionFolder = "apps/Mars";
|
|
conf.TargetFileName = conf.ProjectName;
|
|
}
|
|
}
|
|
|
|
|
|
[Generate]
|
|
internal class JoyConCapturer : BaseCppProject
|
|
{
|
|
public JoyConCapturer()
|
|
{
|
|
RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "JoyConCapturer");
|
|
OutputType = Configuration.OutputType.Exe;
|
|
Name = "JoyConCapturer";
|
|
ClearTargets();
|
|
AddTargets(new BaseCppTarget(Platform.nx,
|
|
DevEnv.vs2015 | DevEnv.vs2017,
|
|
Optimization.Debug | Optimization.Release,
|
|
Sharpmake.OutputType.Lib, ApplicationType.Standalone));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, BaseCppTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.TargetFileName = "JoyConCapturer";
|
|
conf.TargetPath = OutputPath + @"\bin\[conf.Name]\Tools\ScoringTools\[project.Name]\";
|
|
}
|
|
}
|
|
|
|
[Generate]
|
|
public class JoyConCapturerSolution : BaseCppSolution
|
|
{
|
|
public static readonly string ToolsPath = Globals.BranchRoot + @"tools\";
|
|
|
|
public static readonly string ScoringToolsApplicationsPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "JoyConCapturer");
|
|
|
|
public JoyConCapturerSolution()
|
|
{
|
|
Name = "JoyConCapturer";
|
|
ClearTargets();
|
|
AddTargets(new BaseCppTarget(Platform.nx,
|
|
DevEnv.vs2015 | DevEnv.vs2017,
|
|
Optimization.Debug | Optimization.Release,
|
|
Sharpmake.OutputType.Lib, ApplicationType.Standalone));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, BaseCppTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddProject<JoyConCapturer>(target);
|
|
conf.SolutionPath = ScoringToolsApplicationsPath;
|
|
}
|
|
}
|
|
|
|
//*************************** MANAGED CODE Solution*******************************
|
|
///
|
|
/// Creates the solution for all the .NET based applications used in the scoring pipeline
|
|
///
|
|
|
|
[Generate]
|
|
public class ManagedScoringTools : BaseSolution
|
|
{
|
|
public ManagedScoringTools()
|
|
{
|
|
Name = "ManagedScoringTools";
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, Target target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
|
|
conf.RegisterProjectsOfType<ScoringToolsDotNetApplication>(target);
|
|
conf.SolutionFileName = "ManagedScoringTools";
|
|
conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools");
|
|
}
|
|
}
|
|
|
|
|
|
//*************************** UNMANAGED CODE Solution*******************************
|
|
[Generate]
|
|
public class UnManagedScoringTools : BaseCppSolutionGeneric<ScoringToolsTarget>
|
|
{
|
|
public UnManagedScoringTools()
|
|
{
|
|
Name = "UnManagedScoringTools";
|
|
ClearTargets();
|
|
AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
|
|
Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
|
|
}
|
|
|
|
public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
|
|
{
|
|
base.ConfigureAll(conf, target);
|
|
conf.AddProject<MoveSpaceScoringTools>(target); // we have one more project which is same as
|
|
conf.AddProject<MoveSpaceWrapper>(target);
|
|
|
|
conf.SolutionFileName = "UnManagedScoringTools";
|
|
conf.SolutionPath = Path.Combine(RootPath, "tools", "apps", "ScoringTools");
|
|
}
|
|
}
|
|
} |