Dibujo de líneas eficiente en Direct3D (Transformation2D?)

Question

Antecedentes: Estoy usando el contenedor SlimDX C # para DirectX, y estoy dibujando muchos sprites 2D usando la clase Sprite (tradicionalmente de la extensión Direct3DX en los dlls subyacentes). Estoy dibujando varios cientos de sprites en la pantalla a la vez, y el rendimiento es increíble: en mi núcleo cuádruple, está usando algo como el 3-6% del procesador para todo mi juego, incluida la lógica para más de 10,000 objetos, ai rutinas en un segundo subproceso, etc., etc. Así que claramente los sprites se están dibujando usando la aceleración de hardware completa, y todo está como debería ser.

Problema: El problema surge cuando comienzo a introducir llamadas a la clase Line. Tan pronto como dibuje 4 líneas (para un cuadro de selección de arrastre), el uso del procesador se dispara a 13-19%. ¡Esto es con solo cuatro líneas!

Cosas que he intentado:

1. Activar y desactivar el antialiasing de línea.
2. Activar y desactivar GLLines.
3. Llamar manualmente a line.begin y line.end alrededor de mis llamadas para dibujar.
4. Omitir todas las llamadas a line.begin y line.end.
5. Asegurarme de que mis llamadas a line.draw no están dentro de un bloque sprite.begin / sprite.end.
6. Llamando a line.draw dentro de un bloque sprite.begin / sprite.end.
7. Renderizando 4 líneas, o renderizando 300.
8. Desactivar todo el sprite y el renderizado de texto, y simplemente dejar el renderizado de línea por 4 líneas (para ver si esto fue algún tipo de problema de cambio de modo).
9. La mayoría de las combinaciones de lo anterior.

En general, ninguno de estos tuvo un impacto significativo en el rendimiento. # 3 redujo el uso del procesador en un 2%, pero aun así sigue siendo un 8% o más de lo que debería ser. Lo más extraño es que el n. ° 7 desde arriba tuvo un impacto absolutamente nulo en el rendimiento: fue tan lento con 4 líneas como con 300. Lo único que puedo imaginar es que esto se está ejecutando en software por alguna razón, y / o que está causando que la tarjeta gráfica cambie continuamente de un modo de dibujo a otro.

Enfoque matricial:

Si alguien sabe de alguna solución al problema anterior, ¡me encantaría escucharlo!

Pero tengo la suposición de que esto podría ser un problema dentro de directx en general, por lo que he estado siguiendo otra ruta: hacer mi propia línea basada en sprites. Esencialmente, tengo una imagen blanca de 1px, y estoy usando el color difuso y las transformaciones para dibujar las líneas. Esto funciona, en cuanto al rendimiento: dibujar 300 de las "líneas" como este me coloca en el rango de rendimiento de utilización del procesador 3-6% que estoy buscando en mi quad core.

Tengo dos problemas con mi técnica de línea de estiramiento de píxeles, con la que espero que alguien más conocedor de las transformaciones pueda ayudarme. Aquí está mi código actual para una línea horizontal:

    public void DrawLineHorizontal( int X1, int X2, int Y, float HalfHeight, Color Color )
    {
        float width = ( X2 - X1 ) / 2.0f;
        Matrix m = Matrix.Transformation2D( new Vector2( X1 + width, Y ), 0f, new Vector2( width, HalfHeight ),
            Vector2.Zero, 0, Vector2.Zero );
        sprite.Transform = m;

        sprite.Draw( this.tx, Vector3.Zero, new Vector3( X1 + width, Y, 0 ), Color );
    }

Esto funciona, en la medida en que dibuja líneas en su mayoría del tamaño correcto en la ubicación correcta de la pantalla. Sin embargo, las cosas parecen desplazarse hacia la derecha, lo cual es extraño. No estoy muy seguro de si mi enfoque matricial es correcto: solo quiero escalar un sprite 1x1 por una cantidad de píxeles horizontalmente y una cantidad diferente verticalmente. Entonces necesito poder posicionarlos; por el punto central está bien, y creo que eso es lo que tendré que hacer, pero si pudiera posicionarlo en la esquina superior izquierda, sería aún mejor. Esto parece un problema simple, pero mi conocimiento de las matrices es bastante débil.

Esto haría que las líneas puramente horizontales y verticalmente funcionen para mí, que es la mayor parte de la batalla. Podría vivir con eso y usar algún otro tipo de gráfico en ubicaciones que actualmente estoy usando líneas anguladas. Pero sería realmente bueno si hubiera una manera de dibujar líneas que estén en ángulo usando este enfoque de píxeles estirados. En otras palabras, dibuja una línea de 1,1 a 7,19, por ejemplo. Con la rotación de la matriz, etc., parece que esto es factible, pero no sé dónde comenzar, aparte de adivinar y comprobar

Answer 1

suena como un puesto de tubería. Está cambiando algún modo entre renderizar sprites y renderizar líneas, lo que obliga a la tarjeta gráfica a vaciar su canalización antes de comenzar con la nueva primitiva.

Antes de agregar las líneas, ¿eran esos sprites todos los que renderizó, o había otros elementos en la pantalla, que ya usaban otros modos?

Answer 2

Bien, he logrado que las líneas horizontales funcionen después de mucha experimentación. Esto funciona sin la extraña compensación que estaba viendo antes; el mismo principio funcionará también para líneas verticales. Esto tiene un rendimiento muy superior que el de la clase de línea, así que esto es lo que usaré para las líneas horizontales y verticales. Aquí está el código:

    public void DrawLineHorizontal( int X1, int X2, int Y, float HalfHeight, Color Color )
    {
        float width = ( X2 - X1 );
        Matrix m = Matrix.Transformation2D( new Vector2( X1, Y - HalfHeight ), 0f, new Vector2( width, HalfHeight * 2 ),
            Vector2.Zero, 0, Vector2.Zero );
        sprite.Transform = m;

        sprite.Draw( this.tx, Vector3.Zero, new Vector3( X1, Y - HalfHeight, 0 ), Color );
    }

Me gustaría tener una versión de esto que también funcione para líneas en ángulos (como se mencionó anteriormente). ¿Alguna sugerencia para eso?