Obtención de los vértices de la backbuffer (HLSL) en XNA

Question

Hola y lo siento por el título oscura:} I para explicar lo mejor que pueda.

En primer lugar, soy nuevo en HLSL pero entiendo sobre la tubería y otras cosas que son del mundo de las hadas. Lo que estoy tratando de hacer es utilizar la GPU para cálculos generales (GPGPU).

Lo que don `t saber es: ¿Cómo puedo leer * los vértices (que han sido transformadas utilizando vertex shaders) de nuevo a mi solicitud XNA? He leído algo acerca del uso de la memoria de textura de la GPU, pero no puedo encontrar nada sólido ...

Gracias de antemano por cualquier información / punta! : -)

* no está seguro de si es posible dispensada de la impresora de trama y el sombreado de píxeles (si lo hay), es decir, en el extremo que es todo acerca de píxeles, ¿verdad?

Answer 1

Por lo que yo sé que esto no es posible en general.

¿Qué es exactamente estás tratando de hacer? Es probable que haya otra solución

EDITAR :: Teniendo en cuenta el comentario. Si todo lo que quiere hacer es cálculos vectoriales generales sobre la GPU intentan hacerlas en el sombreado de píxeles más que el vertex shader.

Así, por ejemplo, digamos que usted quiere hacer la cruz dos vectores, primero tenemos que escribir los datos en una textura

//Data must be in the 0-1 range before writing into the texture, so you'll need to scale everything appropriately
Vector4 a = new Vector4(1, 0, 1, 1);
Vector4 b = new Vector4(0, 1, 0, 0);

Texture2D dataTexture = new Texture2D(device, 2, 1);
dataTexture.SetData<Vector4>(new Vector4[] { a, b });

Así que ahora tenemos una textura 2 * 1 con los datos, hacer que el simple uso de la textura y un efecto SpriteBatch:

Effect gpgpu;
gpgpu.Begin();
gpgpu.CurrentTechnique = gpgpu.Techniques["DotProduct"];
gpgpu.CurrentTechnique.Begin();
spriteBatch.Begin();
gpgpu.CurrentTechnique.Passes[0].Begin();
spriteBatch.Draw(dataTexture, new Rectangle(0,0,2,1), Color.White);
spriteBatch.end();
gpgpu.CurrentTechnique.Passes[0].End();
gpgpu.CurrentTechnique.End();

Todo lo que necesitamos ahora es el efecto GPGPU he mostrado anteriormente. Eso es sólo un shader procesamiento posterior a la norma, buscando algo como esto:

sampler2D DataSampler = sampler_state
{
    MinFilter = Point;
    MagFilter = Point;
    MipFilter = Point;
    AddressU = Clamp;
    AddressV = Clamp;
};

float4 PixelShaderFunction(float2 texCoord : TEXCOORD0) : COLOR0
{
    float4 A = tex2D(s, texCoord);
    float4 B = tex2D(s, texCoord + float2(0.5, 0); //0.5 is the size of 1 pixel, 1 / textureWidth
    float d = dot(a, b)
    return float4(d, 0, 0, 0);
}

technique DotProduct
{
    pass Pass1
    {
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}

Esto escribirá el producto escalar de A y B en el primer elemento de imagen, y el producto escalar de B y B en el segundo píxel. A continuación, puede leer estas respuestas posterior (ignorando los inútiles)

Vector4[] v = new Vector4[2];
dataTexture.GetData(v);
float dotOfAandB = v[0];
float dotOfBandB = v[1];

Tada! Hay toda una carga de pequeños problemas con tratar de hacer esto en una escala más grande, comentar aquí y voy a tratar de ayudarle con cualquier ejecuta en:)

Answer 2

Si se enciende el " Corriente de salida etapa ," las salidas de su vertex shader será almacenada en una memoria intermedia. Posteriormente estos valores se pueden leer desde la GPU o CPU como se desee.