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; }