ZFX
ZFX Neu
Home
Community
Neueste Posts
Chat
FAQ
IOTW
Tutorials
Bücher
zfxCON
ZFXCE
Mathlib
ASSIMP
NES
Wir über uns
Impressum
Regeln
Suchen
Mitgliederliste
Membername:
Passwort:
Besucher:
4422653
Jetzt (Chat):
30 (0)
Mitglieder:
5239
Themen:
24223
Nachrichten:
234554
Neuestes Mitglied:
-insane-

ZFX
Coding-Foren
DirectX API
Enumeration Direktx 9 -> 10
NormalSeite: 1 2 >
AutorThema
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Enumeration Direktx 9 -> 10Nach oben.
Hallo

Um im Vorfeld festzustellen ob ein Device bestimmte Einstellung verwenden kann wurde bei DirektX 9 ja CheckDeviceType verwendet.

Wie geht man denn da bei DirektX 10 vor umfestzustellen welchen Backbuffer und welches Darstellungsformat verwendet werden kann?

Hab da CheckFormatSupport gefunden aber das gibt nix zurück über den Backbuffer.

2 Mal gendert, zuletzt am 11.02.2009, 16:24:43 Uhr von exploid.
11.02.2009, 16:20:54 Uhr
Richard Schubert Offline
DX-Berater


Registriert seit:
05.12.2002

Berlin
85557876 rs@directx9.de
Re: Enumeration Direktx 9 -> 10Nach oben.
Die Mindestanforderungen für DX10 sind klar definiert. dafür gibt es in der doku irgendwo specs die das klären. es ist also in der regel nicht mehr nötig zu fragen ob ein bestimmtes feature unterstützt wird, da das fest steht. Es gibt eigentlich nur Abfragemechanismen für 128Bit framebuffer blending/filtering/MSAA. darüber hinaus ist es nur möglich via erstellung von DX11, DX10.1 devices möglich herauszufinden ob diese mit dessen specs unterstützt werden.

11.02.2009, 16:26:49 Uhr
DirectX 10
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
hallo

wow schnelle antwort.

was bedeutet denn specs?
achso specifications

1 Mal gendert, zuletzt am 11.02.2009, 16:49:15 Uhr von exploid.
11.02.2009, 16:38:18 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Man könnte doch trotzdem vorweg so einen Dialog starten der anzeigt welche Auflösungen, Devices(Hardware, Software und Reference), Displays möglich sind und den Benutzer eine Voreinstellung treffen zu lassen.
11.02.2009, 17:15:50 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
Man könnte auch einfach im Fenstermodus starten, den User das Fenster auf die Auflösung bringen lassen, die er gern hätte und die dazu nächstgelegene native Auflösung verwenden, wenn er in den Vollbildmodus schaltet.

Ist einfacher zu programmieren als ein zusätzlicher Dialog und intuitiver zu bedienen als eine Liste aus Zahlen und Frequenzen. Zudem ist das Starten im Fenstermodus zum Debuggen eh praktischer.

Devices auswählen ist auch nicht mehr. Man nimmt das Device, zu dem der Bildschirm gehört, auf dem sich das Fenster befindet. Für sowas wie Physik, also GPGPU, nimmt mal alles was man kriegt. Das haut in 99% der Fälle hin und verwirrt keine User. Software und Reference sind für nicht-Entwickler tabu.

Gruß, Ky
11.02.2009, 17:28:25 Uhr
PuMi Online ist nicht jeder!
ZFX'ler


Registriert seit:
02.04.2006

Berlin
266670062
Re: Enumeration Direktx 9 -> 10Nach oben.
1. DXGI Factory erstellen
2. Adapter enumerieren
2.1 Output-Objekte erhalten
2.2 Formate enumerieren (GetDisplayModeList und SDK)
3. Ggf. Adapterinformationen holen

Das war es dann für das Ausgabeformat . Dazu kannst du dir dann vom Adapter ne Desc holen und auch die Grafikkarte auswählen lassen.

War es das was du suchtest?
11.02.2009, 17:49:45 Uhr
Art Train Developer
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
hallo pumi

Ja genau das hab ich im groben so fertig.
Die Stelle mit einen möglichen Backbuffer auszuwählen war erreicht.

http://www.imgbox.de/users/public/images/x31572u107.jpg

Hier musste ich feststellen das es viele Änderungen gab. Den Code um auf die DXGI zuzugreifen wurden so vorbereitet:

Code:
#include 
#include \"stdio.h\"
#include \"string.h\"
#include \"d3d10.h\"


