protected IEnumerable <uSyncDependency> GetPropertyDependencies(JObject value,
IContentType docType, DependencyFlags flags)
{
var dependencies = new List <uSyncDependency>();
foreach (var propertyType in docType.CompositionPropertyTypes)
{
var propertyValue = value[propertyType.Alias];
if (propertyValue == null)
{
continue;
}
var dataType = dataTypeService.GetDataType(propertyType.DataTypeKey);
if (dataType == null)
{
continue;
}
dependencies.AddRange(SyncValueMapperFactory.GetDependencies(propertyValue, dataType.EditorAlias, flags));
}
return(dependencies);
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
if (value == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var stringValue = value.ToString();
if (string.IsNullOrWhiteSpace(stringValue))
{
return(Enumerable.Empty <uSyncDependency>());
}
return(GetGridDependencies <uSyncDependency>(stringValue, ProcessControl, flags));
}
/// <summary>
/// Get the actual media file as a dependency.
/// </summary>
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
var stringValue = value?.ToString();
if (string.IsNullOrWhiteSpace(stringValue))
{
return(Enumerable.Empty <uSyncDependency>());
}
var stringPath = GetImagePath(stringValue).TrimStart('/').ToLower();
if (!string.IsNullOrWhiteSpace(stringPath))
{
return(new uSyncDependency()
{
Name = $"File: {Path.GetFileName(stringPath)}",
Udi = Udi.Create(Constants.UdiEntityType.MediaFile, stringPath),
Flags = flags,
Order = DependencyOrders.OrderFromEntityType(Constants.UdiEntityType.MediaFile),
Level = 0
}.AsEnumerableOfOne());
}
return(Enumerable.Empty <uSyncDependency>());
}
/// <summary>
///
/// </summary>
public SubpassDependency(uint sourceSubpass, uint destinationSubpass, PipelineStageFlags sourceStageMask, PipelineStageFlags destinationStageMask, AccessFlags sourceAccessMask, AccessFlags destinationAccessMask, DependencyFlags dependencyFlags)
{
this.SourceSubpass = sourceSubpass;
this.DestinationSubpass = destinationSubpass;
this.SourceStageMask = sourceStageMask;
this.DestinationStageMask = destinationStageMask;
this.SourceAccessMask = sourceAccessMask;
this.DestinationAccessMask = destinationAccessMask;
this.DependencyFlags = dependencyFlags;
}
/// <summary>
/// Marks this <see cref="BaseUnityPlugin"/> as depenant on another plugin. The other plugin will be loaded before this one.
/// If the other plugin doesn't exist, what happens depends on the <see cref="Flags"/> parameter.
/// </summary>
/// <param name="DependencyGUID">The GUID of the referenced plugin.</param>
/// <param name="Flags">The flags associated with this dependency definition.</param>
public BepInDependency(string DependencyGUID, DependencyFlags Flags = DependencyFlags.HardDependency)
{
this.DependencyGUID = DependencyGUID;
this.Flags = Flags;
MinimumVersion = new Version();
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
// validate string
var stringValue = value?.ToString();
if (string.IsNullOrWhiteSpace(stringValue) || !stringValue.DetectIsJson())
{
return(Enumerable.Empty <uSyncDependency>());
}
// convert to an array.
var images = JsonConvert.DeserializeObject <JArray>(value.ToString());
if (images == null || !images.Any())
{
return(Enumerable.Empty <uSyncDependency>());
}
var dependencies = new List <uSyncDependency>();
foreach (var image in images.Cast <JObject>())
{
var key = GetGuidValue(image, "mediaKey");
if (key != Guid.Empty)
{
var udi = GuidUdi.Create(UdiEntityType.Media, key);
dependencies.Add(CreateDependency(udi as GuidUdi, flags));
}
}
return(dependencies);
}
/// <param name="DependencyGUID">The GUID of the referenced plugin.</param>
/// <param name="Flags">The flags associated with this dependency definition.</param>
public BepInDependency(string DependencyGUID, DependencyFlags Flags = DependencyFlags.HardDependency)
{
this.DependencyGUID = DependencyGUID;
this.Flags = Flags;
}
protected DependencyModel(
string caption,
string?path,
string originalItemSpec,
ProjectTreeFlags flags,
bool isResolved,
bool isImplicit,
IImmutableDictionary <string, string>?properties,
bool isVisible = true)
{
Requires.NotNullOrEmpty(caption, nameof(caption));
// IDependencyModel allows original item spec to be null, but we can satisfy a
// more strict requirement for the dependency types produced internally.
// External providers may not have a meaningful value, but do not use this type.
Requires.NotNullOrEmpty(originalItemSpec, nameof(originalItemSpec));
Path = path;
OriginalItemSpec = originalItemSpec;
Properties = properties ?? ImmutableStringDictionary <string> .EmptyOrdinal;
Caption = caption;
Flags = flags;
if (Properties.TryGetBoolProperty(ProjectItemMetadata.Visible, out bool visibleProperty))
{
isVisible = visibleProperty;
}
DiagnosticLevel diagnosticLevel = DiagnosticLevel.None;
if (Properties.TryGetStringProperty(ProjectItemMetadata.DiagnosticLevel, out string?levelString))
{
diagnosticLevel = levelString switch
{
"Warning" => DiagnosticLevel.Warning,
"Error" => DiagnosticLevel.Error,
_ => DiagnosticLevel.None
};
}
if (diagnosticLevel == DiagnosticLevel.None && !isResolved)
{
// Treat unresolved state as a warning diagnostic
diagnosticLevel = DiagnosticLevel.Warning;
}
DependencyFlags depFlags = 0;
if (isResolved)
{
depFlags |= DependencyFlags.Resolved;
}
if (isVisible)
{
depFlags |= DependencyFlags.Visible;
}
if (isImplicit)
{
depFlags |= DependencyFlags.Implicit;
}
_flags = depFlags;
DiagnosticLevel = diagnosticLevel;
}
public virtual IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags) => Enumerable.Empty <uSyncDependency>();
protected abstract IEnumerable <SyncItem> GetDecendants(SyncItem item, DependencyFlags flags);
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
if (value == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var image = JsonConvert.DeserializeObject <JObject>(value.ToString());
var udiString = image.Value <string>("udi");
if (!string.IsNullOrWhiteSpace(udiString))
{
var dependency = CreateDependency(udiString, flags);
if (dependency != null)
{
return(dependency.AsEnumerableOfOne());
}
}
return(Enumerable.Empty <uSyncDependency>());
}
public void CmdPipelineBarrier(PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlag, MemoryBarrier pMemoryBarrier, BufferMemoryBarrier pBufferMemoryBarrier, ImageMemoryBarrier pImageMemoryBarrier)
{
unsafe {
Interop.NativeMethods.vkCmdPipelineBarrier(this.m, srcStageMask, dstStageMask, dependencyFlag, (UInt32)(pMemoryBarrier != null ? 1 : 0), pMemoryBarrier != null ? pMemoryBarrier.m : (Interop.MemoryBarrier *) default(IntPtr), (UInt32)(pBufferMemoryBarrier != null ? 1 : 0), pBufferMemoryBarrier != null ? pBufferMemoryBarrier.m : (Interop.BufferMemoryBarrier *) default(IntPtr), (UInt32)(pImageMemoryBarrier != null ? 1 : 0), pImageMemoryBarrier != null ? pImageMemoryBarrier.m : (Interop.ImageMemoryBarrier *) default(IntPtr));
}
}
public void CmdPipelineBarrier(PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, MemoryBarrier[] pMemoryBarriers, BufferMemoryBarrier[] pBufferMemoryBarriers, ImageMemoryBarrier[] pImageMemoryBarriers)
{
unsafe {
var arraypMemoryBarriers = pMemoryBarriers == null ? IntPtr.Zero : Marshal.AllocHGlobal(pMemoryBarriers.Length * sizeof(Interop.MemoryBarrier));
var lenpMemoryBarriers = pMemoryBarriers == null ? 0 : pMemoryBarriers.Length;
if (pMemoryBarriers != null)
{
for (int i = 0; i < pMemoryBarriers.Length; i++)
{
((Interop.MemoryBarrier *)arraypMemoryBarriers) [i] = *(pMemoryBarriers [i].m);
}
}
var arraypBufferMemoryBarriers = pBufferMemoryBarriers == null ? IntPtr.Zero : Marshal.AllocHGlobal(pBufferMemoryBarriers.Length * sizeof(Interop.BufferMemoryBarrier));
var lenpBufferMemoryBarriers = pBufferMemoryBarriers == null ? 0 : pBufferMemoryBarriers.Length;
if (pBufferMemoryBarriers != null)
{
for (int i = 0; i < pBufferMemoryBarriers.Length; i++)
{
((Interop.BufferMemoryBarrier *)arraypBufferMemoryBarriers) [i] = *(pBufferMemoryBarriers [i].m);
}
}
var arraypImageMemoryBarriers = pImageMemoryBarriers == null ? IntPtr.Zero : Marshal.AllocHGlobal(pImageMemoryBarriers.Length * sizeof(Interop.ImageMemoryBarrier));
var lenpImageMemoryBarriers = pImageMemoryBarriers == null ? 0 : pImageMemoryBarriers.Length;
if (pImageMemoryBarriers != null)
{
for (int i = 0; i < pImageMemoryBarriers.Length; i++)
{
((Interop.ImageMemoryBarrier *)arraypImageMemoryBarriers) [i] = *(pImageMemoryBarriers [i].m);
}
}
Interop.NativeMethods.vkCmdPipelineBarrier(this.m, srcStageMask, dstStageMask, dependencyFlags, (uint)lenpMemoryBarriers, (Interop.MemoryBarrier *)arraypMemoryBarriers, (uint)lenpBufferMemoryBarriers, (Interop.BufferMemoryBarrier *)arraypBufferMemoryBarriers, (uint)lenpImageMemoryBarriers, (Interop.ImageMemoryBarrier *)arraypImageMemoryBarriers);
Marshal.FreeHGlobal(arraypMemoryBarriers);
Marshal.FreeHGlobal(arraypBufferMemoryBarriers);
Marshal.FreeHGlobal(arraypImageMemoryBarriers);
}
}
public BepInDependency(string a, DependencyFlags b = DependencyFlags.HardDependency)
{
}
internal static unsafe extern void vkCmdPipelineBarrier(CommandBuffer commandBuffer, PipelineStageFlags sourceStageMask, PipelineStageFlags destinationStageMask, DependencyFlags dependencyFlags, uint memoryBarrierCount, MemoryBarrier* memoryBarriers, uint bufferMemoryBarrierCount, BufferMemoryBarrier* bufferMemoryBarriers, uint imageMemoryBarrierCount, ImageMemoryBarrier* imageMemoryBarriers);
protected IEnumerable <uSyncDependency> CreateDependencies(IEnumerable <string> udiStrings, DependencyFlags flags)
{
if (udiStrings == null || !udiStrings.Any())
{
yield break;
}
foreach (var udiString in udiStrings)
{
var dependency = CreateDependency(udiString, flags);
if (dependency != null)
{
yield return(dependency);
}
}
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
var stringValue = GetValueAs <string>(value);
if (string.IsNullOrWhiteSpace(stringValue) || !stringValue.DetectIsJson())
{
return(Enumerable.Empty <uSyncDependency>());
}
var nestedJson = JsonConvert.DeserializeObject <JArray>(stringValue);
if (nestedJson == null || !nestedJson.Any())
{
return(Enumerable.Empty <uSyncDependency>());
}
var dependencies = new List <uSyncDependency>();
foreach (var item in nestedJson.Cast <JObject>())
{
var docTypeAlias = item[this.docTypeAliasValue].ToString();
var docType = GetDocType(docTypeAlias);
if (docType == null)
{
continue;
}
if (flags.HasFlag(DependencyFlags.IncludeDependencies))
{
var docTypeDep = CreateDocTypeDependency(docTypeAlias, flags);
if (docTypeDep != null)
{
dependencies.Add(docTypeDep);
}
}
dependencies.AddRange(GetPropertyDependencies(item, docType, flags));
}
return(dependencies);
}
/// <summary>
/// so do we want this ? go through all the picked values in the content,
/// and include them in the things to export ?
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
protected IEnumerable <uSyncDependency> GetPropertyDependencies(IContentBase item, DependencyFlags flags)
{
var dependencies = new List <uSyncDependency>();
var propertyFlags = flags
& ~DependencyFlags.IncludeChildren;
foreach (var property in item.Properties)
{
var editorAlias = property.PropertyType.PropertyEditorAlias;
var mapper = mappers.GetSyncMapper(editorAlias);
if (mapper != null)
{
foreach (var value in property.Values)
{
if (value.EditedValue == null)
{
continue;
}
var linkedDependencies = mapper.GetDependencies(value.EditedValue, editorAlias, propertyFlags);
// include linked means all content we link to
if (flags.HasFlag(DependencyFlags.IncludeLinked))
{
dependencies.AddRange(linkedDependencies.Where(x => x.Udi.EntityType == UdiEntityType.Document));
}
// include any settings things we would be dependent on for this property.
if (flags.HasFlag(DependencyFlags.IncludeDependencies))
{
dependencies.AddRange(linkedDependencies.Where(x => settingsTypes.InvariantContains(x.Udi.EntityType)));
}
// media means we include media items (the files are checked)
if (flags.HasFlag(DependencyFlags.IncludeMedia))
{
var media = linkedDependencies.Where(x => x.Udi.EntityType == UdiEntityType.Media || x.Udi.EntityType == UdiEntityType.MediaFile).ToList();
media.ForEach(x => { x.Flags |= DependencyFlags.IncludeAncestors; });
dependencies.AddRange(media);
}
}
}
}
return(dependencies);
}
/// <summary>
/// Marks this <see cref="BaseUnityPlugin" /> as dependent on another plugin. The other plugin will be loaded before
/// this one.
/// If the other plugin doesn't exist, what happens depends on the <see cref="Flags" /> parameter.
/// </summary>
/// <param name="DependencyGUID">The GUID of the referenced plugin.</param>
/// <param name="Flags">The flags associated with this dependency definition.</param>
public BepInDependency(string DependencyGUID, DependencyFlags Flags = DependencyFlags.HardDependency)
{
this.DependencyGUID = DependencyGUID;
this.Flags = Flags;
VersionRange = null;
}
protected IEnumerable <uSyncDependency> GetParentDependencies(string path, int order, DependencyFlags flags)
{
var ids = path.Split(new char[] { ',' }, System.StringSplitOptions.RemoveEmptyEntries)
.Select(x => int.Parse(x))
.ToArray();
var items = entityService.GetAll(this.ObjectType, ids);
foreach (var item in items)
{
order--;
yield return(new uSyncDependency
{
Name = item.Name,
Udi = Udi.Create(this.ObjectType.GetUdiType(), item.Key),
Order = order,
Flags = flags & ~DependencyFlags.IncludeChildren,
Level = item.Level
});
}
}
internal static unsafe extern void vkCmdPipelineBarrier(CommandBuffer commandBuffer, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, UInt32 memoryBarrierCount, MemoryBarrier *MemoryBarriers, UInt32 bufferMemoryBarrierCount, BufferMemoryBarrier *BufferMemoryBarriers, UInt32 imageMemoryBarrierCount, ImageMemoryBarrier *ImageMemoryBarriers);
protected IEnumerable <uSyncDependency> GetParentDependencies(int id, int order, DependencyFlags flags)
{
var dependencies = new List <uSyncDependency>();
var parent = entityService.GetParent(id);
if (parent != null)
{
dependencies.Add(new uSyncDependency()
{
Name = parent.Name,
Udi = Udi.Create(this.ObjectType.GetUdiType(), parent.Key),
Order = order,
Flags = flags & ~DependencyFlags.IncludeChildren,
Level = parent.Level
});
dependencies.AddRange(GetParentDependencies(parent.Id, order - 1, flags));
}
return(dependencies);
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
var jsonValue = GetJsonValue(value);
if (value == null || jsonValue == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var docValue = jsonValue.Value <JObject>("value");
var docTypeAlias = jsonValue.Value <string>(this.docTypeAliasValue);
if (docValue == null || docTypeAlias == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var docType = GetDocType(docTypeAlias);
if (docType == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
List <uSyncDependency> dependencies = new List <uSyncDependency>();
if (flags.HasFlag(DependencyFlags.IncludeDependencies))
{
// get the docType as a dependency.
// you only need to get the primary doctype, a subsequent check
// will get the full dependency tree for this doctype if it
// is needed.
var docDependency = CreateDocTypeDependency(docTypeAlias, flags);
if (docDependency != null)
{
dependencies.Add(docDependency);
}
}
// let the base class go through the PropertyTypes
// and call the mappers for each value, this gets us
// any internal dependencies (like media, etc)
// from within the content.
dependencies.AddRange(GetPropertyDependencies(docValue, docType, flags));
return(dependencies);
}
protected IEnumerable <uSyncDependency> CalcDataTypeDependencies(TObject item, DependencyFlags flags)
{
var dataTypes = new List <uSyncDependency>();
var dictionaryKeys = new List <string>();
foreach (var property in item.PropertyTypes)
{
var dataType = dataTypeService.GetDataType(property.DataTypeId);
if (dataType != null)
{
dataTypes.Add(new uSyncDependency()
{
Name = dataType.Name,
Udi = dataType.GetUdi(),
Order = DependencyOrders.DataTypes,
Flags = flags,
Level = item.Level
});
}
// TODO: Dictionary Item Dependencies, when labels start with #
if (property.Name.StartsWith("#"))
{
dictionaryKeys.Add(property.Name.Substring(1));
}
}
foreach (var tab in item.PropertyGroups)
{
if (tab.Name.StartsWith("#"))
{
dictionaryKeys.Add(tab.Name.Substring(1));
}
}
dataTypes.AddRange(GetDictionaryDependencies(dictionaryKeys, flags));
return(dataTypes);
}
private IEnumerable <TObject> GetGridDependencies <TObject>(string gridContent, Func <JObject, DependencyFlags, IEnumerable <TObject> > callback, DependencyFlags flags)
{
var grid = JsonConvert.DeserializeObject <JObject>(gridContent);
if (grid == null)
{
return(Enumerable.Empty <TObject>());
}
var items = new List <TObject>();
var sections = GetArray(grid, "sections");
foreach (var section in sections.Cast <JObject>())
{
var rows = GetArray(section, "rows");
foreach (var row in rows.Cast <JObject>())
{
var areas = GetArray(row, "areas");
foreach (var area in areas.Cast <JObject>())
{
var controls = GetArray(area, "controls");
foreach (var control in controls.Cast <JObject>())
{
var result = callback(control, flags);
if (result != null)
{
items.AddRange(result);
}
}
}
}
}
return(items);
}
private IEnumerable <uSyncDependency> GetDictionaryDependencies(IEnumerable <string> keys, DependencyFlags flags)
{
var dependencies = new List <uSyncDependency>();
foreach (var key in keys)
{
var item = localizationService.GetDictionaryItemByKey(key);
if (item != null)
{
dependencies.Add(new uSyncDependency()
{
Name = item.ItemKey,
Flags = flags,
Order = DependencyOrders.DictionaryItems,
Level = 0,
Udi = item.GetUdi() // strong chance you can't do this with a dictionary item :(
});
}
}
return(dependencies);
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
if (value != null)
{
var udiStrings = value.ToString().ToDelimitedList();
return(CreateDependencies(udiStrings, flags));
}
return(Enumerable.Empty <uSyncDependency>());
}
protected IEnumerable <uSyncDependency> CalcCompositions(IContentTypeComposition item, int priority, DependencyFlags flags)
{
var contentTypes = new List <uSyncDependency>();
foreach (var composition in item.ContentTypeComposition)
{
contentTypes.Add(new uSyncDependency()
{
Name = item.Name,
Udi = composition.GetUdi(),
Order = priority,
Level = composition.Level,
Flags = flags
});
if (composition.ContentTypeComposition != null && composition.ContentTypeComposition.Any())
{
contentTypes.AddRange(CalcCompositions(composition, priority - 1, flags));
}
}
return(contentTypes);
}
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
// value null check.
if (value == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var stringValue = value.ToString();
if (string.IsNullOrWhiteSpace(stringValue))
{
return(Enumerable.Empty <uSyncDependency>());
}
var dependencies = new List <uSyncDependency>();
foreach (Match m in UdiRegEx.Matches(stringValue))
{
if (UdiParser.TryParse <GuidUdi>(m.Value, out GuidUdi udi))
{
if (!dependencies.Any(x => x.Udi == udi))
{
dependencies.Add(CreateDependency(udi, flags));
}
}
}
if (MacroRegEx.IsMatch(stringValue))
{
var mappers = mapperCollection.Value.GetSyncMappers(editorAlias + ".macro");
if (mappers.Any())
{
foreach (var macro in MacroRegEx.Matches(stringValue))
{
foreach (var mapper in mappers)
{
dependencies.AddRange(mapper.GetDependencies(stringValue, editorAlias + ".macro", flags));
}
}
}
}
return(dependencies.Distinct());
}
public static IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
var mappers = GetMappers(editorAlias);
if (!mappers.Any())
{
return(Enumerable.Empty <uSyncDependency>());
}
var dependencies = new List <uSyncDependency>();
foreach (var mapper in mappers)
{
dependencies.AddRange(mapper.GetDependencies(value, editorAlias, flags));
}
return(dependencies);
}
/// <summary>
/// Dependency check for bento item
/// </summary>
/// <remarks>
/// a bento item is a single item, stored in json as a link
///
/// when content is linked, its done via the key.
/// {"id":1161,"key":"0af06fdb-9084-4601-a65f-a9b529e731ad","icon":"icon-brick"}
///
/// when the content is embedded its in the contentData and behaves like nested content
/// {"id":0,"key":"c1d39dea-b590-4d5c-b213-187c2b303d93","contentData":{"name":"Simple Bento Element","contentTypeAlias":"simpleBentoElement","icon":"icon-document","title":"Some title","link":"umb://document/ca4249ed2b234337b52263cabe5587d1"},"icon":"icon-document"}
///
/// </remarks>
public override IEnumerable <uSyncDependency> GetDependencies(object value, string editorAlias, DependencyFlags flags)
{
if (value == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
var stackJson = GetValueAs <JArray>(value);
if (stackJson == null)
{
return(Enumerable.Empty <uSyncDependency>());
}
List <uSyncDependency> dependencies = new List <uSyncDependency>();
foreach (var stack in stackJson)
{
var areas = stack.Value <JArray>("areas");
if (areas == null)
{
continue;
}
foreach (var area in areas)
{
if (area is JObject itemValue)
{
dependencies.AddRange(GetItemDependency(itemValue, flags));
}
}
}
return(dependencies);
}
public unsafe void PipelineBarrier(PipelineStageFlags sourceStageMask, PipelineStageFlags destinationStageMask, DependencyFlags dependencyFlags, uint memoryBarrierCount, MemoryBarrier* memoryBarriers, uint bufferMemoryBarrierCount, BufferMemoryBarrier* bufferMemoryBarriers, uint imageMemoryBarrierCount, ImageMemoryBarrier* imageMemoryBarriers)
{
vkCmdPipelineBarrier(this, sourceStageMask, destinationStageMask, dependencyFlags, memoryBarrierCount, memoryBarriers, bufferMemoryBarrierCount, bufferMemoryBarriers, imageMemoryBarrierCount, imageMemoryBarriers);
}
