private bool SetStyleValue <T>(StylePropertyId id, StyleEnum <T> inlineValue, StyleEnum <T> sharedValue) where T : struct, IConvertible
{
var sv = new StyleValue();
int intValue = UnsafeUtility.EnumToInt(inlineValue.value);
if (TryGetStyleValue(id, ref sv))
{
if (sv.number == intValue && sv.keyword == inlineValue.keyword)
{
return(false);
}
}
else if (inlineValue.keyword == StyleKeyword.Null)
{
return(false);
}
sv.id = id;
sv.keyword = inlineValue.keyword;
sv.number = intValue;
SetStyleValue(sv);
if (inlineValue.keyword == StyleKeyword.Null)
{
sv.keyword = sharedValue.keyword;
sv.number = UnsafeUtility.EnumToInt(sharedValue.value);
}
ApplyStyleValue(sv);
return(true);
}
public override int GetHashCode()
{
unchecked
{
return((UnsafeUtility.EnumToInt(m_Value) * 397) ^ (int)m_Keyword);
}
}
/// <summary>
/// Removes <typeparamref name="AudioSampleProvider"/> from the specified <typeparamref name="DSPNode"/>. If index is not passed or is -1 then it is removed from the last.
/// </summary>
/// <param name="node">The node to remove the <typeparamref name="AudioSampleProvider"/> from</param>
/// <param name="item">The sample provider 'slot' that should have the sample provider removed from</param>
/// <param name="index">The index into the array that the provider should be removed from. This is if the sample provider slot is an array.</param>
/// <typeparam name="TParameters">Enum type of the parameters of the node</typeparam>
/// <typeparam name="TProviders">Enum type of the sample providers of the node</typeparam>
/// <typeparam name="TAudioKernel">The kernel type of the node</typeparam>
/// <exception cref="ArgumentException">Unknown SampleProvider</exception>
/// <exception cref="InvalidOperationException">Can only remove from variable-size array</exception>
public void RemoveSampleProvider <TParameters, TProviders, TAudioKernel>(DSPNode node, TProviders item, int index = -1)
where TParameters : unmanaged, Enum
where TProviders : unmanaged, Enum
where TAudioKernel : struct, IAudioKernel <TParameters, TProviders>
{
AssertSameGraphAsNode(node);
AudioKernelExtensions.GetReflectionData <TAudioKernel, TParameters, TProviders>(out AudioKernelExtensions.SampleProviderDescriptionData sampleProviderDescriptionData);
var itemIndex = UnsafeUtility.EnumToInt(item);
// Can only remove from variable-size arrays.
if (!sampleProviderDescriptionData.Descriptions[itemIndex].m_IsArray ||
sampleProviderDescriptionData.Descriptions[itemIndex].m_Size >= 0)
{
throw new InvalidOperationException("Can only remove sample providers from variable-size array");
}
QueueCommand(new RemoveSampleProviderCommand
{
m_Type = DSPCommandType.RemoveSampleProvider,
m_Graph = m_Graph,
m_Handle = m_Handle,
m_Node = node.Handle,
m_SampleProviderDescriptionData = sampleProviderDescriptionData,
m_Item = UnsafeUtility.EnumToInt(item),
m_Index = index,
});
}
internal void InsertSampleProvider <TParameters, TProviders, TAudioKernel>(
uint providerId, DSPNode node, TProviders item, int index = -1, bool destroyOnRemove = false)
where TParameters : unmanaged, Enum
where TProviders : unmanaged, Enum
where TAudioKernel : struct, IAudioKernel <TParameters, TProviders>
{
AssertSameGraphAsNode(node);
AudioKernelExtensions.GetReflectionData <TAudioKernel, TParameters, TProviders>(out AudioKernelExtensions.SampleProviderDescriptionData sampleProviderDescriptionData);
var providerIndex = GetProviderIndex(item, sampleProviderDescriptionData);
// Can only insert into variable-size arrays.
if (!sampleProviderDescriptionData.Descriptions[providerIndex].m_IsArray ||
sampleProviderDescriptionData.Descriptions[providerIndex].m_Size >= 0)
{
throw new InvalidOperationException("Can only insert into variable-size array.");
}
QueueCommand(new InsertSampleProviderCommand
{
m_Type = DSPCommandType.InsertSampleProvider,
m_Graph = m_Graph,
m_Handle = m_Handle,
m_Node = node.Handle,
m_SampleProviderDescriptionData = sampleProviderDescriptionData,
m_ProviderId = providerId,
m_Item = UnsafeUtility.EnumToInt(item),
m_Index = index,
m_DestroyOnRemove = destroyOnRemove,
});
}
internal void SetSampleProvider <TParameters, TProviders, TAudioKernel>(
uint providerId, DSPNode node, TProviders item, int index = 0, bool destroyOnRemove = false)
where TParameters : unmanaged, Enum
where TProviders : unmanaged, Enum
where TAudioKernel : struct, IAudioKernel <TParameters, TProviders>
{
AssertSameGraphAsNode(node);
AudioKernelExtensions.GetReflectionData <TAudioKernel, TParameters, TProviders>(out AudioKernelExtensions.SampleProviderDescriptionData sampleProviderDescriptionData);
var providerIndex = GetProviderIndex(item, sampleProviderDescriptionData);
// Index validation for fixed-size array items can be performed here. For variable-array,
// it can only be performed in the job threads, where the array size is known and stable.
if (sampleProviderDescriptionData.Descriptions[providerIndex].m_IsArray &&
sampleProviderDescriptionData.Descriptions[providerIndex].m_Size >= 0 &&
(sampleProviderDescriptionData.Descriptions[providerIndex].m_Size < index || index < 0))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
QueueCommand(new SetSampleProviderCommand
{
m_Type = DSPCommandType.SetSampleProvider,
m_Graph = m_Graph,
m_Handle = m_Handle,
m_Node = node.Handle,
m_SampleProviderDescriptionData = sampleProviderDescriptionData,
m_ProviderId = providerId,
m_Item = UnsafeUtility.EnumToInt(item),
m_Index = index,
m_DestroyOnRemove = destroyOnRemove,
});
}
static void PickStructType(StructModel structModel, Action <StructModel, StructType> action)
{
EditorUtility.DisplayCustomMenu(
new Rect(Event.current.mousePosition, Vector2.one),
s_StructTypeOptions,
UnsafeUtility.EnumToInt(structModel.Type),
(data, options, selected) =>
{
StructType type = (StructType)selected;
action(structModel, type);
},
null);
}
private unsafe static void TestUnsafeUtility()
{
// Allocate
void *a = UnsafeUtility.Malloc(
size: ARRAY_SIZE * UnsafeUtility.SizeOf <int>(),
alignment: UnsafeUtility.AlignOf <byte>(),
allocator: Allocator.Temp);
void *b = UnsafeUtility.Malloc(
size: ARRAY_SIZE * UnsafeUtility.SizeOf <int>(),
alignment: UnsafeUtility.AlignOf <byte>(),
allocator: Allocator.Temp);
for (int i = 0; i < ARRAY_SIZE; i++)
{
((int *)a)[i] = i;
}
Print5IntArray((int *)b);
UnsafeUtility.MemCpy(destination: b, source: a, size: ARRAY_SIZE * UnsafeUtility.SizeOf <int>());
Print5IntArray((int *)b);
for (int i = 0; i < ARRAY_SIZE; i++)
{
UnsafeUtility.WriteArrayElement(
destination: b,
index: i,
value: -i);
}
Print5IntFromVoidArray(b);
// Free
UnsafeUtility.Free(memory: a, allocator: Allocator.Temp);
UnsafeUtility.Free(memory: b, allocator: Allocator.Temp);
Debug.Log($"Vowel.I : {UnsafeUtility.EnumToInt(Vowel.I)}");
Int4 int4 = new Int4();
Debug.Log(int4);
ModifyInt4ByAddressOfRef(ref int4);
Debug.Log(int4);
}
/// <summary>
/// This API will sustain the previous parameter value until the dspclock time is reached
/// </summary>
/// <typeparam name="TParameters">Enum type of the parameters of the node</typeparam>
/// <typeparam name="TProviders">Enum type of the sample providers of the node</typeparam>
/// <typeparam name="TAudioKernel">The kernel type of the node</typeparam>
/// <param name="node">The node that should have its parameter sustained</param>
/// <param name="parameter">The parameter to sustain</param>
/// <param name="dspClock">The time in which the parameter should be sustained until</param>
/// <exception cref="ArgumentException">Throws exception when parameter is unknown</exception>
public void SustainFloat <TParameters, TProviders, TAudioKernel>(DSPNode node, TParameters parameter, long dspClock)
where TParameters : unmanaged, Enum
where TProviders : unmanaged, Enum
where TAudioKernel : struct, IAudioKernel <TParameters, TProviders>
{
AssertSameGraphAsNode(node);
AudioKernelExtensions.GetReflectionData <TAudioKernel, TParameters, TProviders>(out void *jobReflectionData, out AudioKernelExtensions.ParameterDescriptionData parameterDescriptionData);
QueueCommand(new SustainFloatCommand
{
m_Type = DSPCommandType.SustainFloat,
m_Graph = m_Graph,
m_Handle = m_Handle,
m_Node = node.Handle,
m_JobReflectionData = jobReflectionData,
m_ParameterDescriptionData = parameterDescriptionData,
m_Parameter = (uint)UnsafeUtility.EnumToInt(parameter),
m_DSPClock = (ulong)dspClock,
});
}
/// <summary>
/// Sets the value of a parameter on the specified node
/// </summary>
/// <param name="node">DSPNode in which the parameter value is set</param>
/// <param name="parameter">Enum which specifies the parameter</param>
/// <param name="value">Target value to be set</param>
/// <param name="interpolationLength">The number of samples to reach the desired value</param>
/// <typeparam name="TParameters">Enum type of the parameters of the node</typeparam>
/// <typeparam name="TProviders">Enum type of the sample providers of the node</typeparam>
/// <typeparam name="TAudioKernel">The kernel type of the node</typeparam>
/// <exception cref="ArgumentException">Exception thrown when parameter is unknown</exception>
public void SetFloat <TParameters, TProviders, TAudioKernel>(DSPNode node, TParameters parameter, float value, int interpolationLength = 0)
where TParameters : unmanaged, Enum
where TProviders : unmanaged, Enum
where TAudioKernel : struct, IAudioKernel <TParameters, TProviders>
{
AssertSameGraphAsNode(node);
AudioKernelExtensions.GetReflectionData <TAudioKernel, TParameters, TProviders>(out void *jobReflectionData, out AudioKernelExtensions.ParameterDescriptionData parameterDescriptionData);
QueueCommand(new SetFloatCommand
{
m_Type = DSPCommandType.SetFloat,
m_Graph = m_Graph,
m_Handle = m_Handle,
m_InterpolationLength = (uint)interpolationLength,
m_JobReflectionData = jobReflectionData,
m_Node = node.Handle,
m_Parameter = (uint)UnsafeUtility.EnumToInt(parameter),
m_ParameterDescriptionData = parameterDescriptionData,
m_Value = value,
});
}
/// <summary>
/// Gets the number of sample providers associated with a given enum value in a container.
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public int GetCount(TProviders p)
{
var itemIndex = UnsafeUtility.EnumToInt(p);
if (itemIndex < 0 || itemIndex >= Count)
{
throw new IndexOutOfRangeException("itemIndex");
}
int globalIndex = SampleProviderIndices[itemIndex];
// Happens if the 'itemIndex'th item is an empty array.
if (globalIndex < 0)
{
return(0);
}
// Find the index of the next non-empty item.
int nextItemIndex = itemIndex + 1;
int nextGlobalIndex = -1;
for (; nextItemIndex < Count; ++nextItemIndex)
{
nextGlobalIndex = SampleProviderIndices[nextItemIndex];
if (nextGlobalIndex >= 0)
{
break;
}
}
// All items after itemIndex are empty containers.
if (nextGlobalIndex < 0)
{
return(SampleProvidersCount - globalIndex);
}
return(nextGlobalIndex - globalIndex);
}
/// <param name="parameter">
/// A specific enum value from the parameter enumeration specified in the
/// audio job.
/// <see cref="IAudioKernel{TParameters,TProviders}"/>
/// </param>
/// <param name="sampleOffset">
/// The time to evaluate the parameter at.
/// </param>
/// <returns>The value of a parameter.</returns>
public float GetFloat(P parameter, int sampleOffset)
{
return(GetFloat(UnsafeUtility.EnumToInt(parameter), sampleOffset));
}
public Flags32(TEnum value)
{
CheckEnumSize();
Flags = UnsafeUtility.EnumToInt(value);
}
/// <summary>
/// Gets the sample provider associated with a given enum value.
/// </summary>
/// <param name="p"></param>
/// <param name="arrayIndex"></param>
/// <returns>Returns a SampleProvider</returns>
public SampleProvider GetSampleProvider(TProviders p, int arrayIndex = 0)
{
return(GetSampleProvider(UnsafeUtility.EnumToInt(p), arrayIndex));
}