public extern static int clGetPlatformInfo ( IntPtr platform, PlatformInfo param_name, IntPtr param_value_size, byte[] param_value, out IntPtr param_value_size_ret );
public override void SetUp ()
{
base.SetUp ();
ServiceContainer.Register<IPlatformInfo> (platformInfo = new PlatformInfo ());
ServiceContainer.Register<ISettingsStore> (settingStore = new SettingStore ());
upgradeManager = new UpgradeManger ();
}
/// <summary>
/// Returns Information about a specific Platform
/// </summary>
/// <returns></returns>
public static OpenCLErrorCode GetPlatformInfo(PlatformHandle platformId,
PlatformInfo paramName,
IntPtr paramValueBufferSize,
InfoBuffer paramValue,
out IntPtr paramValueSize)
{
return clGetPlatformInfo((platformId as IHandleData).Handle, paramName, paramValueBufferSize, paramValue.Address, out paramValueSize);
}
private string GetSystemAssemblyPath(PlatformInfo platformInfo, string systemAssemblyName)
{
foreach (FileSystemPath systemAssemblyFolder in platformInfo.GetSystemAssemblyFolders())
{
string pathForTring = Path.Combine(systemAssemblyFolder.ToString(), systemAssemblyName + ".dll");
if (File.Exists(pathForTring))
return pathForTring;
}
throw new ArgumentException("Assembly does not exissts in system directories", "systemAssemblyName");
}
private void OnClear()
{
string platformName = m_drawer.GetSelectedPlatformName();
PlatformInfo platform = PlatformEditorUtility.GetPlatform(platformName);
if (DefinesEditorSettings.PlatformSettings.TryGetSettings(platform.BuildTargetGroup, out DefinesSettings settings))
{
DefinesBuildEditorUtility.ClearDefinesAll(platform.BuildTargetGroup, settings);
AssetDatabase.SaveAssets();
}
}
protected MvvmApplication(Action <IModuleContext> loadModulesDelegate = null, LoadMode?mode = null)
{
if (ServiceProvider.UiSynchronizationContextField == null)
{
ServiceProvider.UiSynchronizationContextField = SynchronizationContext.Current;
}
_loadModulesDelegate = loadModulesDelegate;
_mode = mode;
_platform = PlatformInfo.Unknown;
_context = new DataContext();
ServiceProvider.Initialize(this);
}
protected void Initialize([NotNull] IMvvmApplication application, [NotNull] IIocContainer iocContainer,
PlatformInfo platform, params Assembly[] assemblies)
{
Should.NotBeNull(application, nameof(application));
Should.NotBeNull(iocContainer, nameof(iocContainer));
application.Initialize(platform ?? PlatformInfo.UnitTest, iocContainer, assemblies, DataContext.Empty);
if (ViewModelProvider == null)
{
IViewModelProvider viewModelProvider;
ViewModelProvider = iocContainer.TryGet(out viewModelProvider) ? viewModelProvider : new ViewModelProvider(iocContainer);
}
}
private SortedDictionary <string, string> GetBaseImageDigests(PlatformInfo platform)
{
SortedDictionary <string, string> baseImageDigestMappings = new SortedDictionary <string, string>();
foreach (string fromImage in platform.ExternalFromImages)
{
string digest = this.dockerService.GetImageDigest(fromImage, Options.IsDryRun);
baseImageDigestMappings[fromImage] = digest;
}
return(baseImageDigestMappings);
}
/// <summary>
/// Инициализация привязок для редактирования выбранной платформы
/// </summary>
private void InitEditPlatform(PlatformInfo selectedPlatform)
{
CurrentPlatform = _ctx.GetPlatformByPlatformInfo(selectedPlatform);
platformBindingSource.DataSource = CurrentPlatform;
_manufacturerBeforeEdit = CurrentPlatform.Manufacturer.Name;
_modelNameBeforeEdit = selectedPlatform.Model;
BindAvalibleInterfacesForEdit();
platformBindingSource.ResumeBinding();
}
private bool IsBaseImageDigestUpToDate(PlatformInfo platform, PlatformData srcPlatformData)
{
string currentBaseImageDigest = _imageDigestCache.GetImageDigest(platform.FinalStageFromImage, Options.IsDryRun);
bool baseImageDigestMatches = DockerHelper.GetDigestSha(srcPlatformData.BaseImageDigest)?.Equals(
DockerHelper.GetDigestSha(currentBaseImageDigest), StringComparison.OrdinalIgnoreCase) == true;
_loggerService.WriteMessage();
_loggerService.WriteMessage($"Image info's base image digest: {srcPlatformData.BaseImageDigest}");
_loggerService.WriteMessage($"Latest base image digest: {currentBaseImageDigest}");
_loggerService.WriteMessage($"Base image digests match: {baseImageDigestMatches}");
return(baseImageDigestMatches);
}
private ImageDocumentationInfo(ImageInfo image, PlatformInfo platform, string documentationGroup)
{
Platform = platform;
DocumentedTags = GetDocumentedTags(Platform.Tags, documentationGroup)
.Concat(GetDocumentedTags(image.SharedTags, documentationGroup))
.ToArray();
FormattedDocumentedTags = String.Join(
", ",
DocumentedTags
.Select(tag => tag.Name)
.ToArray());
}
protected void Page_Load(object sender, EventArgs e)
{
RightMgr.getInstance().opCheck("service", Session, Response);
m_res.InnerHtml = "";
if (IsPostBack)
{
m_gen.m_way = m_queryWay.SelectedIndex;
}
else
{
m_queryWay.Items.Add("通过玩家id查询");
m_queryWay.Items.Add("通过账号查询");
m_queryWay.Items.Add("通过订单号查询");
m_platform.Items.Add("###");
for (int i = (int)PaymentType.e_pt_none + 1; i < (int)PaymentType.e_pt_max; i++)
{
PlatformInfo data = ResMgr.getInstance().getPlatformInfo(i);
if (data == null)
{
m_platform.Items.Add("###");
}
else
{
m_platform.Items.Add(data.m_chaName);
}
}
/* m_gameServer.Items.Add("全部");
* Dictionary<string, DbServerInfo> db = ResMgr.getInstance().getAllDb();
* foreach (DbServerInfo info in db.Values)
* {
* m_gameServer.Items.Add(new ListItem(info.m_serverName, info.m_serverId.ToString()));
* }*/
m_rechargeResult.Items.Add("全部");
m_rechargeResult.Items.Add("成功");
m_rechargeResult.Items.Add("失败");
if (m_gen.parse(Request))
{
m_queryWay.SelectedIndex = m_gen.m_way;
m_param.Text = m_gen.m_param;
m_time.Text = m_gen.m_time;
m_platform.SelectedIndex = m_gen.m_platIndex;
m_rechargeResult.SelectedIndex = m_gen.m_result;
m_range.Text = m_gen.m_range;
// m_gameServer.SelectedIndex = m_gen.m_serverIndex;
onQueryRecharge(null, null);
}
}
}
protected void Initialize([NotNull] IMvvmApplication application, [NotNull] IIocContainer iocContainer,
PlatformInfo platform, params Assembly[] assemblies)
{
Should.NotBeNull(application, "application");
Should.NotBeNull(iocContainer, "iocContainer");
ServiceProvider.DesignTimeManager = new DesignTimeManagerImpl(platform);
application.Initialize(platform ?? PlatformInfo.UnitTest, iocContainer, assemblies, DataContext.Empty);
if (ViewModelProvider == null)
{
IViewModelProvider viewModelProvider;
ViewModelProvider = iocContainer.TryGet(out viewModelProvider) ? viewModelProvider : new ViewModelProvider(iocContainer);
}
}
public sealed override async Task <int> Run(PlatformInfo platform, LaunchProperties props)
{
var runCommand = BuildRunCommand(platform, props);
var psi = CreatePSI();
AddRunArguments(psi, runCommand);
var process = Process.Start(psi) ?? throw new Exception("Could not start docker process.");
await process.WaitForExitAsync();
return(process.ExitCode);
}
public static string GetDockerfileCommitUrl(
this IGitService gitService,
PlatformInfo platform,
string sourceRepoUrl,
string sourceBranch = null)
{
string branchOrShaPathSegment = sourceBranch ??
gitService.GetCommitSha(platform.DockerfilePath, useFullHash: true);
string dockerfileRelativePath = PathHelper.NormalizePath(platform.DockerfilePathRelativeToManifest);
return($"{sourceRepoUrl}/blob/{branchOrShaPathSegment}/{dockerfileRelativePath}");
}
private void RemoveOutOfDateContent(ImageArtifactDetails imageArtifactDetails)
{
for (int repoIndex = imageArtifactDetails.Repos.Count - 1; repoIndex >= 0; repoIndex--)
{
RepoData repoData = imageArtifactDetails.Repos[repoIndex];
// Since the registry name is not represented in the image info, make sure to compare the repo name with the
// manifest's repo model name which isn't registry-qualified.
RepoInfo manifestRepo = Manifest.AllRepos.FirstOrDefault(manifestRepo => manifestRepo.Name == repoData.Repo);
// If there doesn't exist a matching repo in the manifest, remove it from the image info
if (manifestRepo is null)
{
imageArtifactDetails.Repos.Remove(repoData);
continue;
}
for (int imageIndex = repoData.Images.Count - 1; imageIndex >= 0; imageIndex--)
{
ImageData imageData = repoData.Images[imageIndex];
ImageInfo manifestImage = imageData.ManifestImage;
// If there doesn't exist a matching image in the manifest, remove it from the image info
if (manifestImage is null)
{
repoData.Images.Remove(imageData);
continue;
}
for (int platformIndex = imageData.Platforms.Count - 1; platformIndex >= 0; platformIndex--)
{
PlatformData platformData = imageData.Platforms[platformIndex];
PlatformInfo manifestPlatform = manifestImage.AllPlatforms
.FirstOrDefault(manifestPlatform => platformData.Equals(manifestPlatform));
// If there doesn't exist a matching platform in the manifest, remove it from the image info
if (manifestPlatform is null)
{
imageData.Platforms.Remove(platformData);
}
}
}
}
if (imageArtifactDetails.Repos.Count == 0)
{
// Failsafe to prevent wiping out the image info due to a bug in the logic
throw new InvalidOperationException(
"Removal of out-of-date content resulted in there being no content remaining in the target image info file. Something is probably wrong with the logic.");
}
}
/// <summary>
/// Loads image info string content as a parsed model.
/// </summary>
/// <param name="imageInfoContent">The image info content to load.</param>
/// <param name="manifest">Representation of the manifest model.</param>
/// <param name="skipManifestValidation">
/// Whether to skip validation if no associated manifest model item was found for a given image info model item.
/// </param>
/// <param name="useFilteredManifest">Whether to use the filtered content of the manifest for lookups.</param>
public static ImageArtifactDetails LoadFromContent(string imageInfoContent, ManifestInfo manifest,
bool skipManifestValidation = false, bool useFilteredManifest = false)
{
ImageArtifactDetails imageArtifactDetails = JsonConvert.DeserializeObject <ImageArtifactDetails>(imageInfoContent);
foreach (RepoData repoData in imageArtifactDetails.Repos)
{
RepoInfo manifestRepo = (useFilteredManifest ? manifest.FilteredRepos : manifest.AllRepos)
.FirstOrDefault(repo => repo.Name == repoData.Repo);
if (manifestRepo == null)
{
Console.WriteLine($"Image info repo not loaded: {repoData.Repo}");
continue;
}
foreach (ImageData imageData in repoData.Images)
{
imageData.ManifestRepo = manifestRepo;
foreach (PlatformData platformData in imageData.Platforms)
{
foreach (ImageInfo manifestImage in (useFilteredManifest ? manifestRepo.FilteredImages : manifestRepo.AllImages))
{
PlatformInfo matchingManifestPlatform = (useFilteredManifest ? manifestImage.FilteredPlatforms : manifestImage.AllPlatforms)
.FirstOrDefault(platform => ArePlatformsEqual(platformData, imageData, platform, manifestImage));
if (matchingManifestPlatform != null)
{
if (imageData.ManifestImage is null)
{
imageData.ManifestImage = manifestImage;
}
platformData.PlatformInfo = matchingManifestPlatform;
platformData.ImageInfo = manifestImage;
break;
}
}
}
PlatformData representativePlatform = imageData.Platforms.FirstOrDefault();
if (!skipManifestValidation && imageData.ManifestImage == null && representativePlatform != null)
{
throw new InvalidOperationException(
$"Unable to find matching platform in manifest for platform '{representativePlatform.GetIdentifier()}'.");
}
}
}
return(imageArtifactDetails);
}
public void BuildingWorksIfAllParametersAreProvided()
{
var version = Version.Parse("1.0");
var platformInfo = new PlatformInfo();
var scheduler = Substitute.For <IScheduler>();
var apiFactory = Substitute.For <IApiFactory>();
var agent = new UserAgent("Some Client", "1.0");
var database = Substitute.For <ITogglDatabase>();
var timeService = Substitute.For <ITimeService>();
var mailService = Substitute.For <IMailService>();
var ratingService = Substitute.For <IRatingService>();
var googleService = Substitute.For <IGoogleService>();
var licenseProvider = Substitute.For <ILicenseProvider>();
var analyticsService = Substitute.For <IAnalyticsService>();
var schedulerProvider = Substitute.For <ISchedulerProvider>();
var platformConstants = Substitute.For <IPlatformConstants>();
var backgroundService = Substitute.For <IBackgroundService>();
var notificationService = Substitute.For <INotificationService>();
var remoteConfigService = Substitute.For <IRemoteConfigService>();
var intentDonationService = Substitute.For <IIntentDonationService>();
var applicationShortcutCreator = Substitute.For <IApplicationShortcutCreator>();
var suggestionProviderContainer = Substitute.For <ISuggestionProviderContainer>();
var privateSharedStorageService = Substitute.For <IPrivateSharedStorageService>();
Action tryingToConstructWithValidParameters = () =>
TogglFoundation
.ForClient(agent, version)
.WithDatabase(database)
.WithScheduler(scheduler)
.WithApiFactory(apiFactory)
.WithTimeService(timeService)
.WithMailService(mailService)
.WithPlatformInfo(platformInfo)
.WithRatingService(ratingService)
.WithGoogleService(googleService)
.WithLicenseProvider(licenseProvider)
.WithAnalyticsService(analyticsService)
.WithBackgroundService(backgroundService)
.WithSchedulerProvider(schedulerProvider)
.WithPlatformConstants(platformConstants)
.WithNotificationService(notificationService)
.WithRemoteConfigService(remoteConfigService)
.WithIntentDonationService(intentDonationService)
.WithApplicationShortcutCreator(applicationShortcutCreator)
.WithPrivateSharedStorageService(privateSharedStorageService)
.WithSuggestionProviderContainer(suggestionProviderContainer)
.Build();
tryingToConstructWithValidParameters.Should().NotThrow();
}
protected void IgnoreOnMonoVersions(params string[] version_strings)
{
if (!PlatformInfo.IsMono)
{
return;
}
var current = PlatformInfo.GetVersion();
var versions = version_strings.Select(x => new Version(x)).ToList();
if (versions.Any(x => x.Major == current.Major && x.Minor == current.Minor))
{
throw new IgnoreException($"Ignored on mono {PlatformInfo.GetVersion()}");
}
}
// 返回平台名称
public string getPlatformName(int index, bool eng = true)
{
PlatformInfo data = getPlatformInfo(index);
if (data == null)
{
return("none");
}
if (eng)
{
return(data.m_engName);
}
return(data.m_chaName);
}
public static string GetPlatformInfoString(IntPtr platformId, PlatformInfo paramName)
{
//get size
uint parmSize;
CheckError(CL.GetPlatformInfo(platformId, paramName, Null, Null, (IntPtr *)&parmSize));
//get value
byte[] value = new byte[parmSize];
fixed(byte *valuePtr = value)
{
CheckError(CL.GetPlatformInfo(platformId, paramName, new IntPtr(&parmSize), new IntPtr(valuePtr), (IntPtr *)NullPtr));
}
return(Encoding.ASCII.GetString(value));
}
private PlatformData?CreatePlatformData(ImageInfo image, PlatformInfo platform)
{
if (Options.ImageInfoOutputPath is null)
{
return(null);
}
PlatformData?platformData = PlatformData.FromPlatformInfo(platform, image);
platformData.SimpleTags = GetPushTags(platform.Tags)
.Select(tag => tag.Name)
.OrderBy(name => name)
.ToList();
return(platformData);
}
/// <summary>
/// Returns a structure containing platform information extracted from the log
/// </summary>
/// <returns></returns>
public PlatformInfo GetPlatformInfo()
{
var Info = new PlatformInfo();
var InfoRegEx = @"LogInit.+OS:\s*(.+?)\s*(\((.+)\))?,\s*CPU:\s*(.+)\s*,\s*GPU:\s*(.+)";
RegexUtil.MatchAndApplyGroups(Content, InfoRegEx, (Groups) =>
{
Info.OSName = Groups[1];
Info.OSVersion = Groups[3];
Info.CPUName = Groups[4];
Info.GPUName = Groups[5];
});
return(Info);
}
protected override void Append(log4net.Core.LoggingEvent loggingEvent)
{
var platformInfo = new PlatformInfo
{
Host = Uri,
Path = QueueName,
Username = UserName,
Password = Password ?? string.Empty
};
var transportLayer = new EmsTransportLayer(platformInfo);
var logMessage = new Message();
logMessage.SetBody <string>(loggingEvent.RenderedMessage);
logMessage.AddHeader("LogLevel", loggingEvent.Level.ToString());
transportLayer.SendMessage(logMessage);
}
public IActionResult Get()
{
var info = new PlatformInfo
{
OsVersion = GetOSVersion(),
AppServiceVersion = GetAppServiceVersion(),
KuduVersion = GetKuduVersion(),
MiddlewareModuleVersion = GetMiddlewareModuleVersion(),
LastReimage = GetLastReimage(),
LastRapidUpdate = GetLastRapidUpdate(),
CurrentStampname = Environment.GetEnvironmentVariable("WEBSITE_CURRENT_STAMPNAME"),
ProcessorName = GetProcessorName()
};
return(Ok(info));
}
protected void LearnPlatforms(XElement specTree)
{
var platformsX = specTree.Elements("platforms").Elements("platform").ToList();
foreach (var platformX in platformsX)
{
var name = platformX.Attribute("name").Value;
platforms[name] = new PlatformInfo()
{
name = name,
protect = platformX.Attribute("protect").Value,
comment = platformX.Attribute("comment").Value,
};
}
}
public Dictionary <Value, Value> GetSymbols(PlatformInfo platform)
{
string versionedArch = platform.Model.Architecture.GetDisplayName(platform.Model.Variant);
Dictionary <Value, Value> symbols = GetSymbols();
symbols["ARCH_SHORT"] = platform.Model.Architecture.GetShortName();
symbols["ARCH_NUPKG"] = platform.Model.Architecture.GetNupkgName();
symbols["ARCH_VERSIONED"] = versionedArch;
symbols["ARCH_TAG_SUFFIX"] = $"-{versionedArch}";
symbols["OS_VERSION"] = platform.Model.OsVersion;
symbols["OS_VERSION_BASE"] = platform.BaseOsVersion;
symbols["OS_VERSION_NUMBER"] = GetOsVersionNumber(platform);
symbols["OS_ARCH_HYPHENATED"] = GetOsArchHyphenatedName(platform);
return(symbols);
}
protected override IMvxNavigationService InitializeNavigationService(IMvxViewModelLocatorCollection collection)
{
analyticsService = new AnalyticsService();
platformInfo = new PlatformInfo {
Platform = Platform.Daneel
};
var loader = CreateViewModelLoader(collection);
Mvx.RegisterSingleton <IMvxViewModelLoader>(loader);
navigationService = new NavigationService(null, loader, analyticsService, platformInfo);
Mvx.RegisterSingleton <IForkingNavigationService>(navigationService);
Mvx.RegisterSingleton <IMvxNavigationService>(navigationService);
return(navigationService);
}
public void SetUp()
{
if (PlatformInfo.IsMono && PlatformInfo.GetVersion() < new Version(5, 8))
{
Assert.Inconclusive("Not supported on Mono < 5.8");
}
Mocker.GetMock <IDiskProvider>()
.Setup(v => v.FileExists(It.IsAny <string>()))
.Returns <string>(s => File.Exists(s));
Mocker.GetMock <IDiskProvider>()
.Setup(v => v.DeleteFile(It.IsAny <string>()))
.Callback <string>(s => File.Delete(s));
Mocker.SetConstant <IPlatformInfo>(Mocker.Resolve <PlatformInfo>());
}
public IReadOnlyDictionary <Value, Value> GetSymbols(PlatformInfo platform)
{
string versionedArch = platform.Model.Architecture.GetDisplayName(platform.Model.Variant);
return(new Dictionary <Value, Value>
{
["ARCH_SHORT"] = platform.Model.Architecture.GetShortName(),
["ARCH_NUPKG"] = platform.Model.Architecture.GetNupkgName(),
["ARCH_VERSIONED"] = versionedArch,
["ARCH_TAG_SUFFIX"] = platform.Model.Architecture != Architecture.AMD64 ? $"-{versionedArch}" : string.Empty,
["OS_VERSION"] = platform.Model.OsVersion,
["OS_VERSION_BASE"] = platform.BaseOsVersion,
["OS_VERSION_NUMBER"] = Regex.Match(platform.Model.OsVersion, @"\d+.\d+").Value,
["OS_ARCH_HYPHENATED"] = GetOsArchHyphenatedName(platform),
["VARIABLES"] = Manifest.Model?.Variables?.ToDictionary(kvp => (Value)kvp.Key, kvp => (Value)kvp.Value)
});
}
private void setUpPlatformInfo(XmlConfigMaker c)
{
XmlConfig cfg = loadXmlConfig("platform.xml", c, false);
int count = cfg.getCount();
for (int i = 0; i < count; i++)
{
List <Dictionary <string, object> > data = cfg.getTable(i.ToString());
PlatformInfo info = new PlatformInfo();
info.m_engName = Convert.ToString(data[0]["eng"]);
info.m_chaName = Convert.ToString(data[0]["cha"]);
info.m_tableName = Convert.ToString(data[0]["table"]);
m_plat.Add(info.m_engName, info);
m_platId.Add(i, info);
}
}
protected MvvmApplication(LoadMode?moduleLoadMode = null, IList <IModule> modules = null, Action <IModuleContext> loadModulesDelegate = null)
{
if (ToolkitServiceProvider.UiSynchronizationContextField == null)
{
ToolkitServiceProvider.UiSynchronizationContextField = SynchronizationContext.Current;
}
_moduleLoadMode = moduleLoadMode;
_applicationState = ApplicationState.Active;
_platform = PlatformInfo.Unknown;
_context = new DataContext();
_loadModulesDelegate = loadModulesDelegate;
if (!modules.IsNullOrEmpty())
{
Modules = modules;
}
ToolkitServiceProvider.Initialize(this);
}
private static void LoadMergeDiffTool()
{
if (PlatformInfo.platform == Platforms.Windows)
{
string programFilesx86, programFilesx64;
PlatformInfo.GetWindowsProgramFilesPath(out programFilesx86, out programFilesx64);
switch (settings.mergeDiffTool)
{
case MergeDiffTools.None: mergeToolPath = null; break;
case MergeDiffTools.Meld: mergeToolPath = programFilesx86 + "\\Meld\\Meld.exe"; break;
case MergeDiffTools.kDiff3: mergeToolPath = programFilesx64 + "\\KDiff3\\kdiff3.exe"; break;
case MergeDiffTools.P4Merge: mergeToolPath = programFilesx64 + "\\Perforce\\p4merge.exe"; break;
case MergeDiffTools.DiffMerge: mergeToolPath = programFilesx64 + "\\SourceGear\\Common\\\\DiffMerge\\sgdm.exe"; break;
}
}
else if (PlatformInfo.platform == Platforms.Mac)
{
mergeToolPath = null;
}
else if (PlatformInfo.platform == Platforms.Linux)
{
mergeToolPath = null;
}
else
{
throw new Exception("Unsported platform: " + PlatformInfo.platform);
}
if (mergeToolPath != null)
{
isMergeToolInstalled = File.Exists(mergeToolPath);
if (!isMergeToolInstalled)
{
DebugLog.LogWarning("Diff/Merge tool not installed: " + mergeToolPath);
}
}
else
{
isMergeToolInstalled = false;
DebugLog.LogWarning("Diff/Merge tool set to none. Some app functions will fail.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XamarinFormsBootstrapperBase" /> class.
/// </summary>
protected XamarinFormsBootstrapperBase()
{
var assembly = TryLoadAssembly(BindingAssemblyName, null);
if (assembly != null)
{
var serviceType = typeof(IPlatformService).GetTypeInfo();
serviceType = assembly.DefinedTypes.FirstOrDefault(serviceType.IsAssignableFrom);
if (serviceType != null)
{
_platformService = (IPlatformService)Activator.CreateInstance(serviceType.AsType());
}
}
_platform = _platformService == null
? XamarinFormsExtensions.GetPlatformInfo()
: _platformService.GetPlatformInfo();
}
public static string GetPlatformInfo(this Platform inPlatform, PlatformInfo inPlatformInfo)
{
IntPtr paramSize;
var tmpErrorCode = OpenCL_PlatformInformation.GetPlatformInfo(inPlatform.Handle, inPlatformInfo, IntPtr.Zero, InfoBuffer.Empty, out paramSize);
if (tmpErrorCode != OpenCLErrorCode.Success)
{
Log.Add(LogType.Warning, $"Could not get platform name size: {tmpErrorCode}");
return " ";
}
using (var buffer = new InfoBuffer(paramSize))
{
tmpErrorCode = OpenCL_PlatformInformation.GetPlatformInfo(inPlatform.Handle, inPlatformInfo, paramSize, buffer, out paramSize);
Log.Add(LogType.Info, $"Platform: {buffer}");
return buffer.ToString();
}
}
void Update()
{
if( bonesInput.CheckRelease() && currentPlatform != null )
{
// if( currentPlatform == null )
// return;
currentPlatform.reference.SetColorState( ColorState.CS_NOTACTIVE);
currentPlatform = null;
// 2 cases:
// - if there is just one platform, then it will become green
// - if there is more, then there will be reassignment to the same color
if( platforms.Count > 0 )
{
platforms[nextPlatformIndex].reference.SetColorState( ColorState.CS_NEXTTOSELECT);
}
return;
}
if( bonesInput.CheckGrab() )
{
if( platforms.Count == 0 )
return;
if( currentPlatform == null )
{
//grab angle here
magicAngle = (bones.Angle+boneAngleAdjustment)*boneAngleFactor;
if(Mathf.Abs(magicAngle)%preciseSnap < preciseSnapRange || Mathf.Abs(magicAngle)%preciseSnap > preciseSnap - preciseSnapRange) {
//here we snap to precise degree angles
magicAngle = MathUtilities.SnapTo(magicAngle, preciseSnap);
} else {
//here we snap to less precise angles
magicAngle = MathUtilities.SnapTo(magicAngle, angleSnapFactor);
}
currentPlatform = platforms[nextPlatformIndex];
try
{
currentPlatform.reference.SetColorState( ColorState.CS_ACTIVE );
}
catch(Exception c)
{
Debug.Log("error appeared");
}
if( platforms.Count > 1 )
{
nextPlatformIndex = nextPlatformIndex + 1 > platforms.Count - 1 ? 0 : nextPlatformIndex + 1;
platforms[nextPlatformIndex].reference.SetColorState( ColorState.CS_NEXTTOSELECT );
}
}
else
{
currentPlatform.reference.SetColorState( ColorState.CS_NOTACTIVE );
currentPlatform = platforms[nextPlatformIndex];
currentPlatform.reference.SetColorState( ColorState.CS_ACTIVE );
if( platforms.Count > 1 )
{
nextPlatformIndex = nextPlatformIndex + 1 > platforms.Count - 1 ? 0 : nextPlatformIndex + 1;
platforms[nextPlatformIndex].reference.SetColorState( ColorState.CS_NEXTTOSELECT );
}
}
}
if( bonesInput.CheckSwitchNextPlatform() )
{
if( platforms.Count < 2 )
return;
platforms[nextPlatformIndex].reference.SetColorState( ColorState.CS_NOTACTIVE );
nextPlatformIndex = nextPlatformIndex + 1 > platforms.Count - 1 ? 0 : nextPlatformIndex + 1;
// skip the platform if it is held
if( currentPlatform != null && platforms[nextPlatformIndex] == currentPlatform )
nextPlatformIndex = nextPlatformIndex + 1 > platforms.Count - 1 ? 0 : nextPlatformIndex + 1;
platforms[nextPlatformIndex].reference.SetColorState( ColorState.CS_NEXTTOSELECT );
}
}
internal extern static unsafe int GetPlatformInfo(IntPtr platform, PlatformInfo param_name, IntPtr param_value_size, IntPtr param_value, [OutAttribute] IntPtr* param_value_size_ret);
private static extern OpenCLErrorCode clGetPlatformInfo(IntPtr platform,
PlatformInfo paramName,
IntPtr paramValueSize,
IntPtr paramValue,
out IntPtr paramValueSizeRet);
public static InfoBuffer GetPlatformInfo(Platform platform, PlatformInfo paramName, out ErrorCode error)
{
return GetInfo(Cl.GetPlatformInfo, platform, paramName, out error);
}
// bone area zone
void OnTriggerEnter( Collider other )
{
if( currentPlatform != null && other.transform == currentPlatform.reference )
{
platforms.Add(currentPlatform);
return;
}
PlatformInfo pinfo = new PlatformInfo();
pinfo.initialAngle = other.transform.rotation.eulerAngles.z;
pinfo.initialScale = other.transform.localScale;
pinfo.reference = other.GetComponent<Platform>();
switch( platforms.Count )
{
case 0:
pinfo.reference.SetColorState( ColorState.CS_NEXTTOSELECT );
nextPlatformIndex = 0;
break;
case 1:
if( platforms.Contains( currentPlatform ) )
{
pinfo.reference.SetColorState( ColorState.CS_NEXTTOSELECT );
nextPlatformIndex = 1;
}
break;
}
platforms.Add(pinfo);
}
public static extern Error clGetPlatformInfo(OpenCLPlatform platform, PlatformInfo param_name, IntPtr param_value_size, [Out] Byte[] param_value, IntPtr param_value_size_ret);
public static Error clGetPlatformInfo(OpenCLPlatform platform, PlatformInfo param_name, IntPtr param_value_size, [Out] Byte[] param_value, IntPtr param_value_size_ret)
{
Console.WriteLine("Calling Error clGetPlatformInfo(OpenCLPlatform platform, PlatformInfo param_name, IntPtr param_value_size, [Out] Byte[] param_value, IntPtr param_value_size_ret)");
return default(Error);
}
void FixedUpdate()
{
Vector3 moveTo = bones.CentralPoint + new Vector3((bones.CentralPoint.x - centralPoint.x)*distancePositionMultiplierX, (bones.CentralPoint.y - centralPoint.y)*distancePositionMultiplierY, 0f);
////Magnet positioning
transform.position = Vector3.MoveTowards(transform.position,
moveTo,
magnetMovementSpeed);
////Magnet rotation
if(bones.Distance > distanceDeadZone){
rotateTowardsAngle = (bones.Angle+boneAngleAdjustment)*boneAngleFactor;
//now we snap the value so it doesn't flicker
if(Mathf.Abs(rotateTowardsAngle)%preciseSnap < preciseSnapRange || Mathf.Abs(rotateTowardsAngle)%preciseSnap > preciseSnap - preciseSnapRange) {
//here we snap to precise degree angles
rotateTowardsAngle = MathUtilities.SnapTo(rotateTowardsAngle, preciseSnap);
} else {
//here we snap to less precise angles
rotateTowardsAngle = MathUtilities.SnapTo(rotateTowardsAngle, angleSnapFactor);
}
}
if ( currentPlatform == null ) return;
// if(!isReleasePlatforms) return;
////Platform Positioning
if ( currentPlatform == null ) return;
// the platform has been deleted somewhere
if ( currentPlatform.reference == null )
{
currentPlatform = null;
return;
}
// if(!isReleasePlatforms) return;
Platform pl = currentPlatform.reference.GetComponentInChildren<Platform>();
if( pl == null )
{
currentPlatform = null;
return;
}
// if (pl.pt == Platform.PlatformType.PT_RAIL)
// {
// float y = currentPlatform.transform.parent.position.y;
//
// ////Platform Positioning
// currentPlatform.transform.parent.position = Vector3.MoveTowards( currentPlatform.transform.parent.position, new Vector3 (transform.position.x, y, transform.position.z), Time.deltaTime * movingSpeed);
// }
///Platform Positioning Constraints
float y = currentPlatform.reference.transform.parent.position.y;
float x = currentPlatform.reference.transform.parent.position.x;
Vector3 startingPos = currentPlatform.reference.transform.parent.position;
switch(pl.pt)
{
case Platform.PlatformType.PT_EZLINE:
Vector3 projectedPos70 = Vector3.MoveTowards( currentPlatform.reference.transform.parent.position, new Vector3 (transform.position.x, transform.position.y, transform.position.z), Time.deltaTime * movingSpeed);
currentPlatform.reference.transform.parent.position = projectedPos70;
currentPlatform.reference.rail.LateUpdate();
break;
case Platform.PlatformType.PT_ORAIL:
case Platform.PlatformType.PT_ORAILPINNED:
Vector3 projectedPos0 = Vector3.MoveTowards( currentPlatform.reference.transform.parent.position, new Vector3 (transform.position.x, y, transform.position.z), Time.deltaTime * movingSpeed);
float railPlatDist0 = Vector3.Distance(pl.rail.transform.position, projectedPos0);
if(railPlatDist0 > pl.rail.transform.localScale.y/2)
currentPlatform.reference.transform.parent.position = startingPos;
else
currentPlatform.reference.transform.parent.position = projectedPos0;
break;
case Platform.PlatformType.PT_VRAIL:
case Platform.PlatformType.PT_VRAILPINNED:
Vector3 projectedPos1 = Vector3.MoveTowards( currentPlatform.reference.transform.parent.position, new Vector3 (x, transform.position.y, transform.position.z), Time.deltaTime * movingSpeed);
float railPlatDist1 = Vector3.Distance(pl.rail.transform.position, projectedPos1);
if(railPlatDist1 > pl.rail.transform.localScale.y)
currentPlatform.reference.transform.parent.position = startingPos;
else
currentPlatform.reference.transform.parent.position = projectedPos1;
break;
case Platform.PlatformType.PT_PINNED:
// currentPlatform.transform.parent = pl.pin.transform;
currentPlatform.reference.transform.parent.position = Vector3.MoveTowards( currentPlatform.reference.transform.parent.position, new Vector3 (x, y, transform.position.z), Time.deltaTime * movingSpeed);
break;
case Platform.PlatformType.PT_CHAINED:
Vector3 projectedPos2 = Vector3.MoveTowards( currentPlatform.reference.transform.parent.position, new Vector3 (transform.position.x, transform.position.y, transform.position.z), Time.deltaTime * movingSpeed);
float pinPlatDist = Vector3.Distance (pl.pin.transform.position, projectedPos2);
if (pinPlatDist <= pl.chainLenght)
currentPlatform.reference.transform.parent.position = projectedPos2;
else
currentPlatform.reference.transform.parent.position = startingPos;
break;
// case Platform.PlatformType.PT_EVERYTHING:
// currentPlatform.transform.parent.position = Vector3.MoveTowards( currentPlatform.transform.parent.position, new Vector3 (transform.position.x, transform.position.y, transform.position.z), Time.deltaTime * movingSpeed);
//
// float pinPlatDist2 = Vector3.Distance (pl.pin.transform.position, currentPlatform.transform.parent.position);
// if (pinPlatDist2 <= pl.chainLenght)
// currentPlatform.transform.parent.position = Vector3.MoveTowards( currentPlatform.transform.parent.position, new Vector3 (transform.position.x, transform.position.y, transform.position.z), Time.deltaTime * movingSpeed);
// else
// if (
// currentPlatform.transform.parent.position = startingPos;
// break;
}
////Platform Rotation
#region this was moved to be updated independently holding a platform or not
//if the bones are too close, we will have rotation issues
//so we will only update rotation if they are not too close
/*if(bones.Distance > distanceDeadZone){
rotateTowardsAngle = (bones.Angle+boneAngleAdjustment)*boneAngleFactor;
//now we snap the value so it doesn't flicker
if(Mathf.Abs(rotateTowardsAngle)%preciseSnap < preciseSnapRange || Mathf.Abs(rotateTowardsAngle)%preciseSnap > preciseSnap - preciseSnapRange) {
//here we snap to precise degree angles
rotateTowardsAngle = MathUtilities.SnapTo(rotateTowardsAngle, preciseSnap);
} else {
//here we snap to less precise angles
rotateTowardsAngle = MathUtilities.SnapTo(rotateTowardsAngle, angleSnapFactor);
}
}*/
#endregion
//platform rotation happens here
if (pl.pt != Platform.PlatformType.PT_VRAIL && pl.pt != Platform.PlatformType.PT_ORAIL && pl.pt != Platform.PlatformType.PT_EZLINE)
{
rotateFrom = currentPlatform.reference.transform.parent.rotation;
currentPlatform.reference.transform.parent.rotation = Quaternion.RotateTowards(
rotateFrom,
Quaternion.AngleAxis(rotateTowardsAngle + currentPlatform.initialAngle - magicAngle, Vector3.forward),
Time.fixedDeltaTime * rotationSpeed);
}
else if(pl.pt != Platform.PlatformType.PT_PINNED)
{
}
////Platform Scaling
// currentPlatform.transform.localScale = Vector3.MoveTowards(
// currentPlatform.transform.localScale,
// new Vector3(Mathf.Clamp(currentPlatform.initialScale.x*GetBoneDistance(), minimumPlatformScale, maximumPlatformScale), currentPlatform.initialScale.y, currentPlatform.initialScale.z),
// Time.deltaTime * scalingSpeed);
}
