632 lines
30 KiB
C#
632 lines
30 KiB
C#
using UnityEngine.Rendering;
|
|
using System;
|
|
using System.Reflection;
|
|
using System.Linq.Expressions;
|
|
|
|
namespace UnityEditor.Rendering
|
|
{
|
|
/// <summary>Serialisation of BitArray, Utility class</summary>
|
|
public static class SerializedBitArrayUtilities
|
|
{
|
|
/// <summary>Convert to 8bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray8</returns>
|
|
public static SerializedBitArray8 ToSerializeBitArray8(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 8u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray8(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 8bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray8</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray8(this SerializedProperty serializedProperty, out SerializedBitArray8 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 8u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray8(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Convert to 16bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray16</returns>
|
|
public static SerializedBitArray16 ToSerializeBitArray16(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 16u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray16(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 16bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray16</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray16(this SerializedProperty serializedProperty, out SerializedBitArray16 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 16u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray16(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Convert to 32bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray32</returns>
|
|
public static SerializedBitArray32 ToSerializeBitArray32(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 32u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray32(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 32bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray32</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray32(this SerializedProperty serializedProperty, out SerializedBitArray32 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 32u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray32(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Convert to 64bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray64</returns>
|
|
public static SerializedBitArray64 ToSerializeBitArray64(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 64u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray64(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 64bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray64</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray64(this SerializedProperty serializedProperty, out SerializedBitArray64 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 64u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray64(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Convert to 128bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray128</returns>
|
|
public static SerializedBitArray128 ToSerializeBitArray128(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 128u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray128(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 128bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray128</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray128(this SerializedProperty serializedProperty, out SerializedBitArray128 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 128u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray128(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>Convert to 256bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <returns>A SerializedBitArray256</returns>
|
|
public static SerializedBitArray256 ToSerializeBitArray256(this SerializedProperty serializedProperty)
|
|
{
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 256u))
|
|
throw new Exception("Cannot get SerializeBitArray of this Capacity");
|
|
return new SerializedBitArray256(serializedProperty);
|
|
}
|
|
|
|
/// <summary>Try convert to 256bit</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
/// <param name="serializedBitArray">Out SerializedBitArray256</param>
|
|
/// <returns>True if convertion was a success</returns>
|
|
public static bool TryGetSerializeBitArray256(this SerializedProperty serializedProperty, out SerializedBitArray256 serializedBitArray)
|
|
{
|
|
serializedBitArray = null;
|
|
if (!IsBitArrayOfCapacity(serializedProperty, 256u))
|
|
return false;
|
|
serializedBitArray = new SerializedBitArray256(serializedProperty);
|
|
return true;
|
|
}
|
|
|
|
static bool IsBitArrayOfCapacity(SerializedProperty serializedProperty, uint capacity)
|
|
{
|
|
const string baseTypeName = "BitArray";
|
|
string type = serializedProperty.type;
|
|
uint serializedCapacity;
|
|
return type.StartsWith(baseTypeName)
|
|
&& uint.TryParse(type.Substring(baseTypeName.Length), out serializedCapacity)
|
|
&& capacity == serializedCapacity;
|
|
}
|
|
}
|
|
|
|
/// <summary>interface to handle generic SerializedBitArray</summary>
|
|
public interface ISerializedBitArray
|
|
{
|
|
/// <summary>Capacity of the bitarray</summary>
|
|
uint capacity { get; }
|
|
/// <summary>Get the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Bit value</returns>
|
|
bool GetBitAt(uint bitIndex);
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
void SetBitAt(uint bitIndex, bool value);
|
|
/// <summary>Does the bit at given index have multiple different values?</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: Multiple different value</returns>
|
|
bool HasBitMultipleDifferentValue(uint bitIndex);
|
|
}
|
|
|
|
/// <summary>Abstract base classe of all SerializedBitArray</summary>
|
|
public abstract class SerializedBitArray : ISerializedBitArray
|
|
{
|
|
// Note: this should be exposed at the same time as issue with type other than Int32 is fixed on C++ side
|
|
/// <summary>Set the bit at given index</summary>
|
|
protected static Action<SerializedProperty, int, bool> SetBitAtIndexForAllTargetsImmediate;
|
|
/// <summary>Has multiple differente value bitwise</summary>
|
|
protected static Func<SerializedProperty, int> HasMultipleDifferentValuesBitwise;
|
|
static SerializedBitArray()
|
|
{
|
|
var type = typeof(SerializedProperty);
|
|
var setBitAtIndexForAllTargetsImmediateMethodInfo = type.GetMethod("SetBitAtIndexForAllTargetsImmediate", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
var hasMultipleDifferentValuesBitwisePropertyInfo = type.GetProperty("hasMultipleDifferentValuesBitwise", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
var serializedPropertyParameter = Expression.Parameter(typeof(SerializedProperty), "property");
|
|
var indexParameter = Expression.Parameter(typeof(int), "index");
|
|
var valueParameter = Expression.Parameter(typeof(bool), "value");
|
|
var hasMultipleDifferentValuesBitwiseProperty = Expression.Property(serializedPropertyParameter, hasMultipleDifferentValuesBitwisePropertyInfo);
|
|
var setBitAtIndexForAllTargetsImmediateCall = Expression.Call(serializedPropertyParameter, setBitAtIndexForAllTargetsImmediateMethodInfo, indexParameter, valueParameter);
|
|
var setBitAtIndexForAllTargetsImmediateLambda = Expression.Lambda<Action<SerializedProperty, int, bool>>(setBitAtIndexForAllTargetsImmediateCall, serializedPropertyParameter, indexParameter, valueParameter);
|
|
var hasMultipleDifferentValuesBitwiseLambda = Expression.Lambda<Func<SerializedProperty, int>>(hasMultipleDifferentValuesBitwiseProperty, serializedPropertyParameter);
|
|
SetBitAtIndexForAllTargetsImmediate = setBitAtIndexForAllTargetsImmediateLambda.Compile();
|
|
HasMultipleDifferentValuesBitwise = hasMultipleDifferentValuesBitwiseLambda.Compile();
|
|
}
|
|
|
|
/// <summary>The underlying serialized property</summary>
|
|
protected SerializedProperty m_SerializedProperty;
|
|
SerializedProperty[] m_SerializedProperties;
|
|
|
|
/// <summary>Capacity of the bitarray</summary>
|
|
public uint capacity { get; }
|
|
|
|
internal SerializedBitArray(SerializedProperty serializedProperty, uint capacity)
|
|
{
|
|
this.capacity = capacity;
|
|
m_SerializedProperty = serializedProperty;
|
|
}
|
|
|
|
/// <summary>Initialisation of dedicated SerializedPropertiws</summary>
|
|
/// <returns>Arrays of SerializedProperty</returns>
|
|
protected SerializedProperty[] GetOrInitializeSerializedProperties()
|
|
{
|
|
if (m_SerializedProperties == null)
|
|
{
|
|
UnityEngine.Object[] targets = m_SerializedProperty.serializedObject.targetObjects;
|
|
int size = targets.Length;
|
|
if (size == 1)
|
|
m_SerializedProperties = new[] { m_SerializedProperty };
|
|
else
|
|
{
|
|
string propertyPath = m_SerializedProperty.propertyPath;
|
|
m_SerializedProperties = new SerializedProperty[size];
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
m_SerializedProperties[i] = new SerializedObject(targets[i]).FindProperty(propertyPath);
|
|
}
|
|
}
|
|
}
|
|
return m_SerializedProperties;
|
|
}
|
|
|
|
/// <summary>Does the bit at given index have multiple different values?</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: Multiple different value</returns>
|
|
public bool HasBitMultipleDifferentValue(uint bitIndex)
|
|
{
|
|
if (bitIndex >= capacity)
|
|
throw new IndexOutOfRangeException("Index out of bound in BitArray" + capacity);
|
|
return HasBitMultipleDifferentValue_Internal(bitIndex);
|
|
}
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
abstract protected bool HasBitMultipleDifferentValue_Internal(uint bitIndex);
|
|
|
|
/// <summary>
|
|
/// Safety: serializedProperty must match its path
|
|
/// </summary>
|
|
/// <param name="propertyPath">serializedProperty must match its path</param>
|
|
/// <param name="serializedProperty">serializedProperty must match its path</param>
|
|
/// <param name="bitIndex"></param>
|
|
/// <returns></returns>
|
|
unsafe protected bool HasBitMultipleDifferentValue_For64Bits(string propertyPath, SerializedProperty serializedProperty, uint bitIndex)
|
|
{
|
|
if (!serializedProperty.hasMultipleDifferentValues)
|
|
return false;
|
|
|
|
var serializedProperties = GetOrInitializeSerializedProperties();
|
|
int length = serializedProperties.Length;
|
|
ulong mask = 1uL << (int)bitIndex;
|
|
bool value = ((ulong)m_SerializedProperties[0].FindPropertyRelative(propertyPath).longValue & mask) != 0uL;
|
|
for (int i = 1; i < length; ++i)
|
|
{
|
|
if ((((ulong)m_SerializedProperties[i].FindPropertyRelative(propertyPath).longValue & mask) != 0uL) ^ value)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>Get the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Bit value</returns>
|
|
public bool GetBitAt(uint bitIndex)
|
|
{
|
|
if (bitIndex >= capacity)
|
|
throw new IndexOutOfRangeException("Index out of bound in BitArray" + capacity);
|
|
return GetBitAt_Internal(bitIndex);
|
|
}
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
abstract protected bool GetBitAt_Internal(uint bitIndex);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
public void SetBitAt(uint bitIndex, bool value)
|
|
{
|
|
if (bitIndex >= capacity)
|
|
throw new IndexOutOfRangeException("Index out of bound in BitArray" + capacity);
|
|
SetBitAt_Internal(bitIndex, value);
|
|
}
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
abstract protected void SetBitAt_Internal(uint bitIndex, bool value);
|
|
|
|
/// <summary>Sync again every serializedProperty</summary>
|
|
protected void ResyncSerialization()
|
|
{
|
|
foreach (var property in m_SerializedProperties)
|
|
property.serializedObject.ApplyModifiedProperties();
|
|
Update();
|
|
}
|
|
|
|
/// <summary>Sync the reflected value with target value change</summary>
|
|
public void Update()
|
|
{
|
|
foreach (var property in m_SerializedProperties)
|
|
property.serializedObject.Update();
|
|
m_SerializedProperty.serializedObject.Update();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 8bit capacity</summary>
|
|
public sealed class SerializedBitArray8 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray8(SerializedProperty serializedProperty) : base(serializedProperty, 8u)
|
|
=> m_Data = m_SerializedProperty.FindPropertyRelative("data");
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> (HasMultipleDifferentValuesBitwise(m_Data) & (1 << (int)bitIndex)) != 0;
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get8(bitIndex, (byte)m_Data.intValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
byte versionedData = (byte)property.FindPropertyRelative("data").intValue;
|
|
BitArrayUtilities.Set8(bitIndex, ref versionedData, value);
|
|
property.FindPropertyRelative("data").intValue = versionedData;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 16bit capacity</summary>
|
|
public sealed class SerializedBitArray16 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray16(SerializedProperty serializedProperty) : base(serializedProperty, 16u)
|
|
=> m_Data = m_SerializedProperty.FindPropertyRelative("data");
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> (HasMultipleDifferentValuesBitwise(m_Data) & (1 << (int)bitIndex)) != 0;
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get16(bitIndex, (ushort)m_Data.intValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
ushort versionedData = (ushort)property.FindPropertyRelative("data").intValue;
|
|
BitArrayUtilities.Set16(bitIndex, ref versionedData, value);
|
|
property.FindPropertyRelative("data").intValue = versionedData;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 32bit capacity</summary>
|
|
public sealed class SerializedBitArray32 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray32(SerializedProperty serializedProperty) : base(serializedProperty, 32u)
|
|
=> m_Data = m_SerializedProperty.FindPropertyRelative("data");
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> (HasMultipleDifferentValuesBitwise(m_Data) & (1 << (int)bitIndex)) != 0;
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get32(bitIndex, (uint)m_Data.intValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
int versionedData = property.FindPropertyRelative("data").intValue;
|
|
uint trueData;
|
|
unsafe
|
|
{
|
|
trueData = *(uint*)(&versionedData);
|
|
}
|
|
BitArrayUtilities.Set32(bitIndex, ref trueData, value);
|
|
unsafe
|
|
{
|
|
versionedData = *(int*)(&trueData);
|
|
}
|
|
property.FindPropertyRelative("data").intValue = versionedData;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 64bit capacity</summary>
|
|
public sealed class SerializedBitArray64 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray64(SerializedProperty serializedProperty) : base(serializedProperty, 64u)
|
|
=> m_Data = m_SerializedProperty.FindPropertyRelative("data");
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> HasBitMultipleDifferentValue_For64Bits("data", m_Data, bitIndex);
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get64(bitIndex, (ulong)m_Data.longValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
long versionedData = property.FindPropertyRelative("data").longValue;
|
|
ulong trueData;
|
|
unsafe
|
|
{
|
|
trueData = *(ulong*)(&versionedData);
|
|
}
|
|
BitArrayUtilities.Set64(bitIndex, ref trueData, value);
|
|
unsafe
|
|
{
|
|
versionedData = *(long*)(&trueData);
|
|
}
|
|
property.FindPropertyRelative("data").longValue = versionedData;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 128bit capacity</summary>
|
|
public sealed class SerializedBitArray128 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data1;
|
|
SerializedProperty m_Data2;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray128(SerializedProperty serializedProperty) : base(serializedProperty, 128u)
|
|
{
|
|
m_Data1 = m_SerializedProperty.FindPropertyRelative("data1");
|
|
m_Data2 = m_SerializedProperty.FindPropertyRelative("data2");
|
|
}
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> bitIndex < 64u
|
|
? HasBitMultipleDifferentValue_For64Bits("data1", m_Data1, bitIndex)
|
|
: HasBitMultipleDifferentValue_For64Bits("data2", m_Data2, bitIndex - 64u);
|
|
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get128(
|
|
bitIndex,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data1").longValue,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data2").longValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
long versionedData1 = property.FindPropertyRelative("data1").longValue;
|
|
long versionedData2 = property.FindPropertyRelative("data2").longValue;
|
|
ulong trueData1;
|
|
ulong trueData2;
|
|
unsafe
|
|
{
|
|
trueData1 = *(ulong*)(&versionedData1);
|
|
trueData2 = *(ulong*)(&versionedData2);
|
|
}
|
|
BitArrayUtilities.Set128(bitIndex, ref trueData1, ref trueData2, value);
|
|
unsafe
|
|
{
|
|
versionedData1 = *(long*)(&trueData1);
|
|
versionedData2 = *(long*)(&trueData2);
|
|
}
|
|
property.FindPropertyRelative("data1").longValue = versionedData1;
|
|
property.FindPropertyRelative("data2").longValue = versionedData2;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
|
|
/// <summary>SerializedBitArray spetialized for 256bit capacity</summary>
|
|
public sealed class SerializedBitArray256 : SerializedBitArray
|
|
{
|
|
SerializedProperty m_Data1;
|
|
SerializedProperty m_Data2;
|
|
SerializedProperty m_Data3;
|
|
SerializedProperty m_Data4;
|
|
|
|
/// <summary>Constructor</summary>
|
|
/// <param name="serializedProperty">The SerializedProperty</param>
|
|
public SerializedBitArray256(SerializedProperty serializedProperty) : base(serializedProperty, 128u)
|
|
{
|
|
m_Data1 = m_SerializedProperty.FindPropertyRelative("data1");
|
|
m_Data2 = m_SerializedProperty.FindPropertyRelative("data2");
|
|
m_Data3 = m_SerializedProperty.FindPropertyRelative("data3");
|
|
m_Data4 = m_SerializedProperty.FindPropertyRelative("data4");
|
|
}
|
|
|
|
/// <summary>Say if the properties have differente values</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>True: properties have different value</returns>
|
|
protected override bool HasBitMultipleDifferentValue_Internal(uint bitIndex)
|
|
=> bitIndex < 128u
|
|
? bitIndex < 64u
|
|
? HasBitMultipleDifferentValue_For64Bits("data1", m_Data1, bitIndex)
|
|
: HasBitMultipleDifferentValue_For64Bits("data2", m_Data2, bitIndex - 64u)
|
|
: bitIndex < 192u
|
|
? HasBitMultipleDifferentValue_For64Bits("data3", m_Data3, bitIndex - 128u)
|
|
: HasBitMultipleDifferentValue_For64Bits("data4", m_Data4, bitIndex - 192u);
|
|
|
|
/// <summary>Get the value at index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <returns>Value at the index</returns>
|
|
protected override bool GetBitAt_Internal(uint bitIndex)
|
|
=> BitArrayUtilities.Get256(
|
|
bitIndex,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data1").longValue,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data2").longValue,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data3").longValue,
|
|
(ulong)m_SerializedProperty.FindPropertyRelative("data4").longValue);
|
|
|
|
/// <summary>Set the bit at given index</summary>
|
|
/// <param name="bitIndex">The index</param>
|
|
/// <param name="value">The value</param>
|
|
protected override void SetBitAt_Internal(uint bitIndex, bool value)
|
|
{
|
|
foreach (var property in GetOrInitializeSerializedProperties())
|
|
{
|
|
long versionedData1 = property.FindPropertyRelative("data1").longValue;
|
|
long versionedData2 = property.FindPropertyRelative("data2").longValue;
|
|
long versionedData3 = property.FindPropertyRelative("data3").longValue;
|
|
long versionedData4 = property.FindPropertyRelative("data4").longValue;
|
|
ulong trueData1;
|
|
ulong trueData2;
|
|
ulong trueData3;
|
|
ulong trueData4;
|
|
unsafe
|
|
{
|
|
trueData1 = *(ulong*)(&versionedData1);
|
|
trueData2 = *(ulong*)(&versionedData2);
|
|
trueData3 = *(ulong*)(&versionedData3);
|
|
trueData4 = *(ulong*)(&versionedData4);
|
|
}
|
|
BitArrayUtilities.Set256(bitIndex, ref trueData1, ref trueData2, ref trueData3, ref trueData4, value);
|
|
unsafe
|
|
{
|
|
versionedData1 = *(long*)(&trueData1);
|
|
versionedData2 = *(long*)(&trueData2);
|
|
versionedData3 = *(long*)(&trueData3);
|
|
versionedData4 = *(long*)(&trueData4);
|
|
}
|
|
property.FindPropertyRelative("data1").longValue = versionedData1;
|
|
property.FindPropertyRelative("data2").longValue = versionedData2;
|
|
property.FindPropertyRelative("data3").longValue = versionedData3;
|
|
property.FindPropertyRelative("data4").longValue = versionedData4;
|
|
}
|
|
ResyncSerialization();
|
|
}
|
|
}
|
|
}
|