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