testss
This commit is contained in:
@@ -0,0 +1,27 @@
|
||||
using UnityEngine.Rendering;
|
||||
|
||||
namespace UnityEditor.Rendering.Utilities
|
||||
{
|
||||
/// <summary>
|
||||
/// Editor MaterialQuality utility class.
|
||||
/// </summary>
|
||||
public static class EditorMaterialQualityUtilities
|
||||
{
|
||||
/// <summary>
|
||||
/// Get the material quality levels enabled in a keyword set.
|
||||
/// </summary>
|
||||
/// <param name="keywordSet">Input keywords.</param>
|
||||
/// <returns>All available MaterialQuality levels in the keyword set.</returns>
|
||||
public static MaterialQuality GetMaterialQuality(this ShaderKeywordSet keywordSet)
|
||||
{
|
||||
var result = (MaterialQuality)0;
|
||||
for (var i = 0; i < MaterialQualityUtilities.Keywords.Length; ++i)
|
||||
{
|
||||
if (keywordSet.IsEnabled(MaterialQualityUtilities.Keywords[i]))
|
||||
result |= (MaterialQuality)(1 << i);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,631 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user