public void ApplyEnv(EnvConfig env)
{
switch (Biome)
{
case MapGenBiome.Arctic:
env.CloudColor = "#8E8E8E";
env.SkyColor = "#8E8E8E";
env.FogColor = "#AFAFAF";
break;
case MapGenBiome.Desert:
env.CloudColor = "#FFEE88";
env.SkyColor = "#FFEE88";
env.FogColor = "#FFEE88";
env.HorizonBlock = Block.Sand;
break;
case MapGenBiome.Hell:
env.CloudColor = "#000000";
env.SkyColor = "#FFCC00";
env.FogColor = "#FF6600";
env.HorizonBlock = Block.StillLava;
break;
// TODO swamp env
}
}
public static void TestDotNetCoreProjects(ICakeContext context, TaskConfig config)
{
DotNetCoreConfig dotNetCoreConfig = config.Load <DotNetCoreConfig>();
DotNetCoreConfig.TestConfig test = dotNetCoreConfig.Test;
DotNetCoreConfig.CoverageConfig coverage = dotNetCoreConfig.Coverage;
if (test.Skip)
{
context.LogInfo("Skipping tests.");
return;
}
EnvConfig env = config.Load <EnvConfig>();
string testProjectFile = test.ProjectFile;
if (testProjectFile is null)
{
throw new TaskConfigException("Build solution or project file not specified.");
}
var coverletSettings = new CoverletSettings
{
CollectCoverage = true,
CoverletOutputFormat = CoverletOutputFormat.opencover,
CoverletOutputDirectory = Path.Combine(env.Directories.TestOutput, "coverage"),
};
IList <string> excludeFilters = coverage.ExcludeFilters;
if (excludeFilters.Count > 0)
{
coverletSettings.Exclude = excludeFilters.ToList();
}
IList <string> includeFilters = coverage.IncludeFilters;
if (includeFilters.Count > 0)
{
coverletSettings.Include = includeFilters.ToList();
}
var settings = new DotNetCoreTestSettings
{
Configuration = env.Configuration,
OutputDirectory = Path.Combine(env.Directories.BinaryOutput, "__build"),
Logger = test.Logger ?? "trx",
ResultsDirectory = Path.Combine(env.Directories.TestOutput, "testresults"),
NoBuild = true,
NoRestore = true,
Verbosity = context.Log.Verbosity.ToVerbosity(),
};
string filter = test.Filter;
if (!string.IsNullOrWhiteSpace(filter))
{
settings.Filter = filter;
}
context.DotNetCoreTest(testProjectFile, settings, coverletSettings);
}
public static void AddMembershipReboot(this IServiceCollection services, EnvConfig config)
{
// any middleware or component that uses DI to inject an instance of UserAccountService<HierarchicalUserAccount>
// should instead depend on either AdminUserAccountServiceContainer, or DefaultUserAccountServiceContainer
services.AddScoped(provider =>
{
MembershipRebootSetup setup = MembershipRebootConfigFactory.GetAdminConfig(provider.GetService <IApplicationEnvironment>(), provider.GetRequiredService <ILoggerFactory>(), config);
var repository = provider.GetRequiredService <IUserAccountRepository <HierarchicalUserAccount> >();
return(new AdminUserAccountServiceContainer
{
Service = new UserAccountService <HierarchicalUserAccount>(setup, repository)
});
});
services.AddScoped(provider =>
{
MembershipRebootSetup setup = MembershipRebootConfigFactory.GetDefaultConfig(provider.GetService <IApplicationEnvironment>(), provider.GetRequiredService <ILoggerFactory>(), config);
var repository = provider.GetRequiredService <IUserAccountRepository <HierarchicalUserAccount> >();
return(new DefaultUserAccountServiceContainer
{
Service = new UserAccountService <HierarchicalUserAccount>(setup, repository)
});
});
services.AddScoped(typeof(IUserAccountRepository <HierarchicalUserAccount>), typeof(MongoUserAccountRepository <HierarchicalUserAccount>));
services.AddScoped <IBulkUserRepository <HierarchicalUserAccount>, MongoUserAccountRepository <HierarchicalUserAccount> >();
services.AddAuthentication(sharedOptions => sharedOptions.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme);
services.AddScoped(provider => new MongoDatabase(config.DB.MembershipReboot));
}
/// <summary>
/// Registers a task that performs final setup of configuration after all plugin-specific
/// config tasks have been run.
/// <para/>
/// This includes:
/// 1. Runs all configuration lambdas from the <c>ConfigureTask</c> methods in the
/// build.cake file.
/// 2. Override configurations with any matching values from the environment.
/// 3. Override configurations with any matching values from the command line.
/// </summary>
/// <param name="envTasks">List of all plugin tasks for the current CI environment.</param>
private void RegisterConfigTask(IReadOnlyList <RegisteredTask> envTasks)
{
CakeTaskBuilder task = RegisterTask(TaskNames.Config)
.Description("Finalizes configurations and displays final configuration values.");
// Create dependency on all plugin configuration tasks.
IEnumerable <RegisteredTask> configTasks = envTasks
.Where(t => t.AttributeType == typeof(ConfigAttribute))
.OrderBy(t => t.Order);
foreach (RegisteredTask configTask in configTasks)
{
task.IsDependentOn(configTask.Name);
}
task.Does(ctx =>
{
TaskConfig config = TaskConfig.Current;
// Run configurations specified in the build.cake file
config.PerformDeferredSetup();
// Override configurations from environment variables
IDictionary <string, string> envVars = ctx.Environment.GetEnvironmentVariables();
foreach (KeyValuePair <string, string> envVar in envVars)
{
if (config.Data.ContainsKey(envVar.Key))
{
config.Data[envVar.Key] = envVar.Value;
}
}
// Override configurations from command line arguments
var keys = config.Data.Keys.ToList();
foreach (string key in keys)
{
if (ctx.Arguments.HasArgument(key))
{
config.Data[key] = ctx.Arguments.GetArgument(key);
}
}
// Display the final configuration values
ctx.LogHighlight("Final Configurations");
ctx.LogHighlight("--------------------");
foreach (KeyValuePair <string, object> data in config.Data.OrderBy(kvp => kvp.Key))
{
ctx.LogHighlight($"{data.Key} = {data.Value?.Dump() ?? "[NULL]"}");
}
EnvConfig env = config.Load <EnvConfig>();
// Clean out output directories or create them
//TODO: Can these directories be created on-demand? For some project types like Angular,
//these folders are ignored and the dist folder is used.
ctx.EnsureDirectoryExists(env.Directories.Artifacts);
ctx.EnsureDirectoryExists(env.Directories.BinaryOutput);
ctx.EnsureDirectoryExists(env.Directories.TestOutput);
});
}
private static void PublishNuGet(ICakeContext ctx, TaskConfig cfg, NuGetPublisher nuget)
{
EnvConfig env = cfg.Load <EnvConfig>();
ctx.DotNetCorePack(nuget.ProjectFile, new DotNetCorePackSettings
{
Configuration = env.Configuration,
OutputDirectory = nuget.OutputLocation,
Verbosity = ctx.Log.Verbosity.ToVerbosity(),
ArgumentCustomization = arg =>
{
arg.Append($"/p:Version={env.Version.Build}");
if (nuget.PublishAsSnupkg)
{
arg.Append("/p:SymbolPackageFormat=snupkg");
}
return(arg);
},
IncludeSource = true,
IncludeSymbols = true,
});
IEnumerable <string> packageFiles = Directory.EnumerateFiles(nuget.OutputLocation,
nuget.PublishAsSnupkg ? "*.snupkg" : "*.nupkg");
foreach (string packageFile in packageFiles)
{
ctx.DotNetCoreNuGetPush(packageFile, new DotNetCoreNuGetPushSettings
{
Source = nuget.Source(env.Branch),
ApiKey = nuget.ApiKey?.Invoke(env.Branch),
});
}
}
public UserController(EnvConfig cfg,
AdminUserAccountServiceContainer container,
IBulkUserRepository <HierarchicalUserAccount> repository)
{
this._cfg = cfg;
this._userAccountService = container.Service;
this._repository = repository;
}
private void StartPublishing()
{
GotoUdonInternalState.Instance.enableAutomaticPublish = true;
EditorUtility.SetDirty(GotoUdonInternalState.Instance);
EnvConfig.ConfigurePlayerSettings();
VRC_SdkBuilder.PreBuildBehaviourPackaging();
VRC_SdkBuilder.ExportAndUploadSceneBlueprint();
}
private void InitializeConfiguration()
{
// Setup action to initialize some really core stuff, including directories and version
// details.
RegisterSetupAction(ctx =>
{
Log.Verbose("Initializing Cake.Tasks configuration.");
TaskConfig config = TaskConfig.Current;
EnvConfig env = config.Load <EnvConfig>();
env.Name = Path.GetFileName(ctx.Environment.WorkingDirectory.FullPath)
.Replace('.', '-')
.Replace(' ', '-')
.Replace('_', '-')
.Trim();
env.Configuration = ctx.Arguments.GetArgument("Configuration") ?? "Release";
env.IsCi = false;
env.Branch = null;
env.Directories.Working = ctx.Environment.WorkingDirectory.FullPath;
string outputDirectory = Path.Combine(env.Directories.Working, ".ci");
env.Directories.Artifacts = Path.Combine(outputDirectory, "artifacts");
env.Directories.BinaryOutput = Path.Combine(outputDirectory, "binaries");
env.Directories.PublishOutput = Path.Combine(outputDirectory, "publish");
env.Directories.TestOutput = Path.Combine(outputDirectory, "testresults");
env.Version.BuildNumber = "1";
env.Version.Primary = (Func <string>)(() => $"0.{env.Version.BuildNumber.Resolve()}.0");
env.Version.Full = (Func <string>)(() => env.Version.Primary.Resolve());
env.Version.Build = (Func <string>)(() => $"{env.Version.Full.Resolve()}+{env.Version.BuildNumber.Resolve()}");
// Display the subdirectories under the tools/Addins directory.
// To verify the versions of the addins and tools installed.
// Useful for troubleshooting.
//TODO: Make this a configuration
ctx.LogHighlight("--------------------");
ctx.LogHighlight("Addin subdirectories");
ctx.LogHighlight("--------------------");
string addinsBaseDir = Path.Combine(env.Directories.Working, "tools", "Addins");
if (Directory.Exists(addinsBaseDir))
{
IEnumerable <string> addinsDirs = AddinFinder.Find(addinsBaseDir);
IEnumerable <string> otherDirs = Directory.EnumerateDirectories(addinsBaseDir, "*", SearchOption.TopDirectoryOnly)
.Except(addinsDirs, StringComparer.OrdinalIgnoreCase);
foreach (string addinsDir in addinsDirs)
{
ctx.LogHighlight(Path.GetFileName(addinsDir));
}
foreach (string otherDir in otherDirs)
{
ctx.Log.Information(Path.GetFileName(otherDir));
}
}
return(config);
});
}
public void CopyTo(EnvConfig config)
{
if (config.name != "Release")
{
config.serverHost = serverHost;
config.testEndOfGameMode = testEndOfGameMode;
config.internetPvpBotMode = internetPvpBotMode;
}
}
private static void CheckHealth(EnvConfig config, ILogger logger)
{
// TODO: trace log correctly
logger.LogInformation("Checking Health... ");
HealthContext.CurrentStatus = CheckUserDatabaseStatus(config);
logger.LogInformation(HealthContext.CurrentStatus + Environment.NewLine);
}
private static bool CheckFogSettings()
{
EnvConfig.FogSettings fogSettings = EnvConfig.GetFogSettings();
if (fogSettings.fogStrippingMode == EnvConfig.FogSettings.FogStrippingMode.Automatic)
{
return(false);
}
return(fogSettings.keepLinear || fogSettings.keepExp || fogSettings.keepExp2);
}
private void BuildAndTest()
{
EnvConfig.ConfigurePlayerSettings();
VRC_SdkBuilder.shouldBuildUnityPackage = false;
AssetExporter.CleanupUnityPackageExport(); // force unity package rebuild on next publish
VRC_SdkBuilder.RunSetNumClients(0);
VRC_SdkBuilder.forceNoVR = true;
VRC_SdkBuilder.PreBuildBehaviourPackaging();
VRC_SdkBuilder.RunExportSceneResourceAndRun();
StartClients();
}
public static void ConfigureDotNetCore(TaskConfig config)
{
DotNetCoreConfig cfg = config.Load <DotNetCoreConfig>();
EnvConfig env = config.Load <EnvConfig>();
string workingDirectory = env.Directories.Working ?? Directory.GetCurrentDirectory();
cfg.Build.ProjectFile = (Func <string>)(() => GetBuildProjectFile(workingDirectory));
cfg.Test.Skip = false;
cfg.Test.ProjectFile = (Func <string>)(() => GetBuildProjectFile(workingDirectory));
cfg.Test.Logger = "trx";
private static void PublishAspNetCore(ICakeContext ctx, TaskConfig cfg, AspNetCorePublisher publisher)
{
EnvConfig env = cfg.Load <EnvConfig>();
ctx.DotNetCorePublish(publisher.ProjectFile, new DotNetCorePublishSettings
{
Configuration = env.Configuration,
OutputDirectory = publisher.OutputLocation,
Verbosity = ctx.Log.Verbosity.ToVerbosity(),
ArgumentCustomization = arg => arg.Append($"/p:Version={env.Version.Build}"),
});
}
public TestDatabaseManager()
{
EnvConfig = new EnvConfig();
var dbCfg = new DatabaseConfig(EnvConfig);
DbContextProvider = new DbContextProvider(dbCfg);
CreateTableScriptsProvider = new CreateTableScriptsProvider();
DatabaseDirectoryManager = new DatabaseDirectoryManager(dbCfg);
CreateDatabase = new CreateDatabase(dbCfg, DatabaseDirectoryManager, CreateTableScriptsProvider.GetScripts());
DropDatabase = new DropDatabase(dbCfg);
}
public static void ScheduleHealthCheck(EnvConfig config, ILoggerFactory logFactory)
{
ILogger logger = logFactory.CreateLogger(typeof(HealthChecker).ToString());
var r = new Registry();
r.Schedule(() =>
{
CheckHealth(config, logger);
}).ToRunNow().AndEvery(30).Seconds();
TaskManager.UnobservedTaskException += TaskManager_UnobservedTaskException;
TaskManager.Initialize(r);
}
public ServerAPI(ConfigsProvider configsProvider, SignalBus signalBus)
{
envConfig = configsProvider.Get <EnvConfig>();
tokenKey = "ServerAPI.playerToken" + (envConfig.IsLocal ? ".local" : "");
this.signalBus = signalBus;
this.signalBus.Subscribe <PlayerActionSignal>(signal =>
{
if (!string.IsNullOrEmpty(signal.Data.token))
{
UserToken = signal.Data.token;
}
});
}
public static void SetDirectoryPublisherOutputs(ICakeContext ctx, TaskConfig cfg)
{
EnvConfig env = cfg.Load <EnvConfig>();
var directoryPublishers = env.Publishers.OfType <DirectoryPublisher>().ToList();
foreach (DirectoryPublisher publisher in directoryPublishers)
{
publisher.ValidateDirectory();
string directory = Path.Combine(env.Directories.Working, publisher.Directory);
publisher.SetOutput(directory);
}
}
public static void ConfigureProjectNameFromGitRepoUrl(ICakeContext ctx, TaskConfig cfg)
{
EnvConfig env = cfg.Load <EnvConfig>();
string gitDir = Path.Combine(env.Directories.Working, ".git");
if (!Directory.Exists(gitDir))
{
ctx.LogInfo($"Working directory '{env.Directories.Working}' is not a Git repository. Cannot calculate project name from it.");
return;
}
string fetchHeadFile = Path.Combine(gitDir, "FETCH_HEAD");
if (!File.Exists(fetchHeadFile))
{
ctx.LogInfo("Cannot retrieve remote URL for current repo.");
return;
}
using StreamReader reader = File.OpenText(fetchHeadFile);
string firstLine = reader.ReadLine();
Match match = RemoteUrlPattern.Match(firstLine);
if (!match.Success)
{
ctx.LogInfo("Cannot retrieve remote URL for current repo.");
return;
}
string matchedRemoteUri = match.Groups[1].Value;
if (!Uri.TryCreate(matchedRemoteUri, UriKind.Absolute, out Uri remoteUri))
{
ctx.LogInfo("Cannot retrieve remote URL for current repo.");
return;
}
const string ignoreExtension = ".git";
string lastSegment = remoteUri.Segments[remoteUri.Segments.Length - 1];
if (lastSegment.EndsWith(ignoreExtension, StringComparison.OrdinalIgnoreCase))
{
lastSegment = lastSegment.Substring(0, lastSegment.Length - ignoreExtension.Length);
}
ctx.LogInfo($"Setting project name to {lastSegment}.");
env.Name = lastSegment;
}
public static void ConfigureAppVeyorEnvironment(ICakeContext ctx, TaskConfig cfg)
{
IAppVeyorProvider appveyor = ctx.AppVeyor();
if (!appveyor.IsRunningOnAppVeyor)
{
throw new TaskConfigException("Not running in AppVeyor");
}
EnvConfig env = cfg.Load <EnvConfig>();
env.IsCi = true;
env.Version.BuildNumber = appveyor.Environment.Build.Number.ToString();
env.Version.Build = $"{env.Version.Primary}-build.{env.Version.BuildNumber}";
}
internal static bool Handle(Player p, Level lvl, string type, string value, EnvConfig cfg, string area)
{
if (type.CaselessEq("preset"))
{
EnvPreset preset = FindPreset(value);
if (preset == null)
{
MessagePresets(p); return(false);
}
cfg.SkyColor = preset.Sky;
cfg.CloudColor = preset.Clouds;
cfg.FogColor = preset.Fog;
cfg.ShadowColor = preset.Shadow;
cfg.LightColor = preset.Sun;
}
else if (type.CaselessEq("normal"))
{
cfg.ResetEnv();
p.Message("Reset environment for {0} %Sto normal", area);
}
else
{
EnvOption opt = EnvOptions.Find(type);
if (opt == null)
{
return(false);
}
opt.SetFunc(p, area, cfg, value);
}
if (lvl == null)
{
Player[] players = PlayerInfo.Online.Items;
foreach (Player pl in players)
{
pl.SendCurrentEnv();
}
SrvProperties.Save();
}
else
{
SendEnv(lvl);
lvl.SaveSettings();
}
return(true);
}
public static void PublishDotNetProjects(ICakeContext ctx, TaskConfig config)
{
EnvConfig env = config.Load <EnvConfig>();
IList <DotNetCorePublisher> publishers = env.Publishers.OfType <DotNetCorePublisher>().ToList();
if (publishers.Count == 0)
{
ctx.LogInfo("No .NET Core projects to publish. Specify a publisher.");
}
foreach (DotNetCorePublisher publisher in publishers)
{
string publishDirectory = Path.Combine(env.Directories.PublishOutput,
publisher.GetType().Name + Guid.NewGuid().ToString("N"));
if (!Directory.Exists(publishDirectory))
{
Directory.CreateDirectory(publishDirectory);
}
publisher.SetOutput(publishDirectory);
switch (publisher)
{
case AspNetCorePublisher aspnet:
PublishAspNetCore(ctx, config, aspnet);
break;
case NuGetPublisher nuget:
DotNetCoreConfig dnc = config.Load <DotNetCoreConfig>();
if (nuget.Source is null)
{
nuget.Source = dnc.NuGetPublisher.SourceFn;
}
if (nuget.Source is null)
{
nuget.Source = _ => "https: //api.nuget.org/v3/index.json";
}
if (nuget.ApiKey is null)
{
nuget.ApiKey = dnc.NuGetPublisher.ApiKeyFn;
}
PublishNuGet(ctx, config, nuget);
break;
default:
throw new TaskConfigException($"Unrecognized .NET Core publisher type: {publisher.GetType().FullName}.");
}
}
}
public static void ConfigureTfsEnvironment(ICakeContext ctx, TaskConfig cfg)
{
IAzurePipelinesProvider azurePipelines = ctx.AzurePipelines();
ctx.LogInfo(azurePipelines.Dump());
//if (!azurePipelines.IsRunningOnAzurePipelines || !azurePipelines.IsRunningOnAzurePipelinesHosted)
// throw new TaskConfigException("Not running in Azure Pipelines");
EnvConfig env = cfg.Load <EnvConfig>();
env.IsCi = true;
// If the build number is configured as an integer, use it. Otherwise use the build ID.
// Basically, we need something unique.
env.Version.BuildNumber = azurePipelines.Environment.Build.Number;
}
public override void Use(Player p, string message, CommandData data)
{
if (message.CaselessEq("preset"))
{
MessagePresets(p); return;
}
Level lvl = null;
EnvConfig cfg = null;
string area = "server";
if (message.CaselessStarts("global "))
{
message = message.Substring("global ".Length);
cfg = Server.Config;
}
else if (message.CaselessStarts("level "))
{
message = message.Substring("level ".Length);
}
// Work on current level by default
if (cfg == null)
{
if (p.IsSuper)
{
p.Message("&WWhen using &T/Env &Wfrom {0}, only &T/Env Global &Wis supported", p.SuperName); return;
}
lvl = p.level; cfg = lvl.Config;
area = lvl.ColoredName;
if (!LevelInfo.Check(p, data.Rank, lvl, "set env settings of this level"))
{
return;
}
}
string[] args = message.SplitSpaces();
string opt = args[0], value = args.Length > 1 ? args[1] : "";
if (!Handle(p, lvl, opt, value, cfg, area))
{
Help(p);
}
}
private static string CheckUserDatabaseStatus(EnvConfig config)
{
try
{
var userStore = new MongoDatabase(config.DB.MembershipReboot);
var repo = new MongoUserAccountRepository <HierarchicalUserAccount>(userStore);
var test = repo.GetAllTenants();
if (!test.Any())
{
return(HealthContext.Warning);
}
return(HealthContext.Good);
}
catch
{
return(HealthContext.Bad);
}
}
public static Action <DataProtectionConfiguration> GetConfiguration(EnvConfig config)
{
// make sure the shared keystore directory exists
if (!Directory.Exists(config.DataProtection.SharedKeystoreDir))
{
Directory.CreateDirectory(config.DataProtection.SharedKeystoreDir);
}
return(new Action <DataProtectionConfiguration>(dataProtectionConfiguration =>
{
string certStoreName = config.DataProtection.CertStoreName;
string certThumbprint = config.DataProtection.CertThumbprint;
Console.WriteLine("DataProtection.CertStoreName: " + certStoreName);
Console.WriteLine("DataProtection.CertThumbprint: " + certThumbprint);
X509Certificate2 sharedDpCert = Certificate.Get(certStoreName, certThumbprint);
dataProtectionConfiguration.SetApplicationName(config.DataProtection.AppName);
dataProtectionConfiguration.PersistKeysToFileSystem(new DirectoryInfo(config.DataProtection.SharedKeystoreDir));
dataProtectionConfiguration.ProtectKeysWithCertificate(sharedDpCert);
}));
}
public static void StartTest(GameObject go)
{
GetAllScenes(out loadedScenes);
#if UNITY_EDITOR
originalActiveScene = EditorSceneManager.GetActiveScene();
EditorSceneManager.SaveOpenScenes();
EnvConfig.SetVRSDKs(new string[] { "OpenVR", "Oculus", "None" });
EditorApplication.isPlaying = true;
testScene = EditorSceneManager.OpenScene("Assets/VRCTest/Scenes/AvatarTest.unity", OpenSceneMode.Additive);
#endif
foreach (var scene in loadedScenes)
{
SceneManager.UnloadSceneAsync(scene);
}
var goClone = GameObject.Instantiate(go);
SceneManager.SetActiveScene(testScene);
SceneManager.MoveGameObjectToScene(goClone, testScene);
goClone.name = go.name;
goClone.transform.position = Vector3.zero;
// clear player if we re-run (e.g. oops happened or in dev)
var pGO = GameObject.FindWithTag("Player");
if (pGO != null)
{
Object.DestroyImmediate(pGO);
}
goClone.tag = "Player";
goSafeCopy = goClone;
goSafeCopy.SetActive(false);
var player = new GameObject("Player");
var pctrl = player.AddComponent <VRCTPlayerController>();
pctrl.m_Avatar = goSafeCopy;
SceneManager.MoveGameObjectToScene(player, testScene);
}
public static void ConfigureGitVersion(ICakeContext ctx, TaskConfig cfg)
{
// Update the GitVersion config
GitVersionConfig gitVersion = cfg.Load <GitVersionConfig>();
Common.Tools.GitVersion.GitVersion version = ctx.GitVersion();
gitVersion.Version = version;
EnvConfig env = cfg.Load <EnvConfig>();
// Update branch name
env.Branch = version.BranchName;
// Update primary and full versions
env.Version.Primary = version.MajorMinorPatch;
env.Version.Full = version.SemVer;
// Update build number
env.Version.BuildNumber = version.CommitsSinceVersionSource.HasValue
? version.CommitsSinceVersionSource.Value.ToString()
: version.BuildMetaData;
}
public static void BuildDotNetCoreSolution(ICakeContext context, TaskConfig config)
{
DotNetCoreConfig.BuildConfig build = config.Load <DotNetCoreConfig>().Build;
string buildProjectFile = build.ProjectFile;
if (buildProjectFile is null)
{
throw new TaskConfigException("Build solution or project file not specified.");
}
EnvConfig env = config.Load <EnvConfig>();
string outputDirectory = Path.Combine(env.Directories.BinaryOutput, "__build");
context.DotNetCoreBuild(buildProjectFile, new DotNetCoreBuildSettings
{
OutputDirectory = outputDirectory,
Configuration = env.Configuration,
Verbosity = context.Log.Verbosity.ToVerbosity(),
});
}
void OnGUIScene()
{
GUILayout.Label("", VRCSdkControlPanel.scrollViewSeparatorStyle);
_builderScrollPos = GUILayout.BeginScrollView(_builderScrollPos, false, false, GUIStyle.none,
GUI.skin.verticalScrollbar, GUILayout.Width(VRCSdkControlPanel.SdkWindowWidth),
GUILayout.MinHeight(217));
GUILayout.BeginVertical(VRCSdkControlPanel.boxGuiStyle, GUILayout.Width(VRCSdkControlPanel.SdkWindowWidth));
GUILayout.BeginHorizontal();
GUILayout.BeginVertical(GUILayout.Width(300));
EditorGUILayout.Space();
GUILayout.Label("Local Testing", VRCSdkControlPanel.infoGuiStyle);
GUILayout.Label(
"Before uploading your world you may build and test it in the VRChat client. You won't be able to invite anyone from online but you can launch multiple of your own clients.",
VRCSdkControlPanel.infoGuiStyle);
GUILayout.EndVertical();
GUILayout.BeginVertical(GUILayout.Width(200));
EditorGUILayout.Space();
_numClients = EditorGUILayout.IntField("Number of Clients", _numClients, GUILayout.MaxWidth(190));
EditorGUILayout.Space();
_forceNoVr = EditorGUILayout.Toggle("Force Non-VR", _forceNoVr, GUILayout.MaxWidth(190));
EditorGUILayout.Space();
GUI.enabled = _builder.NoGuiErrorsOrIssues();
string lastUrl = VRC_SdkBuilder.GetLastUrl();
bool lastBuildPresent = lastUrl != null;
if (lastBuildPresent == false)
{
GUI.enabled = false;
}
if (VRCSettings.Get().DisplayAdvancedSettings)
{
if (GUILayout.Button("Last Build"))
{
VRC_SdkBuilder.shouldBuildUnityPackage = false;
VRC_SdkBuilder.SetNumClients(_numClients);
VRC_SdkBuilder.forceNoVR = _forceNoVr;
VRC_SdkBuilder.RunLastExportedSceneResource();
}
if (Core.APIUser.CurrentUser.hasSuperPowers)
{
if (GUILayout.Button("Copy Test URL"))
{
TextEditor te = new TextEditor {
text = lastUrl
};
te.SelectAll();
te.Copy();
}
}
}
GUI.enabled = _builder.NoGuiErrorsOrIssues() ||
Core.APIUser.CurrentUser.developerType == Core.APIUser.DeveloperType.Internal;
#if UNITY_ANDROID
EditorGUI.BeginDisabledGroup(true);
#endif
if (GUILayout.Button("Build & Test"))
{
bool buildTestBlocked = !VRCBuildPipelineCallbacks.OnVRCSDKBuildRequested(VRCSDKRequestedBuildType.Scene);
if (!buildTestBlocked)
{
#if VRC_SDK_VRCSDK2
EnvConfig.ConfigurePlayerSettings();
VRC_SdkBuilder.shouldBuildUnityPackage = false;
AssetExporter.CleanupUnityPackageExport(); // force unity package rebuild on next publish
VRC_SdkBuilder.SetNumClients(_numClients);
VRC_SdkBuilder.forceNoVR = _forceNoVr;
VRC_SdkBuilder.PreBuildBehaviourPackaging();
VRC_SdkBuilder.ExportSceneResourceAndRun();
#elif VRC_SDK_VRCSDK3
EnvConfig.ConfigurePlayerSettings();
VRC_SdkBuilder.shouldBuildUnityPackage = false;
AssetExporter.CleanupUnityPackageExport(); // force unity package rebuild on next publish
VRC_SdkBuilder.SetNumClients(_numClients);
VRC_SdkBuilder.forceNoVR = _forceNoVr;
VRC_SdkBuilder.PreBuildBehaviourPackaging();
VRC_SdkBuilder.ExportSceneResourceAndRun();
#endif
}
}
#if UNITY_ANDROID
EditorGUI.EndDisabledGroup();
#endif
GUILayout.EndVertical();
if (Event.current.type != EventType.Used)
{
GUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.EndVertical();
}
EditorGUILayout.Space();
GUILayout.BeginVertical(VRCSdkControlPanel.boxGuiStyle, GUILayout.Width(VRCSdkControlPanel.SdkWindowWidth));
GUILayout.BeginHorizontal();
GUILayout.BeginVertical(GUILayout.Width(300));
EditorGUILayout.Space();
GUILayout.Label("Online Publishing", VRCSdkControlPanel.infoGuiStyle);
GUILayout.Label(
"In order for other people to enter your world in VRChat it must be built and published to our game servers.",
VRCSdkControlPanel.infoGuiStyle);
EditorGUILayout.Space();
GUILayout.EndVertical();
GUILayout.BeginVertical(GUILayout.Width(200));
EditorGUILayout.Space();
if (lastBuildPresent == false)
{
GUI.enabled = false;
}
if (VRCSettings.Get().DisplayAdvancedSettings)
{
if (GUILayout.Button("Last Build"))
{
if (Core.APIUser.CurrentUser.canPublishWorlds)
{
EditorPrefs.SetBool("VRC.SDKBase_StripAllShaders", false);
VRC_SdkBuilder.shouldBuildUnityPackage = VRCSdkControlPanel.FutureProofPublishEnabled;
VRC_SdkBuilder.UploadLastExportedSceneBlueprint();
}
else
{
VRCSdkControlPanel.ShowContentPublishPermissionsDialog();
}
}
}
GUI.enabled = _builder.NoGuiErrorsOrIssues() ||
Core.APIUser.CurrentUser.developerType == Core.APIUser.DeveloperType.Internal;
if (GUILayout.Button(VRCSdkControlPanel.GetBuildAndPublishButtonString()))
{
bool buildBlocked = !VRCBuildPipelineCallbacks.OnVRCSDKBuildRequested(VRCSDKRequestedBuildType.Scene);
if (!buildBlocked)
{
if (Core.APIUser.CurrentUser.canPublishWorlds)
{
EnvConfig.ConfigurePlayerSettings();
EditorPrefs.SetBool("VRC.SDKBase_StripAllShaders", false);
VRC_SdkBuilder.shouldBuildUnityPackage = VRCSdkControlPanel.FutureProofPublishEnabled;
VRC_SdkBuilder.PreBuildBehaviourPackaging();
VRC_SdkBuilder.ExportAndUploadSceneBlueprint();
}
else
{
VRCSdkControlPanel.ShowContentPublishPermissionsDialog();
}
}
}
GUILayout.EndVertical();
GUI.enabled = true;
if (Event.current.type == EventType.Used)
{
return;
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndScrollView();
}
