Manager.checkdeviceformat

[Haddd]

 Curiosamente, parece que no funciona correctamente la opción de comprobar si una textura es soportada como RenderTarget. Por ejemplo, ponga el formato que ponga, me dice que NO se soporta, y no es cierto...

Código [Seleccionar] Expand


           AdapterInformation ai = Manager.Adapters.Default;
           Format formato = Format.A2R10G10B10;

           // Comprobamos si se soporta este formato
           int result;
           if (!Manager.CheckDeviceFormat(ai.Adapter, DeviceType.Hardware, initialization.PresentParams.BackBufferFormat, Usage.RenderTarget, ResourceType.Textures, formato, out result))
           {
               HLogWriter.WriteLine("No soporta el formato A2R10G10B10. Error :" + result.ToString("x"));

               formato = Format.A8R8G8B8;
           }


¿veis algún error?

 Los metodos de DirectX9 no devuelven nunca verdadero o falso, si no un valor de tipo HRESULT (int) que debe ser validado con las macros SUCCEEDED o FAILED, o comparado con un valor de tipo D3DERR.

sustituye if(!... por if (FAILED(... , o haz una comparación posterior if (result!=D3D_OK)

Te hablo de C++ pero imagino que será igual en C#, mira a ver si es por eso.

[Ray]

 Se me olvidó identificarme.

Un saludo.

[Haddd]

 en Managed devuelve tru o false y en un parámetro devuelve el resultado.

 Pues entonces tienes que comprobar el resultado con D3D_OK o con la macro FAILED

Código [Seleccionar] Expand


if (FAILED(result))    {
   // ERROR
  }

o

if (result!=D3D_OK) {
   // ERROR
  }


D3D_OK vale 0 osea FALSE (cosas del DirectX) por eso no es es recomendable verificar los resultados a pelo, porque va a dar lo contrario.

[Ray]

 No se que pasa que me desregistra sin avisarme..

Mejor crea un manejador de errores general en el que puedas comprobar los "result" de cualquier metodo DirectX con los D3DERR, para que te devuelva el resultando y el mensaje correspondiente, algo asi:

Código [Seleccionar] Expand


if (result!=D3D_OK) {
  switch(result)  {
     case D3DERR_INVALIDCALL: MsgError="INVALID CALL"; break;
     case D3DERR_NOTAVAILABLE : MsgError="NOT AVAILABLE"; break;
     case D3DERR_OUTOFVIDEOMEMORY : MsgError="OUT OF VIDEO MEMORY"; break;
     default: MsgError="ERROR NO DEFINIDO";
     }
  }


Esos cuatro resultados son los mas habituales, puedes encontrarlos todos consultando los tipos enumerados D3DERR.

 Me da la impresión de que el if (!Manager.CheckDeviceFormat siempre te da (TRUE) porque al ser correcto te devuelve D3D_OK, y si lo niegas sería !D3D_OK = !0 = TRUE

Si sigue sin funcionar prueba a sustituirlo por if (FAILED(Manager.CheckDeviceFormat....

(Al final voy a tener que aprender C# para estar seguro de lo que digo)

[BeRSeRKeR]

 Como ha dicho Haddd, en Managed DX ese método devuelve un tipo bool y en C# un bool no puede equivaler a un int, por poner un ejemplo. Es decir, en C#, false no es 0 ni true es != 0 por lo que en este caso eso que hace Haddd está bien.

Las macros SUCCEED y FAILED no existen en Managed DX.

Además, en la documentación del Managed DX viene un ejemplo de cómo averiguar si la aceleradora soporta texturas HDR:

Código [Seleccionar] Expand

// check support for a Format.A16B16R16F render target
if (!Manager.CheckDeviceFormat(0, DeviceType.Hardware, adapterFormat,
                                 Usage.RenderTarget, ResourceType.CubeTexture,
                                 Format.A16B16G16R16F))
   return true;
else
   return false;


Como se puede ver el mecanismo es el mismo que sigue Haddd.

Saludos.

[Ray]

 Entonces es lo que imaginaba, la negación del resultado es TRUE (que sí soporta el formato)  incluso en C#.

Por lo tanto para enviar el mensaje de error (cuando no soporta el formato) hay que quitar la negación ( ! ), o colocar el mensaje en un "else"

aunque lo mejor para no liarse es usar

Código [Seleccionar] Expand


if (D3D_OK ==  CheckDeviceFormat(...) )  {
     //  OK
    }
else {
     //  FALLO
    }


por lo menos en C++.

[BeRSeRKeR]

 Bueno, ese ejemplo que he puesto antes sacado del SDK, se ve que es un poco engañoso porque hace que si el método CheckDeviceFormat devuelve false (if !CheckDeviceFormat), el método donde esté encapsulado ese código devuelve true...cuando lo lógico es que el método se llame algo así como "ComprobarQueElFormatoEstaSoportado", por lo que devolvería true si se soporta y no false como parece que hace el ejemplo ese.

En cualquier caso, CheckDeviceFormat devuelve true si se soporta el formato y false de lo contrario por lo que si pones el operador de negación, estás diciendo que si el método devuelve false, que haga lo que tenga que hacer porque el formato no es soportado. Así que eso está bien.

He estado depurando el código de uno de los ejemplos del SDK de DX (que lo hace igual que Haddd) y en dicho ejemplo sí funciona pero me he dado cuenta de que es porque el formato de backbuffer que le pasa es X8R8G8B8. En cuanto le he pasado A8R8G8B8 (que es el que le pasamos en Haddd), también devuelve que el formato no existe. Efectivamente he probado a poner en el código de Haddd el formato X8R8G8B8 y funciona.

Así que por alguna razón el CheckDeviceFormat dice que el formato A2R10G10B10 no es soportado en backbuffers A8R8G8B8, lo cual es totalmente falso ya que lo estamos utilizando sin problemas...no sé, será un bug, o a saber... :D

Saludos.

[Juan Mellado]

BeRSeRKeR,
el tercer parámetro de la función (adapterformat) espera recibir un "Adapter Format" válido para la tarjeta, no el formato del BackBuffer, ¿no?.

Mirando con el Caps Viewer, en mi tarjeta sólo aparecen dos valores válidos: X8R8G8B8 y R5G6B5.

Lo he probado, y sólo para esos dos formatos valida correctamente.

¿No será eso?

Es sólo una idea.

Saludos

[BeRSeRKeR]

 Pues es cierto, pero ahora mismo no recuerdo en qué método se especifica el formato del dispositivo... :D

Saludos.

[Ray]

 Efectivamente, he mirado por ahi algunos ejemplos y con TRUE pasa y con FALSE falla, (como debe ser), me había liado el ejemplo.

De todas formas he visto un ultimo parámetro que le pasais a la función "out result" que es un int al igual que el HRESULT de C++ que supuestamente deberá devolver el resultado.

Cuando falle comparad el resultado con D3DERR_INVALIDCALL, D3DERR_NOTAVAILABLE, etc...  para saber si la función ha fallado por no ser llamada correctamente o por un parámetro incorrecto, o si realmente es que no está soportada la textura.

Por lo menos que yo sepa así se hace en C++ para saber en que ha fallado el método (también es que existe más información claro).

En cualquier caso mi enhorabuena por el proyecto, es muy dificil hacer algo así,  y que funcione bién mucho más. y la cantidad de cosas que hay que saber y controlar. Por cierto.. lastima que no esté escrito en C++,  ...pero eso,  es otro hilo....

[Ray]

 

el tercer parámetro de la función (adapterformat) espera recibir un "Adapter Format" válido para la tarjeta, no el formato del BackBuffer, ¿no?.

¿No será eso?

Pues va a ser que sí.

según esta tabla de la ayuda de DirectX9:

Código [Seleccionar] Expand



BackBuffer or Display Formats

These formats are the only valid formats for a back buffer or a display.

Format Back buffer      Display

A2R10G10B10 x       x (full-screen mode only)
A8R8G8B8    x
X8R8G8B8    x       x
A1R5G5B5    x
X1R5G5B5    x       x
R5G6B5       x       x



el modo A8R8G8B8 no es soportado por ningún adaptador, aunque sí por los  BackBuffer.