public static unsafe bool IsOutsidePlanes(ref BlobArray <float4> planes, float4 localVertex)
{
const float kEpsilon = CSGConstants.kDistanceEpsilon;
var planePtr = (float4 *)planes.GetUnsafePtr();
int n = 0;
for (; n + 4 < planes.Length; n += 4)
{
var distance = new float4(math.dot(planePtr[n + 0], localVertex),
math.dot(planePtr[n + 1], localVertex),
math.dot(planePtr[n + 2], localVertex),
math.dot(planePtr[n + 3], localVertex));
// will be 'false' when distance is NaN or Infinity
if (!math.all(distance <= kEpsilon))
{
return(true);
}
}
for (; n < planes.Length; n++)
{
var distance = math.dot(planePtr[n], localVertex);
// will be 'false' when distance is NaN or Infinity
if (!(distance <= kEpsilon))
{
return(true);
}
}
return(false);
}
public static void AddRangeFromBlob <T>(this NativeList <T> list, ref BlobArray <T> data) where T : struct
{
for (int i = 0; i < data.Length; i++)
{
list.Add(data[i]);
}
}
public static void Main(string[] args)
{
var m = new Moo();
var a = new BlobArray<uint>();
a.Add(89);
a.Add(99);
a.Add(109);
m.Po = a;
m.Text = "A string!";
m.Array[0].Meh = 7;
m.Array[1].Beh = 2.7f;
m.Array2[0][1] = 2;
BlobSerializer s = new BlobSerializer();
s.BigEndian = false;
s.Write(m);
using (Stream data = File.OpenWrite("output"))
using (Stream relocs = File.OpenWrite("output.relocs"))
{
s.GenerateOutput(data, relocs);
}
}
private JobHandle SchedulePersistJobs(JobHandle inputDeps, PersistentDataContainer dataContainer, ComponentTypeHandle <PersistenceState> persistenceStateTypeHandle)
{
var returnJobHandle = inputDeps;
for (int persistenceArchetypeIndex = 0; persistenceArchetypeIndex < dataContainer.DataLayoutCount; persistenceArchetypeIndex++)
{
PersistencyArchetypeDataLayout dataLayout = dataContainer.GetDataLayoutAtIndex(persistenceArchetypeIndex);
ref BlobArray <PersistencyArchetypeDataLayout.TypeInfo> typeInfoArray = ref dataLayout.PersistedTypeInfoArrayRef.Value;
PersistencyContainerTag containerTag = new PersistencyContainerTag {
DataIdentifier = dataContainer.DataIdentifier
};
PersistableTypeCombinationHash persistableTypeCombinationHash = new PersistableTypeCombinationHash {
Value = dataLayout.PersistableTypeHandleCombinationHash
};
for (int typeInfoIndex = 0; typeInfoIndex < typeInfoArray.Length; typeInfoIndex++)
{
// type info
PersistencyArchetypeDataLayout.TypeInfo typeInfo = typeInfoArray[typeInfoIndex];
ComponentType runtimeType = ComponentType.ReadOnly(PersistencySettings.GetTypeIndex(typeInfo.PersistableTypeHandle));
int stride = typeInfo.ElementSize * typeInfo.MaxElements + PersistenceMetaData.SizeOfStruct;
int byteSize = dataLayout.Amount * stride;
// query
var query = PersistableEntitiesQuery;
query.SetSharedComponentFilter(containerTag, persistableTypeCombinationHash);
JobHandle jobHandle;
if (typeInfo.IsBuffer)
{
jobHandle = new CopyBufferElementsToByteArray
{
BufferTypeHandle = GetDynamicComponentTypeHandle(runtimeType),
MaxElements = typeInfo.MaxElements,
PersistenceStateType = persistenceStateTypeHandle,
RawContainerData = dataContainer.GetRawData(),
SubArrayOffset = dataLayout.Offset + typeInfo.Offset,
SubArrayByteSize = byteSize,
ElementSize = typeInfo.ElementSize
}.Schedule(query, inputDeps);
}
else
{
jobHandle = new CopyComponentDataToByteArray()
{
ComponentTypeHandle = GetDynamicComponentTypeHandle(runtimeType),
TypeSize = typeInfo.ElementSize,
PersistenceStateType = persistenceStateTypeHandle,
RawContainerData = dataContainer.GetRawData(),
SubArrayOffset = dataLayout.Offset + typeInfo.Offset,
SubArrayByteSize = byteSize
}.Schedule(query, inputDeps);
}
query.ResetFilter();
returnJobHandle = JobHandle.CombineDependencies(returnJobHandle, jobHandle);
}
}
public unsafe static void ClearValues <T>(ref BlobArray <T> array) where T : unmanaged
{
if (array.Length == 0)
{
return;
}
UnsafeUtility.MemSet(array.GetUnsafePtr(), 0, array.Length * sizeof(T));
}
public static void AllocateArray <T>(this BlobBuilder builder, ref BlobArray <T> blobArray, IList <T> sourceArray) where T : struct
{
var array = builder.Allocate(ref blobArray, sourceArray.Count);
for (var i = 0; i < sourceArray.Count; i++)
{
array[i] = sourceArray[i];
}
}
public static void AddRangeNoResize <T>(this NativeList <T> list, ref BlobArray <T> elements, int length) where T : unmanaged
{
CheckLengthInRange(length, elements.Length);
if (length == 0)
{
return;
}
list.AddRangeNoResize(elements.GetUnsafePtr(), length);
}
public override void Build(BlobBuilder builder, ref BlobArray <T> data)
{
var arrayBuilder = builder.Allocate(ref data, Value.Length);
for (var i = 0; i < Value.Length; i++)
{
((Builder <T>)Value[i]).Build(builder, ref arrayBuilder[i]);
}
}
//[MethodImpl(MethodImplOptions.NoInlining)]
void FindInsideVertices(ref BlobArray <float3> usedVertices0,
ref BlobArray <ushort> vertexIntersectionPlanes,
ref BlobArray <int2> vertexIntersectionSegments,
ref BlobArray <float4> intersectingPlanes1,
float4x4 nodeToTreeSpaceMatrix1,
float4x4 vertexToLocal0,
//ref HashedVertices hashedVertices,
NativeArray <PlaneVertexIndexPair> foundIndices0,
ref int foundIndices0Length)
{
var localVertices = stackalloc float4[usedVertices0.Length];
var usedVertexIndices = stackalloc ushort[usedVertices0.Length];
var foundVertexCount = 0;
for (int j = 0; j < usedVertices0.Length; j++)
{
var brushVertex1 = new float4(usedVertices0[j], 1);
localVertices[j] = math.mul(vertexToLocal0, brushVertex1);
usedVertexIndices[j] = (ushort)j;
}
foundVertexCount = usedVertices0.Length;
for (int j = foundVertexCount - 1; j >= 0; j--)
{
if (IsOutsidePlanes(ref intersectingPlanes1, localVertices[j]))
{
if (j < foundVertexCount - 1)
{
localVertices[j] = localVertices[foundVertexCount - 1];
usedVertexIndices[j] = usedVertexIndices[foundVertexCount - 1];
}
foundVertexCount--;
}
}
for (int j = 0; j < foundVertexCount; j++)
{
var usedVertexIndex = usedVertexIndices[j];
var segment = vertexIntersectionSegments[usedVertexIndex];
if (segment.y == 0)
{
continue;
}
var treeSpaceVertex = math.mul(nodeToTreeSpaceMatrix1, localVertices[j]).xyz;
var treeSpaceVertexIndex = hashedVertices.AddNoResize(treeSpaceVertex);
for (int i = segment.x; i < segment.x + segment.y; i++)
{
var planeIndex = vertexIntersectionPlanes[i];
foundIndices0[foundIndices0Length] = new PlaneVertexIndexPair {
planeIndex = (ushort)planeIndex, vertexIndex = (ushort)treeSpaceVertexIndex
};
foundIndices0Length++;
}
}
}
/// Find a binding in a binding array.
public static int FindBindingIndex(ref BlobArray <StringHash> bindings, StringHash searchedBinding)
{
// TODO : Optimize
var i = 0;
while (i < bindings.Length && !bindings[i].Equals(searchedBinding))
{
++i;
}
return(i < bindings.Length ? i : -1);
}
public static float CalculateScore(ref BlobArray <ConsiderationBase> considerations, ref NativeArray <float> inputs)
{
var score = 0f;
for (int i = 0; i < considerations.Length; i++)
{
score += considerations[i].Output(inputs[i]);
}
inputs.Dispose();
return(score /= considerations.Length);
}
public unsafe void ReplaceIfExists(ref BlobArray <float3> uniqueVertices)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
// Add Unique vertex
for (int i = 0; i < uniqueVertices.Length; i++)
{
var vertex = uniqueVertices[i];
HashedVerticesUtility.ReplaceIfExists((ushort *)m_HashTable, m_ChainedIndices, m_Vertices, vertex);
}
}
public static bool Contains <T>(ref BlobArray <T> array, T value)
where T : struct, IEquatable <T>
{
for (int i = 0; i < array.Length; i++)
{
if (array[i].Equals(value))
{
return(true);
}
}
return(false);
}
public static bool Contains <T>(ref BlobArray <T> array, T value)
where T : struct
{
for (int i = 0; i < array.Length; i++)
{
if (EqualityComparer <T> .Default.Equals(array[i], value))
{
return(true);
}
}
return(false);
}
public static void CopyFrom <T>(this NativeSlice <T> dstArray, int dstIndex, ref BlobArray <T> srcArray, int srcIndex, int srcCount) where T : unmanaged
{
CheckLengthInRange(srcCount, srcArray.Length);
CheckLengthInRange(srcCount, dstArray.Length);
CheckIndexInRangeInc(dstIndex, dstArray.Length - srcCount);
CheckIndexInRangeInc(srcIndex, srcArray.Length - srcCount);
var srcPtr = (T *)srcArray.GetUnsafePtr() + srcIndex;
var dstPtr = (T *)dstArray.GetUnsafePtr() + dstIndex;
UnsafeUtility.MemCpy(dstPtr, srcPtr, srcCount * UnsafeUtility.SizeOf <T>());
}
static int FindIndex(ref BlobArray <StringHash> ids, StringHash id)
{
for (int i = 0; i < ids.Length; ++i)
{
if (ids[i] == id)
{
return(i);
}
}
return(-1);
}
public static unsafe bool IsOutsidePlanes(ref BlobArray <float4> planes, float4 localVertex)
{
for (int n = 0; n < planes.Length; n++)
{
var distance = math.dot(planes[n], localVertex);
// will be 'false' when distance is NaN or Infinity
if (!(distance <= kDistanceEpsilon))
{
return(true);
}
}
return(false);
}
static void InitializeAxes(ref BlobBuilder blobBuilder, Axis[] axes, ref BlobArray <Axis> rigAxes)
{
if (axes == null || axes.Length == 0)
{
return;
}
var arrayBuilder = blobBuilder.Allocate(ref rigAxes, axes.Length);
for (int i = 0; i < axes.Length; ++i)
{
rigAxes[i] = axes[i];
}
}
void Draw(ref BlobArray <int> parentIndexes, ref DynamicBuffer <float4x4> localToWorldBuffer, Color color)
{
for (int i = 1; i != parentIndexes.Length; ++i)
{
var localToWorld = localToWorldBuffer[i];
var pIdx = parentIndexes[i];
var parentLocalToWorld = localToWorldBuffer[pIdx];
Vector3 p1 = localToWorld.c3.xyz;
Vector3 p2 = parentLocalToWorld.c3.xyz;
// DebugOverlay.DrawLine3D(p1, p2, color);
Debug.DrawLine(p1, p2, color);
}
}
public HashedVertices(ref BlobArray <float3> uniqueVertices, Allocator allocator = Allocator.Persistent)
: this(uniqueVertices.Length, allocator)
{
// Add Unique vertex
for (int i = 0; i < uniqueVertices.Length; i++)
{
var vertex = uniqueVertices[i];
var centerIndex = new int3((int)(vertex.x / kCellSize), (int)(vertex.y / kCellSize), (int)(vertex.z / kCellSize));
var hashCode = HashedVerticesUtility.GetHash(centerIndex);
var prevChainIndex = ((ushort *)m_HashTable)[hashCode];
var newChainIndex = m_ChainedIndices->Length;
m_Vertices->AddNoResize(vertex);
m_ChainedIndices->AddNoResize((ushort)prevChainIndex);
((ushort *)m_HashTable)[(int)hashCode] = (ushort)(newChainIndex + 1);
}
}
public unsafe void AddUniqueVertices(ref BlobArray <float3> uniqueVertices)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
#endif
// Add Unique vertex
for (int i = 0; i < uniqueVertices.Length; i++)
{
var vertex = uniqueVertices[i];
var centerIndex = new int3((int)(vertex.x / kCellSize), (int)(vertex.y / kCellSize), (int)(vertex.z / kCellSize));
var hashCode = HashedVerticesUtility.GetHash(centerIndex);
var prevChainIndex = ((ushort *)m_HashTable)[hashCode];
var newChainIndex = m_ChainedIndices->Length;
m_Vertices->AddNoResize(vertex);
m_ChainedIndices->AddNoResize((ushort)prevChainIndex);
((ushort *)m_HashTable)[(int)hashCode] = (ushort)(newChainIndex + 1);
}
}
RigRemapEntry[] GetMatchingRemapEntries(List <ChannelMap> channels, ref BlobArray <StringHash> sourceBindings, ref BlobArray <StringHash> destinationBindings, int offsetCount = 0)
{
var rigRemapEntry = new RigRemapEntry[channels.Count];
int count = 0;
for (int i = 0; i != channels.Count; i++)
{
var sourceIndex = Core.FindBindingIndex(ref sourceBindings, channels[i].SourceId);
var destinationIndex = Core.FindBindingIndex(ref destinationBindings, channels[i].DestinationId);
if (sourceIndex != -1 && destinationIndex != -1 && (channels[i].OffsetIndex == 0 || channels[i].OffsetIndex < offsetCount))
{
rigRemapEntry[count++] = new RigRemapEntry {
SourceIndex = sourceIndex, DestinationIndex = destinationIndex, OffsetIndex = channels[i].OffsetIndex
};
}
}
Array.Resize(ref rigRemapEntry, count);
return(rigRemapEntry);
}
void Method()
{
BlobArray <float> myFloats = _blobAssetReference.Value.myfloats;
EnsureNotOptimizedAway(myFloats.Length);
}
public override void Build(BlobBuilder builder, ref BlobArray <float> data)
{
float sum = Weights.Sum();
builder.AllocateArray(ref data, Weights.Select(w => w / sum).ToArray());
}
public static unsafe BlobBuilderArray <T> Construct <T>(this BlobBuilder builder, ref BlobArray <T> blobArray, HashedVertices data) where T : unmanaged
{
var blobBuilderArray = builder.Allocate(ref blobArray, data.Length);
if (data.Length > 0)
{
UnsafeUtility.MemCpy(blobBuilderArray.GetUnsafePtr(), data.GetUnsafeReadOnlyPtr(), blobBuilderArray.Length * sizeof(T));
}
return(blobBuilderArray);
}
public static unsafe BlobBuilderArray <T> Construct <T>(this BlobBuilder builder, ref BlobArray <T> blobArray, T *data, int length) where T : unmanaged
{
length = math.max(length, 0);
var blobBuilderArray = builder.Allocate(ref blobArray, length);
if (length > 0)
{
UnsafeUtility.MemCpy(blobBuilderArray.GetUnsafePtr(), data, blobBuilderArray.Length * sizeof(T));
}
return(blobBuilderArray);
}
public static unsafe BlobBuilderArray <T> Construct <T>(this BlobBuilder builder, ref BlobArray <T> blobArray, List <T> data) where T : unmanaged
{
var blobBuilderArray = builder.Allocate(ref blobArray, data.Count);
for (int i = 0; i < data.Count; i++)
{
blobBuilderArray[i] = data[i];
}
return(blobBuilderArray);
}
public static unsafe void CopyFrom <T>(this BlobBuilderArray <T> dstArray, ref BlobArray <T> srcArray) where T : unmanaged
{
UnsafeUtility.MemCpy(dstArray.GetUnsafePtr(), srcArray.GetUnsafePtr(), srcArray.Length * sizeof(T));
}
internal static unsafe ref T GetDataInSample <T>(ref BlobArray <float> samples, int offset)
where T : unmanaged
{
return(ref *(T *)((float *)samples.GetUnsafePtr() + offset));
}
static void TransformOtherIntoBrushSpace(ref float4x4 treeToBrushSpaceMatrix, ref float4x4 brushToTreeSpaceMatrix, ref BlobArray <float4> srcPlanes, float4 *dstPlanes)
{
var brush1ToBrush0LocalLocalSpace = math.transpose(math.mul(treeToBrushSpaceMatrix, brushToTreeSpaceMatrix));
for (int plane_index = 0; plane_index < srcPlanes.Length; plane_index++)
{
ref var srcPlane = ref srcPlanes[plane_index];
dstPlanes[plane_index] = math.mul(brush1ToBrush0LocalLocalSpace, srcPlane);
}
void Method()
{
BlobArray <float> myFloats = _blobAssetReference.Value.myfloats;
}
