public unsafe NatliveSliceIntPtr(NativeSlice <T> nativeSlice) { #if ENABLE_UNITY_COLLECTIONS_CHECKS safetyHandle = NativeSliceUnsafeUtility.GetAtomicSafetyHandle(nativeSlice); #endif data = new IntPtr(nativeSlice.GetUnsafeReadOnlyPtr()); length = nativeSlice.Length; stride = nativeSlice.Stride; }
public DataStreamReader(NativeSlice <byte> slice) { #if ENABLE_UNITY_COLLECTIONS_CHECKS m_Safety = NativeSliceUnsafeUtility.GetAtomicSafetyHandle(slice); #endif m_bufferPtr = (byte *)slice.GetUnsafeReadOnlyPtr(); m_Length = slice.Length; uint test = 1; unsafe { byte *test_b = (byte *)&test; IsLittleEndian = test_b[0] == 1; } }
public unsafe static AsyncRequestNativeArrayData CreateAndCheckAccess <T>(NativeSlice <T> array) where T : struct { AsyncRequestNativeArrayData result = default(AsyncRequestNativeArrayData); result.nativeArrayBuffer = array.GetUnsafePtr <T>(); result.lengthInBytes = (long)array.Length * (long)UnsafeUtility.SizeOf <T>(); AtomicSafetyHandle atomicSafetyHandle = NativeSliceUnsafeUtility.GetAtomicSafetyHandle <T>(array); int *ptr = (int *)((void *)atomicSafetyHandle.versionNode); bool flag = atomicSafetyHandle.version != (*ptr & -6); if (flag) { AtomicSafetyHandle.CheckWriteAndThrowNoEarlyOut(atomicSafetyHandle); } result.safetyHandle = atomicSafetyHandle; return(result); }
public static AsyncRequestNativeArrayData CreateAndCheckAccess <T>(NativeSlice <T> array) where T : struct { if (AtomicSafetyHandle.IsTempMemoryHandle(array.m_Safety)) { throw new ArgumentException("AsyncGPUReadback cannot use Temp memory as input since the result may only become available at an unspecified point in the future."); } var nativeArrayData = new AsyncRequestNativeArrayData(); nativeArrayData.nativeArrayBuffer = array.GetUnsafePtr(); nativeArrayData.lengthInBytes = (long)array.Length * UnsafeUtility.SizeOf <T>(); var handle = NativeSliceUnsafeUtility.GetAtomicSafetyHandle(array); var versionPtr = (int *)handle.versionNode; if (handle.version != ((*versionPtr) & AtomicSafetyHandle.WriteCheck)) { AtomicSafetyHandle.CheckWriteAndThrowNoEarlyOut(handle); } nativeArrayData.safetyHandle = handle; return(nativeArrayData); }
public unsafe void Execute(int i) { int j = vertexLookupData[i].x; int k = vertexLookupData[i].y; PerSkinJobData perSkinData = perSkinJobData[j]; float3 srcVertex = spriteSkinData[j].vertices[k]; float4 tangents = spriteSkinData[j].tangents[k]; var influence = spriteSkinData[j].boneWeights[k]; int bone0 = influence.boneIndex0 + perSkinData.bindPosesIndex.x; int bone1 = influence.boneIndex1 + perSkinData.bindPosesIndex.x; int bone2 = influence.boneIndex2 + perSkinData.bindPosesIndex.x; int bone3 = influence.boneIndex3 + perSkinData.bindPosesIndex.x; var spriteSkin = spriteSkinData[j]; byte *deformedPosOffset = (byte *)vertices.GetUnsafePtr(); NativeSlice <float3> deformableVerticesFloat3 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <float3>(deformedPosOffset + spriteSkin.deformVerticesStartPos, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount); #if ENABLE_UNITY_COLLECTIONS_CHECKS NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableVerticesFloat3, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices)); #endif if (spriteSkinData[j].hasTangents) { byte *deformedTanOffset = deformedPosOffset + spriteSkin.tangentVertexOffset + spriteSkin.deformVerticesStartPos; var deformableTangentsFloat4 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <float4>(deformedTanOffset, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount); var tangent = new float4(tangents.xyz, 0.0f); tangent = math.mul(finalBoneTransforms[bone0], tangent) * influence.weight0 + math.mul(finalBoneTransforms[bone1], tangent) * influence.weight1 + math.mul(finalBoneTransforms[bone2], tangent) * influence.weight2 + math.mul(finalBoneTransforms[bone3], tangent) * influence.weight3; #if ENABLE_UNITY_COLLECTIONS_CHECKS NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableTangentsFloat4, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices)); #endif deformableTangentsFloat4[k] = new float4(math.normalize(tangent.xyz), tangents.w); } deformableVerticesFloat3[k] = math.transform(finalBoneTransforms[bone0], srcVertex) * influence.weight0 + math.transform(finalBoneTransforms[bone1], srcVertex) * influence.weight1 + math.transform(finalBoneTransforms[bone2], srcVertex) * influence.weight2 + math.transform(finalBoneTransforms[bone3], srcVertex) * influence.weight3; }
public unsafe void Execute(int i) { if (!isSpriteSkinValidForDeformArray[i]) { return; } var spriteSkin = spriteSkinData[i]; byte *deformedPosOffset = (byte *)vertices.GetUnsafePtr(); NativeSlice <float3> deformableVerticesFloat3 = NativeSliceUnsafeUtility.ConvertExistingDataToNativeSlice <float3>(deformedPosOffset + spriteSkin.deformVerticesStartPos, spriteSkin.spriteVertexStreamSize, spriteSkin.spriteVertexCount); #if ENABLE_UNITY_COLLECTIONS_CHECKS NativeSliceUnsafeUtility.SetAtomicSafetyHandle(ref deformableVerticesFloat3, NativeSliceUnsafeUtility.GetAtomicSafetyHandle(vertices)); #endif bounds[i] = SpriteSkinUtility.CalculateSpriteSkinBounds(deformableVerticesFloat3); }