¿Los valores de la matriz Float3 son diferentes en el sombreador de cómputo de lo que les envié como desde el script C # en la unidad?

Así que estoy usando un sombreador de cómputo en la unidad para encontrar grupos de vértices que se superponen (son los mismos que) otros grupos de vértices en un Vector3[].

Tengo una Lista < Lista < int > > llamada caras. Cada Lista en la lista de caras es un grupo de índices que apunta a la matriz de triángulos en una Malla. Esto es para que pueda tener varios triángulos que representen una cara de N lados.

Después de prepararme en C# para que la matriz de caras se convierta en algo que la GPU pueda entender, envío toda la malla y los datos de caras a Compute Shader:

Este código es para aquellos que necesitan ver todo. Me vuelvo más específico en la siguiente sección.

 public void ClearOverlap()
 {
 //faces
 ComputeBufferMatrix matrix = ListListIntToComputeBufferMatrix(faces);
 GlobalProperties.findOverlappingFaces.SetInt("width", matrix.width);
 GlobalProperties.findOverlappingFaces.SetInt("height", matrix.height);
 GlobalProperties.findOverlappingFaces.SetBuffer(0, "faces", matrix.computeBuffer);
 ComputeBuffer facesSharing = new ComputeBuffer(matrix.width * matrix.height, sizeof(int));
 int[] facesSharingArray = new int[matrix.width * matrix.height];
 facesSharing.SetData(facesSharingArray);
 GlobalProperties.findOverlappingFaces.SetBuffer(0, "facesSharing", facesSharing);
 //vertices
 ComputeBuffer vertices = new ComputeBuffer(mesh.vertices.Length, sizeof(float) * 3);
 vertices.SetData(mesh.vertices);
 GlobalProperties.findOverlappingFaces.SetBuffer(0, "vertices", vertices);
 //triangles
 ComputeBuffer triangles = new ComputeBuffer(mesh.triangles.Length, sizeof(int));
 vertices.SetData(mesh.triangles);
 GlobalProperties.findOverlappingFaces.SetBuffer(0, "triangles", triangles);
 //output
 ComputeBuffer output = new ComputeBuffer(matrix.height, sizeof(float) * 3);
 Vector3[] outputInfo = new Vector3[matrix.height];
 output.SetData(outputInfo);
 GlobalProperties.findOverlappingFaces.SetBuffer(0, "returnFaces", output);
 //dispatch
 GlobalProperties.findOverlappingFaces.Dispatch(0, matrix.height, 1, 1);
 //clear out overlapping faces
 output.GetData(outputInfo);
 for(int i = 0; i < outputInfo.Length; i+=1)
 {
 Debug.Log(outputInfo[i]);
 }
 Debug.Log(mesh.vertices.Length);
 Debug.Log(mesh.vertices[1000]);
 Debug.Log(outputInfo[0].x);
 Debug.Log(outputInfo[0].y);
 Debug.Log(outputInfo[1000].z);
 //dispose buffers
 matrix.computeBuffer.Dispose();
 vertices.Dispose();
 triangles.Dispose();
 output.Dispose();
 facesSharing.Dispose();
}

Aquí está la siguiente sección

El siguiente fragmento de código es la parte en la que envío los vértices de la malla al búfer de cómputo que luego establecerá el RWStructuredBuffer en el sombreador de cómputo llamado "vértices"

//vertices
ComputeBuffer vertices = new ComputeBuffer(mesh.vertices.Length, sizeof(float) * 3);
vertices.SetData(mesh.vertices);
GlobalProperties.findOverlappingFaces.SetBuffer(0, "vertices", vertices);

En ningún momento cambiaré los valores de los vértices después de configurarlos en el búfer de cálculo. Y antes de este punto los valores están perfectamente bien. De hecho, incluso después de enviar el sombreador de cálculo, los valores siguen estando bien. Solo cuando están en el sombreador de cómputo son malos.

Espero valores como 3,5, 0,5 y 10,5 (estoy trabajando con puntos de bloque para que estén 0,5 fuera de la cuadrícula). Sin embargo, obtengo valores como 2.8054E-42, 3.4563E-45... etc.

Nota IMPORTANTE

No estoy cambiando los valores en Compute Shader. Literalmente, los estoy escribiendo nuevamente en otro RWStructuredBuffer que está configurado en un Vector3[] diferente (pero del mismo tamaño) que "mesh.vertices".

Resumen

Vector3[] se cambia al ingresar al sombreador de cómputo. Ni antes ni después.

¿Alguien puede arrojar algo de luz sobre este problema porque he buscado en muchos foros y nadie parece haber experimentado este problema?

PD
: Incluso pensé que tal vez los bits de los puntos flotantes se volteaban durante el envío o algo así, así que fui a este sitio web ( https://www.h-schmidt.net/FloatConverter/IEEE754.html ) para ver cuál era el valor. es cuando los abro pero no es lo que está pasando.

Aquí está el código Compute Shader

Los vértices RWStructuredBuffer son los vértices y RWStructuredBuffer returnFaces es el otro Vector3[] que devuelve lo que está en la matriz de vértices. Es literalmente solo enviar valores y obtener los mismos valores. ¡Pero no son del mismo valor, que es el problema!

#pragma kernel CSMain
int width;
int height;
RWStructuredBuffer<int> faces;
RWStructuredBuffer<int> triangles;
RWStructuredBuffer<float3> vertices;
RWStructuredBuffer<int> facesSharing;
RWStructuredBuffer<float3> returnFaces;
[numthreads(1,1,1)]
void CSMain (uint3 id: SV_DispatchThreadID)
{
 returnFaces[id.x] = vertices[id.x];
}

Solución del problema

Tengo un problema similar! ¿Solucionaste este problema? Acabo de registrar una cuenta para preguntar

Convierto float3 en una matriz flotante en C#. Y procese la matriz flotante en el sombreador de cómputo. Pero, siento que esto es extraño.