#pragma comment(lib, \"DXGI.lib\")

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdline, int nshowcmd )
{
    IDXGIFactory* pDXGIFactory;
    int OutputIndex = 0;
    IDXGIOutput* pOutput;
    IDXGIAdapter* pAdapter;
    int AdapterIndex = 0;
    DXGI_ADAPTER_DESC adapterDescription;
    FILE* pFile;
    wchar_t status[256];

    HRESULT hr = CreateDXGIFactory (__uuidof(IDXGIFactory), (void**)(&pDXGIFactory));
     
    if (hr != S_OK)
        return -1;

    pFile = fopen (\"loggraka.txt\",\"w\");
    if (pFile==NULL)
        // couldnt open file
        return -1;
    
     
    // Loop as long as DXGI returns valid adapters.
    while (pDXGIFactory->EnumAdapters (AdapterIndex, &pAdapter) == S_OK)
    {
        // Do something with the adapter object
        LARGE_INTEGER version;
 
        if (pAdapter->CheckInterfaceSupport (__uuidof (ID3D10Device), &version) != S_OK)
            // No D3D10
            printf(\"we have no support\");
        else {
            // Yes we can use D3D10
            printf(\"we have support\");    
            hr = pAdapter->GetDesc( &adapterDescription );
            fwprintf(pFile,L\"Grafikkarte: \");
            fwprintf(pFile,adapterDescription.Description);
            fwprintf(pFile,L\"\n\");

            DXGI_OUTPUT_DESC outputDescription;
            UINT numModes=0, uianzmodes=0;
            
             
            while (pAdapter->EnumOutputs (OutputIndex, &pOutput) == S_OK)
            {
                // Do something with the output object
                pOutput->GetDesc(&outputDescription);
                // Es gibt z. Zeitpunkt der Programmierung 99 Elemente von DXGI_FORMAT
                for(int DXGI_test=0; DXGI_test<200; DXGI_test++) {
                    //Funktion sucht Anzahl der Modes und speichert diese in numModes
                    pOutput->GetDisplayModeList(    (DXGI_FORMAT)DXGI_test,//DXGI_FORMAT_R8G8B8A8_UNORM,
                                                    DXGI_ENUM_MODES_SCALING , 
                                                    &numModes,
                                                    0
                                                    );

                    if(numModes) { 
                        fwprintf(pFile,L\"Modien gefunden für DXGI_FORMAT = \");
                        _itow(DXGI_test,status,10); 
                        fwprintf(pFile,status);
                        fwprintf(pFile,L\"\n\");
                        fwprintf(pFile,L\"Anzahl der Modien: \");
                        _itow(numModes,status,10); 
                        fwprintf(pFile,status);
                        fwprintf(pFile,L\"\n\");

                        DXGI_MODE_DESC* mode=new DXGI_MODE_DESC[numModes];

                        pOutput->GetDisplayModeList    (    (DXGI_FORMAT)DXGI_test, 
                                                        DXGI_ENUM_MODES_SCALING,
                                                        &numModes,
                                                        mode
                                                    );

                        for(int n=0; nRelease ();
             
                OutputIndex++;
            }
            fwprintf(pFile, L\"Gesammtdarstellungen: \");   _itow(uianzmodes,status,10); fwprintf(pFile, status);    fwprintf(pFile, L\"\n\"); 
                        

        }
                 
        pAdapter->Release (); // Don't forget to release when you are done
     
        AdapterIndex++;
    }

    if(pFile) { 
        fclose (pFile); 
        pFile = 0; 
    }
    pDXGIFactory->Release ();
    
}


Da bin ich jetzt dabei das in sinnvollere Klassen und Strukturen zu sortieren:

Code:
/*----------------------------------------------------------------*/
/*----------------------File: D3D_enum.h--------------------------*/ 
/*----------------------------------------------------------------*/
#ifndef D3D_ENUM_H
#define D3D_ENUM_H
#include         // type definitions
#include 
#include             // DXGI stuff 
#include \"d3d10.h\"
#include \"errors.h\"            // error codes

// D E F I N E S
#define MAXADAPTERS 31    // more adapters are not owned by a normal pc user
#define MAXCOMBOS 80    // max device combinations
#define MAXOUTPUTS 6    // max possible outputs
#define DXGI_MAX_DEVICE_IDENTIFIER_STRING 128


// P R O T O T Y P E S
void AddItem(HWND hWnd, TCHAR *ch, void *pData);
// helper functions
TCHAR* D3DDevTypeToString(D3D10_DRIVER_TYPE devType);
void* GetSelectedItem(HWND hWnd);

// device settings that combines adapter adjustments for Direct3D device
struct D3DEnumDeviceCombo {
    //D3D10_DRIVER_TYPE DeviceType;
    DXGI_FORMAT BackBufferFormat;
    DXGI_FORMAT AdapterFormatArray
    BOOL Windowed;    
}; // struct D3DEnumDeviceCombo
/*----------------------------------------------------------------*/

// all Output Devices capable to display scene
struct D3DEnumOutputInfo {
    IDXGIOutput*        pOutput;
    DXGI_OUTPUT_DESC    Desc;
}; // struct D3DEnumOutputInfo
/*----------------------------------------------------------------*/

// all devices capable to render
struct D3DEnumDeviceInfo {
    //UINT nAdapter;
    D3D10_DRIVER_TYPE    d3dDevType;                // HAL, SW, REF
    D3DEnumDeviceCombo    d3dCombo[MAXCOMBOS];    // combo
    UINT                nNumCombo;  // number of combos    
}; // struct D3DEnumDeviceInfo
/*----------------------------------------------------------------*/

// all adapter found
struct D3DEnumAdapterInfo {
    //UINT                nAdapter;
    IDXGIAdapter*        pIDXGIInterface;    // adapter interface
    DXGI_ADAPTER_DESC    Desc;                // Adapter description
    LARGE_INTEGER        version;            // The user mode driver version
    D3DEnumDeviceInfo    d3dDevs[3];            // list of devices
    UINT                nNumDevs;            // number of devices
    D3DEnumOutputInfo   d3dOutput[MAXOUTPUTS]; // list of outputs
    UINT                nOutputs;            // number of outputs
    
}; // struct D3DEnumAdapterInfo
/*----------------------------------------------------------------*/


/*// one for each AdapterFormat-BackbufferFormat-WindowMode
// (windowed or fullscreen) combination that is valid
struct BKCOMBOINFO {
   UINT       nAdapter;             // belongs to
   D3DDEVTYPE d3dDevType;           // HAL, SW, REF
   bool       bWindowed;            // windowed mode

   D3DFORMAT  fmtAdapter;           // pixelbuffer
   D3DFORMAT  fmtBackBuffer;        // backbuffer
   D3DFORMAT  fmtDepthStencil;      // z/stencil format

   DWORD      dwBehavior;           // vertex processing
   D3DMULTISAMPLE_TYPE msType;      // multisample type
   };
/*----------------------------------------------------------------*/

// up to three for each adapter
/*struct BKDEVICEINFO {
   UINT         nAdapter;        // belongs to
   D3DDEVTYPE   d3dDevType;      // HAL, SW, REF
   D3DCAPS9     d3dCaps;         // capabilites
   BKCOMBOINFO    d3dCombo[80];    // combo
   UINT         nNumCombo;       // number of combos
   };
/*----------------------------------------------------------------*/

// enumeration stuff
class D3DEnum {
    public:
        D3DEnum();
        ~D3DEnum();
        
        // enumerate everything
        HRESULT Enum(    HWND hAdapter, HWND hMode,
                        HWND hDevice,  HWND hAdapterFmt,
                        HWND hBackFmt, HWND hWnd,
                        HWND hFull,    FILE *pLog );
    private:
        DXGI_FORMAT    m_fmtAdapter[5]; // list of possible adapter formats
        UINT        m_nNumFmt;       // adapter formats possible

        // handle to GUI items given from d3d dialog
        HWND m_hADAPTER;        // adapter combobox 
        HWND m_hMODE;            // mode combobox
        HWND m_hDEVICE;            // device combobox
        HWND m_hADAPTERFMT;        // adapter format combobox
        HWND m_hBACKFMT;        // backbuffer fmt combobox
        HWND m_hWND;            // radiobtn windowed
        HWND m_hFULL;            // radiobtn fullscreen

        // Enum Adapter
        IDXGIFactory*        m_pDXGIFactory;        // Interface implements methods for generating DXGI objects
        UINT                m_uiNumAdapters;    // number of found adapters
        D3DEnumAdapterInfo    m_sAdapterInfo[MAXADAPTERS];        // Adapter information struct

        HRESULT EnumAdapters(void);                // Enumerate Adapters
        HRESULT EnumDisplayModes(D3DEnumAdapterInfo &);    // Enumerate the display modes on the adapter.
        HRESULT EnumCombos(D3DEnumDeviceInfo &); // device settings that combines adapter adjustments for Direct3D device
        HRESULT EnumerateOutputs(D3DEnumAdapterInfo &xAdapter); // Enumerate Outputs

        // combobox selection changed
        void ChangedAdapter(void);
        void ChangedDevice(void);

        // write to log file
        void Log(char *, ...);

        FILE    *m_pLog;        // log file opened by d3d class
}; // class
/*----------------------------------------------------------------*/
#endif

D3D_Enum.h

Code:
/*----------------------------------------------------------------*/
/*----------------------File: D3D_enum.cpp------------------------*/ 
/*----------------------------------------------------------------*/
#include \"d3d_enum.h\"


// L I B R A R I E S
#pragma comment(lib, \"DXGI.lib\")

// F U N C T I O N S ///////////////////////////////////////////////

// Ctor
D3DEnum::D3DEnum() {
    m_hADAPTER        = NULL;    
    m_hMODE            = NULL;        
    m_hDEVICE        = NULL;        
    m_hADAPTERFMT    = NULL;    
    m_hBACKFMT        = NULL;    
    m_hWND            = NULL;
    m_hFULL            = NULL;

    // Enum Adapter
    m_uiNumAdapters=0;
    memset(&m_sAdapterInfo[0], 0, sizeof(m_sAdapterInfo[0]) * MAXADAPTERS); // m_sAdapterInfo[all] = 0;
    for(UINT i=0; ifor(UINT k=0; k<3; k++)
            m_sAdapterInfo[i].d3dDevs[k].d3dDevType = D3D10_DRIVER_TYPE_NULL;
    }
    m_pDXGIFactory=NULL;


    //Log(\"[D3DEnum::D3DEnum]: online (waiting for enumeration call)\n\");
}
/*----------------------------------------------------------------*/

// Dtor
D3DEnum::~D3DEnum() { 
    if (m_pDXGIFactory) 
        m_pDXGIFactory->Release(); 
    m_pDXGIFactory = NULL;

    for(UINT i=0; i// Adapter Interface
        if (m_sAdapterInfo[i].pIDXGIInterface)
            m_sAdapterInfo[i].pIDXGIInterface->Release();
        m_sAdapterInfo[i].pIDXGIInterface=0;
        // Outputs
        for (UINT k=0; kRelease();
        }
    }
    Log(\"[D3DEnum::D3DEnum]: offline\n\");
}
/*----------------------------------------------------------------*/

/**
 * Enumerates all available display modes and fills the given combo
 * boxes with corresponding values.
 * -> IN: HWND - combobox to receive available adapters
 *        HWND - combobox used for display modes
 *        HWND - combobox used for device types
 *        HWND - combobox used for adapter formats
 *        HWND - combobox used for backbuffer formats
 *        HWND - radiobutton windowed
 *        HWND - radiobutton fullscreen
 *        FILE - already open log file
 */
HRESULT D3DEnum::Enum(    HWND hAdapter, HWND hMode,
                        HWND hDevice,  HWND hAdapterFmt,
                        HWND hBackFmt, HWND hWnd,
                        HWND hFull,    FILE *pLog ) {
                          
    HRESULT hr;
    
    if (pLog) m_pLog = pLog;
    Log(\"[D3DEnum::Enum]: online (waiting for enumeration to start)\n\");

    // save handles to comboboxes
    m_hADAPTER    = hAdapter;
    m_hMODE       = hMode;
    m_hDEVICE     = hDevice;
    m_hADAPTERFMT = hAdapterFmt;
    m_hBACKFMT    = hBackFmt;
    m_hWND        = hWnd;
    m_hFULL       = hFull;

    /*DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,     //This is DXUT's preferred mode

            DXGI_FORMAT_R8G8B8A8_UNORM,            
            DXGI_FORMAT_R16G16B16A16_FLOAT,
            DXGI_FORMAT_R10G10B10A2_UNORM*/
    // set allowed bpp formats
    m_fmtAdapter[0] = DXGI_FORMAT_R8G8B8A8_UNORM; 
    m_fmtAdapter[1] = DXGI_FORMAT_R16G16B16A16_FLOAT;  
    m_fmtAdapter[2] = DXGI_FORMAT_R10G10B10A2_UNORM;  

    m_nNumFmt = 3;

    // enumerate available adapters
    hr = EnumAdapters();
    
    // write found adapters to combolist field
    for (UINT i=0; i// make sure that adapter exists
        if(m_sAdapterInfo[i].pIDXGIInterface) {
            AddItem(m_hADAPTER,  m_sAdapterInfo[i].Desc.Description, &m_sAdapterInfo[i]);
            hr = EnumerateOutputs(m_sAdapterInfo[i]);
        } // if
    } // for

    // Enumerate the device driver types on the adapter.
    for (UINT i=0; i// for 

    // treat enum like adapter change
    SendMessage(m_hADAPTER, CB_SETCURSEL, (WPARAM)0, 0);
    ChangedAdapter();
    // select first entry from each combo
    SendMessage(m_hADAPTER, CB_SETCURSEL, (WPARAM)0, 0);
    SendMessage(m_hMODE,    CB_SETCURSEL, (WPARAM)0, 0);
    SendMessage(m_hDEVICE,  CB_SETCURSEL, (WPARAM)0, 0);
    SendMessage(m_hBACKFMT, CB_SETCURSEL, (WPARAM)0, 0);
    SendMessage(m_hADAPTERFMT, CB_SETCURSEL, (WPARAM)0, 0);
    return S_OK;
}
/*----------------------------------------------------------------*/

HRESULT D3DEnum::EnumAdapters(void) {

    unsigned int uiAdapterIndex = 0;

    HRESULT hr = CreateDXGIFactory (__uuidof(IDXGIFactory), (void**)(&m_pDXGIFactory));
    if (hr != S_OK) {
        Log(\"[D3DEnum::EnumAdapters]: CreateDXGIFactory failed\n\");
        return _FAIL;
    }


    // Loop as long as DXGI returns valid adapters.
    while (m_pDXGIFactory->EnumAdapters (uiAdapterIndex, &m_sAdapterInfo[uiAdapterIndex].pIDXGIInterface) == S_OK) {
        
        // Check if device interface is supported by the system.
        if (m_sAdapterInfo[uiAdapterIndex].pIDXGIInterface->CheckInterfaceSupport (__uuidof (ID3D10Device), &m_sAdapterInfo[uiAdapterIndex].version) != S_OK) {
            Log(\"[D3DEnum::EnumAdapters]: CheckInterfaceSupport failed. Found not supported interface.\n\");
        }

        hr = m_sAdapterInfo[uiAdapterIndex].pIDXGIInterface->GetDesc( &m_sAdapterInfo[uiAdapterIndex].Desc );
        if (hr != S_OK) {
            Log(\"[D3DEnum::EnumAdapters]: GetDesc failed\n\");
            return _FAIL;
        }
        
        uiAdapterIndex++;
        // Check if System owns more interfaces than we can handle
        if(uiAdapterIndex == MAXADAPTERS){
            m_uiNumAdapters = uiAdapterIndex;
            Log(\"[D3DEnum::EnumAdapters]: Could not enumerate all adapters\n\");
            break;
        }    
    }

    m_uiNumAdapters = uiAdapterIndex;
    
    return _OK;
} // EnumAdapters
/*----------------------------------------------------------------*/

// Enumerate outputs
HRESULT D3DEnum::EnumerateOutputs(D3DEnumAdapterInfo &xAdapter) {
    HRESULT hr;
    IDXGIOutput* pOutput;

    for( int iOutput = 0; iOutputEnumOutputs( iOutput, &pOutput );
        if( hr == DXGI_ERROR_NOT_FOUND  )
        {
            return S_OK;
        }
        else if( FAILED( hr ) )
        {
            return hr;    //Something bad happened.
        }
        else //Success!
        {
            xAdapter.d3dOutput[iOutput].pOutput = pOutput;
            pOutput->GetDesc( &xAdapter.d3dOutput[iOutput].Desc );
            xAdapter.nOutputs++;
        }
    }
    return _OK;
}// EnumerateOutputs
/*----------------------------------------------------------------*/


// Enumerate device types
HRESULT D3DEnum::EnumDevices(D3DEnumAdapterInfo &xAdapter) {
    D3DEnumDeviceInfo  *pDev;
    IDXGIAdapter*        pAdapter = NULL;
    HRESULT                hr;

    const D3D10_DRIVER_TYPE d3dDriverTypes[] = {
        D3D10_DRIVER_TYPE_HARDWARE,
        D3D10_DRIVER_TYPE_REFERENCE,        
        D3D10_DRIVER_TYPE_SOFTWARE
    };

    xAdapter.nNumDevs = 0;

    for (UINT nDev=0; nDev<3; nDev++) {
        pDev = &xAdapter.d3dDevs[xAdapter.nNumDevs];

        //pDev->nNumCombo   = 0;
        //pDev->nAdapter    = xAdapter.nAdapter;
        pDev->d3dDevType  = d3dDriverTypes[nDev];
                    
        ID3D10Device* pd3dDevice = NULL;
        pAdapter = NULL;
        if( pDev->d3dDevType == D3D10_DRIVER_TYPE_HARDWARE )
            pAdapter = xAdapter.pIDXGIInterface;
        // will fail if unsupported devtype
        // Call D3D10CreateDevice to ensure that this is a D3D10 device.
        hr=D3D10CreateDevice( pAdapter, pDev->d3dDevType, ( HMODULE )0, 0,
                              D3D10_SDK_VERSION, &pd3dDevice );
        if(hr<0)
            continue;
        if ( pd3dDevice )    pd3dDevice->Release();
        // if we found a successful type store it
        xAdapter.d3dDevs[nDev].d3dDevType = pDev->d3dDevType;
        pd3dDevice = NULL;
        // this should not fail
        if (FAILED(hr=EnumCombos(*pDev)))
            return hr;
      
        // at least one supportet combo?
        //if (pDev->nNumCombo <= 0)
        //    continue;

        // keep valid device
        xAdapter.nNumDevs++;
    } // for

   return _OK;
} // EnumDevices
/*----------------------------------------------------------------*/

// device settings that contains a combination of 
// adapter format, back buffer format, and windowed
// that is compatible with a particular Direct3D device
HRESULT D3DEnum::EnumerateDisplayModes(D3DEnumDeviceInfo &xDev) {
    HRESULT hr = S_OK;
  
    return _OK;
} // EnumCombos
/*----------------------------------------------------------------*/

/**
 * write outputstring to attribut outputstream if exists
 * -> IN: FILE - pointer to logfile stream or NULL
 */
void D3DEnum::Log(char *chString, ...) {

   char ch[256];
   char *pArgs;
   
   pArgs = (char*) &chString + sizeof(chString);
   vsprintf_s(ch, sizeof(ch), chString, pArgs) ;
   fprintf(m_pLog, ch);
   
   #ifdef _DEBUGFLUSH_
   fflush(m_pLog);
   #endif
}
/*----------------------------------------------------------------*/

void AddItem(HWND hWnd, TCHAR *ch, void *pData) {
   WPARAM nI = (WPARAM)((int)(DWORD)SendMessage(hWnd,CB_ADDSTRING,0,(LPARAM)ch));
   SendMessage(hWnd,CB_SETITEMDATA, nI, (LPARAM)pData);
}
/*----------------------------------------------------------------*/

/**
 * Three helper function for combobox-convenience.
 */
void* GetSelectedItem(HWND hWnd) {
   WPARAM nI = (WPARAM)((int)(DWORD)SendMessage(hWnd,CB_GETCURSEL,0,0));
   return ((void*)SendMessage(hWnd,CB_GETITEMDATA,nI,0));
}
/*----------------------------------------------------------------*/

/**
 * Call when adapter selection changed. This will reset device
 * combobox, list devices for new adapter, and call ChangedDevice().
 */
void D3DEnum::ChangedAdapter(void) {
    D3DEnumAdapterInfo *pA=NULL;

    // delete content of device combobox
    SendMessage(m_hDEVICE, CB_RESETCONTENT, 0, 0);

    pA = (D3DEnumAdapterInfo *)GetSelectedItem(m_hADAPTER);

    for (UINT d=0; dnNumDevs; d++) {
        // write found devices to combolist field
        AddItem(m_hDEVICE, D3DDevTypeToString(pA->d3dDevs[d].
            d3dDevType), &pA->d3dDevs[d]);
    }
    SendMessage(m_hDEVICE, CB_SETCURSEL, (WPARAM)0, 0);
   
    // treat as if device selection changed
    ChangedDevice();
} // ChangedAdapter
/*----------------------------------------------------------------*/

/**
 * Call when device selection changed. This will reset radio button
 * states for windowed/fullscreen mode and call ChangedWindowMode().
 */
void D3DEnum::ChangedDevice(void) {
    D3DEnumDeviceCombo *pD=NULL;
    bool                bWindowed=false,
                        bFullscreen=false;

   pD = (D3DEnumDeviceCombo *)GetSelectedItem(m_hDEVICE);

   // check if windowed/fullscreen mode possible
/*   for (UINT c=0; cY->nNumCombo; c++) {
      if (pD->bWindowed)
         bWindowed = true;
      else
         bFullscreen = true;
      }*/

   // active radio buttons accordingliy
   EnableWindow(m_hWND,  bWindowed);
   EnableWindow(m_hFULL, bFullscreen);

   if (!bWindowed && (SendMessage(m_hWND,BM_GETCHECK,0,0)==BST_CHECKED))
      SendMessage(m_hFULL, BM_SETCHECK, BST_CHECKED, 0);

   // treat as if radio button changed
   //ChangedWindowMode();
   } // ChangedDevice
/*----------------------------------------------------------------*/

TCHAR* D3DDevTypeToString(D3D10_DRIVER_TYPE devType) {
    switch (devType) {
        case 0: /*D3D10_DRIVER_TYPE_HAL*/        return TEXT(\"D3D10_DRIVER_TYPE_HAL\");
        case 1: /*D3D10_DRIVER_TYPE_REFERENCE*/    return TEXT(\"D3D10_DRIVER_TYPE_REFERENCE\");
        case 3: /*D3D10_DRIVER_TYPE_SOFTWARE:*/    return TEXT(\"D3D10_DRIVER_TYPE_SOFTWARE\");
      
        default:                return TEXT(\"Unknown devType\");
    }
}
/*----------------------------------------------------------------*/

D3D_Enum.cpp

Das ganze befindet sich in einer Struktur von Applikation greift auf Library welche auf DLL zugreift.

also: Applikation -> Library -> DLL

Das finde ich gut als Ansatz für eine Funktionssammlung die ja beliebig erweiterbar ist mit dlls.

Das Problem ist jetzt halt zu erkennen wie die Direkt3D 10 Interface Architektur funktioniert um dem Benuter die Möglichkeit zu geben im Vorfeld bevor das Direkt3d 10 Device geöffnet wird einzustellen wie er die Szene dargestellt haben möchte. Also im Fenster, auf welchen Bildschirm, in welcher Auflösung, welche Farbanzahl usw.
11.02.2009, 18:36:02 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
bin jetzt im Direkt3d 10 Tutorial auf die Utilities aufmerksam geworden die machen bei der Auflösungssuche folgendermassen:

Code:
//--------------------------------------------------------------------------------------
HRESULT CD3D10Enumeration::EnumerateDisplayModes( CD3D10EnumOutputInfo* pOutputInfo )
{
    HRESULT hr = S_OK;
    DXGI_FORMAT allowedAdapterFormatArray[] =
        {
            DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,     //This is DXUT's preferred mode

            DXGI_FORMAT_R8G8B8A8_UNORM,            
            DXGI_FORMAT_R16G16B16A16_FLOAT,
            DXGI_FORMAT_R10G10B10A2_UNORM
        };
    int allowedAdapterFormatArrayCount = sizeof( allowedAdapterFormatArray ) / sizeof( allowedAdapterFormatArray[0] );

    // Swap perferred modes for apps running in linear space
    DXGI_FORMAT RemoteMode = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
    if( !DXUTIsInGammaCorrectMode() )
    {
        allowedAdapterFormatArray[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
        allowedAdapterFormatArray[1] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
        RemoteMode = DXGI_FORMAT_R8G8B8A8_UNORM;
    }

    // The fast path only enumerates R8G8B8A8_UNORM_SRGB modes
    if( !m_bEnumerateAllAdapterFormats )
        allowedAdapterFormatArrayCount = 1;

    for( int f = 0; f < allowedAdapterFormatArrayCount; ++f )
    {
        // Fast-path: Try to grab at least 512 modes.
        //              This is to avoid calling GetDisplayModeList more times than necessary.
        //              GetDisplayModeList is an expensive call.
        UINT NumModes = 512;
        DXGI_MODE_DESC* pDesc = new DXGI_MODE_DESC[ NumModes ];
        assert( pDesc );
        if( !pDesc )
            return E_OUTOFMEMORY;

        hr = pOutputInfo->m_pOutput->GetDisplayModeList( allowedAdapterFormatArray[f],
                                                         DXGI_ENUM_MODES_SCALING,
                                                         &NumModes,
                                                         pDesc );
        if( DXGI_ERROR_NOT_FOUND == hr )
        {
            SAFE_DELETE_ARRAY( pDesc );
            NumModes = 0;
            break;
        }
        else if( MAKE_DXGI_HRESULT( 34 ) == hr && RemoteMode == allowedAdapterFormatArray[f] )
        {
            // DXGI cannot enumerate display modes over a remote session.  Therefore, create a fake display
            // mode for the current screen resolution for the remote session.
            if( 0 != GetSystemMetrics( 0x1000 ) ) // SM_REMOTESESSION
            {
                DEVMODE DevMode;
                DevMode.dmSize = sizeof( DEVMODE );
                if( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &DevMode ) )
                {
                    NumModes = 1;
                    pDesc[0].Width = DevMode.dmPelsWidth;
                    pDesc[0].Height = DevMode.dmPelsHeight;
                    pDesc[0].Format = RemoteMode;
                    pDesc[0].RefreshRate.Numerator = 60;
                    pDesc[0].RefreshRate.Denominator = 1;
                    pDesc[0].ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE;
                    pDesc[0].Scaling = DXGI_MODE_SCALING_CENTERED;
                    hr = S_OK;
                }
            }
        }
        else if( DXGI_ERROR_MORE_DATA == hr )
        {
            // Slow path.  There were more than 512 modes.
            SAFE_DELETE_ARRAY( pDesc );
            hr = pOutputInfo->m_pOutput->GetDisplayModeList( allowedAdapterFormatArray[f],
                                                             DXGI_ENUM_MODES_SCALING,
                                                             &NumModes,
                                                             NULL );
            if( FAILED( hr ) )
            {
                NumModes = 0;
                break;
            }

            pDesc = new DXGI_MODE_DESC[ NumModes ];
            assert( pDesc );
            if( !pDesc )
                return E_OUTOFMEMORY;

            hr = pOutputInfo->m_pOutput->GetDisplayModeList( allowedAdapterFormatArray[f],
                                                             DXGI_ENUM_MODES_SCALING,
                                                             &NumModes,
                                                             pDesc );
            if( FAILED( hr ) )
            {
                SAFE_DELETE_ARRAY( pDesc );
                NumModes = 0;
                break;
            }

        }

        if( 0 == NumModes && 0 == f )
        {
            // No R8G8B8A8_UNORM_SRGB modes!
            // Abort the fast-path if we're on it
            allowedAdapterFormatArrayCount = sizeof( allowedAdapterFormatArray ) / sizeof
                ( allowedAdapterFormatArray[0] );
            SAFE_DELETE_ARRAY( pDesc );
            continue;
        }

        if( SUCCEEDED( hr ) )
        {
            for( UINT m = 0; m < NumModes; m++ )
            {
                pOutputInfo->displayModeList.Add( pDesc[m] );
            }
        }

        SAFE_DELETE_ARRAY( pDesc );
    }

    return hr;
}


Das ist aus DXUTEnum.cpp
11.02.2009, 18:40:17 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Hallo Krishty
[zitat] Man könnte auch einfach im Fenstermodus starten, den User das Fenster auf die Auflösung bringen lassen, die er gern hätte und die dazu nächstgelegene native Auflösung verwenden, wenn er in den Vollbildmodus schaltet.[/zitat]

Dem stimm ich zu

[zitat] Devices auswählen ist auch nicht mehr. Man nimmt das Device, zu dem der Bildschirm gehört, auf dem sich das Fenster befindet. Für sowas wie Physik, also GPGPU, nimmt mal alles was man kriegt. Das haut in 99% der Fälle hin und verwirrt keine User. Software und Reference sind für nicht-Entwickler tabu. [/zitat]

Der Dialog ist nur einmalig geplant beim Start. Die Einstellungen werden dann geloged und später geladen. Oder halt wenn es Probleme gibt mit dem Starten des Programms das man eine Analyse der Fehler bewerkstelligen kann und eine Lösung findet.

11.02.2009, 19:06:12 Uhr
PuMi Online ist nicht jeder!
ZFX'ler


Registriert seit:
02.04.2006

Berlin
266670062
Re: Enumeration Direktx 9 -> 10Nach oben.
Hallo,

:/ was ich so sehe: Du solltest den Codestil
wirklich verbessern. Wenn das jetzt ein File ist,
sei das ja (wenn es den temporär wäre) für
temporäre Zwecke ok. Aber wenn du das so
ausweitest, wird das wirklich unübersichtlich.
Daher einige Tipps die mir aufgefallen sind und
die aus meiner Erfahrung stammen:

Benutze FAILED() und SUCCEEDED(). Nehme dir ein
HRESULT in deiner Funktion und schreibe
if(FAILED(hr = ...)) oder if(SUCCEEDED(hr = ...)).
Wenn du einen Fehler hast, benutze
DXGetErrorString() und DXGetErrorDescription() um
HRESULT in Logfiles zu schreiben.

Wenn du Logfiles schreiben möchtest, schreibe dir
eine Logger-Klasse, erstelle davon ein statisches
Objekt und binde diese Headerdatei in jede
Quellcodedatei für gutes Logging ein. Damit die
Klasse auch Sinn hat schreibe Methoden wie diese:

Code:
static const bool Fail(const string &message) const
{
     ofstream stream = ofstream(cConfigFile, ios::app);
     stream << \"[E] \" << message.c_str() << \"\n\";
     ofstream.close();
     return false;
}
static const bool Sucess(const string &message) const
{
     ofstream stream = ofstream(cConfigFile, ios::app);
     stream << \"[S] \" << message.c_str() << \"\n\";
     ofstream.close();
     return true;
}


Dann gib deinen Variablen gute Namen und suche
für bestimmte Zwecke bestimmte Schreibvarianten.
Ich löse das bei mir seit meiner vierten Version
meiner Engine folgende Schreibweise für...

Klassen Class
Klassenmember (private): _XyzParam
Klassenmember (protected): __Evaluation;
Klassenmember (public): mIsPrepared;
Strukturenmember: MyValue;
Methode/Funktionsparameter: shortname
Variablenname: MyAdapterDevice;

Bei langen Quellcodes kann man schnell sehen wo
das steht und Visual Studio 2008 sortiert das mit
den Unterstrichen auch brav ganz nach unten .

Packe alles in Strukturen. Für n-Dimensionale
Datenverwaltung ist vector<> list<> etc. dein
Freund. Packe die Originalstrukturen (wie die
Output Descs) in vector<>. Biete dann zwei
Methoden an: Einmal um die Original DirectX-
Struktur zu erhalten und einmal eine Struktur von
dir mit den wichtigsten Daten. Wenn du den
Variablen namen gibst, dann gib Ihnen Fachnamen
wie sie in der Doku verwendet werden - damit
andere nicht herumrätseln müssen was du
eigentlich meinst (zum Beispiel RemoteMode). Auch
wenn es etwas anstrengend erscheint: Bei Listen
(Arrays, lists, vectors etc.) hinten immer den
Namen für die Mehrzahl angeben: Hier ein Beispiel
-> Adapters statt AdapterArray. Das das ein Array
dann ist, kann man aus der Mehrzahl verstehen
wenn kein IntelliSence an ist .

Dann noch etwas... wenn du Quellcode schreibt.
Dann gehe nicht über 120 Zeichen pro Zeile. Das
lässt sich schlecht in Foren etc. lesen da man
über die Seite in jeder Zeile hüpfen muss. Willst
du das später mal ausdrucken, solltest du nicht
einmal über 93 Zeichen gehen (bei Consolas).

Schließlich willst du später in einem Jahr
vielleicht nochmal reinschauen falls es einen Bug
gibt und dann schnellstmöglich verstehen was da
eigentlich passiert (hoffe ich zumindest).

Deine wievielte Engine ist das?

Ich werde dir nochmal (Übermorgen) einen
Quellcode reinstellen, wie ich das komplette
Hardwareverfahren lösen würde.
12.02.2009, 20:28:27 Uhr
Art Train Developer
dLoB Offline
ZFX'ler


Registriert seit:
27.06.2005

Nordrhein-Westfalen
Re: Enumeration Direktx 9 -> 10Nach oben.
Unterstriche am Anfang von Variablen sind dem Compiler vorbehalten. Sowas sollte man nicht machen! Außerdem siehts IMHO beschissen aus...
12.02.2009, 21:24:02 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Hallo Pumi

Danke für deine Tipps.

@Pumi: Deine wievielte Engine ist das?

Ich befasse mich seit einigen Jahren mit 3d
Programmierung aus reiner Faszination. Eine
Engine ist das aber nicht was dabei zustandekam
eher eine Sammlung von Bibliotheken in dlls.
Im Grunde werden Techniken und Informationen
gesucht um zu verstehen was im Verborgenen hinter der Spielkulisse geschieht.

@Pumi Du solltest den Codestil
wirklich verbessern.

Du meinst wahrscheinlich den Teil wo das DXGI verwendet wird.
Das war auch in 5 min gecoded um zu verstehen wie man das DXGI verwendet.

4 Mal gendert, zuletzt am 13.02.2009, 15:15:33 Uhr von exploid.
13.02.2009, 15:04:01 Uhr
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: Enumeration Direktx 9 -> 10Nach oben.
Zitat:

Klassenmember (private): _XyzParam
Klassenmember (protected): __Evaluation;
Klassenmember (public): mIsPrepared;


Ketzerfrage: Wenn der Stil schon logisch und konsistent sein soll ... warum keine 3 Unterstriche für public?

Zitat:

Certain sets of names and function signatures are always reserved to the implementation:
— Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter is reserved to the implementation for any use.
[...]
— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace


Gruß,
Alex
13.02.2009, 16:50:40 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
Zitat von Aramis:
Ketzerfrage: Wenn der Stil schon logisch und konsistent sein soll ... warum keine 3 Unterstriche für public?
Ich hätte andersrum gefragt, warum nicht private zwei Unterstriche bekommt und protected einen – protected kapselt schließlich weniger als private und die Unterstriche gäben dann den Grad der Kapselung an.

Aber vielleicht ist die Antwort ja, dass protected einfach nie benutzt wird …

Unterstriche sind imho eh Schmuh und höchstens dafür reserviert, dass ich mal testweise ein paar Zeilen hinklatsche … aber ist wohl Geschmackssache.
13.02.2009, 17:06:43 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Hallo

Hab den Dialog halbwegs fertig. Könnt ihr den bitte
mal bei euch testen? Wäre dankbar.

download link

Wenn ne Fehlermeldung wegen der dll erscheint dann
dll dann die Graphics_01.dll nach c:windows\system32 kopieren.
13.02.2009, 17:13:24 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
„Available Modes“ ist leer, kA ob das so sein soll, ansonsten funzt es.

Dir ist hoffentlich klar, dass DXGI_FORMAT_R16G16B16A16_FLOAT kein praktisch verwendbarer Anzeigemodus ist?
13.02.2009, 17:18:58 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Da sollten alle modes drin stehen für die Adapter Formate. Da sind dann noch bugs.

Nein das war mir nicht klar

1 Mal gendert, zuletzt am 13.02.2009, 17:26:44 Uhr von exploid.
13.02.2009, 17:23:56 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
Für D3D10 am besten – wie in D3D9 – nur das Desktopformat verwenden, wenn man im Fenstermodus rendert … im Vollbildmodus gehen die drei enumerierten UNORMs, FLOAT produziert – drücken wir es so aus – überraschende Ergebnisse.

Falls es dir beim Debugging hilft, ich habe Vista 64-Bit mit einer ATI Radeon HD 4850.
13.02.2009, 17:31:46 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
@krishty läuft dein monitor auf 75 hertz oder auf 60?

ich such nur nach 60 hertz modes an der stelle

wenn er < 60 hertz ist dann siehst du wahrschinlich da modes wenn du auf 60 runterschaltest

könnte eine mögliche fehlerursache sein

3 Mal gendert, zuletzt am 13.02.2009, 17:36:26 Uhr von exploid.
13.02.2009, 17:33:44 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
Ich betreibe ihn bereits mit 60 Hertz.

1 Mal gendert, zuletzt am 13.02.2009, 17:37:18 Uhr von Krishty.
13.02.2009, 17:37:00 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
ok danke dann weiss ich im moment nicht weiter
13.02.2009, 17:39:18 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
das ist die entsprechende Stelle die die Auflösungen in das Combolistenfeld einträgt:
Code:
/**
 * Call when adapter format selection changed. 
 */
void D3DEnum::ChangedAdapterFormat(void) {
    D3DDisplayModeList *pDisplay=NULL;
    WCHAR wcBuffer[128]={};

    // get selected item
    pDisplay = (D3DDisplayModeList *)GetSelectedItem(m_hADAPTERFMT);
    for (UINT d=0; dnModes; d++) {
        // only interested in unspecified modes at this point
        if(pDisplay->pDesc[d].Scaling != DXGI_MODE_SCALING_UNSPECIFIED)
            continue;
        // only interested in 60 hz types
        if(pDisplay->pDesc[d].RefreshRate.Numerator > 61000)
            continue;

        swprintf(wcBuffer, L\"%d x %d\", pDisplay->pDesc[d].Width, pDisplay->pDesc[d].Height);
        AddItem(m_hMODE, wcBuffer, &d);
    }
    SendMessage(m_hMODE, CB_SETCURSEL, (WPARAM)0, 0); // Select first entry

} // ChangedDevice
/*----------------------------------------------------------------*/


Auf meinem Rechner funktioniert das einwandfrei.

1 Mal gendert, zuletzt am 13.02.2009, 17:42:26 Uhr von exploid.
13.02.2009, 17:41:25 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Enumeration Direktx 9 -> 10Nach oben.
Wie wär’s, wenn du umfangreiche Log-Messages einbaust, das Programm neu hochlädst und ich dann die Logdatei poste?
13.02.2009, 17:43:01 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
ok
13.02.2009, 17:46:07 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Enumeration Direktx 9 -> 10Nach oben.
Hallo

Da bin ich wieder.

download link

Da sind jetzt an allen wichtigen Stellen logs eingebaut.
13.02.2009, 20:12:24 Uhr
NormalSeite: 1 2 >


ZFX Community Software, Version 0.9.1
Copyright 2002-2003 by Steffen Engel