adapterauswahl bei directx



  • seufz, ich hab mal wieder ein problem 😉
    ich hab nu endlich einen schönen würfel mit texturen(usw usf) gecodet, und er bewegt sich auch wunderschön auf meinem bildschirm..wie gesagt, auf MEINEM 🙄 ...bisher hab ichs aber noch auf keinem andren pc zum laufen gebracht.

    nun hab ich mich nochmal an die adapterauswahl drangesetzt,und bin atm am planen, wie ich das am besten angehen sollte.

    das hauptproblem ist,dass ich nich weis wo ich anfangen soll.
    erst such ich die adapter raus, und dann kommt schon das problem:in welcher reihenfolge sollte ich die eigenschaften abfragen: erst die farbe, oder erst die auflösung?
    und wenn ich dann die einzelnen infos in eine struktur gesperrt hab, wie krieg ich dann schlussendlich raus, welche graka nun die beste für mich ist, dh welches system sollte ich zum vergleichen verwenden?

    wenig codetechnische fragen aber viel theorie 😉



  • Hi,

    ich stand/stehe vor dem selben Problem und arbeite mich jetzt [da mir hier nicht so recht geholfen werden konnte (spezieller Gruß an TGGC, der gerade durch seine Hilfe in "komisches koordinatensystem in dx" glänzt)] durch den Code des Dx AppWizard des MS VC++ 6.0. Der Code is zwar grässlich aber man sieht, wie so eine Initialisierung aussehen kann.
    Ich kann dir nur empfehlen, dir den auch mal anzuschauen.

    PS: Wenn du MS VC++ 6 nicht benutzt, könnte ich dir die paar Zeilen auch schicken.



  • Mit dem SDK kommen 'ne Menge Beispiele, alle haben die Adapterauswahl drin. Oder man machts wie bei OSR, ganz simpel und der User ist nicht überfragt.

    @interpreter: Stimmt, gibt nicht viele, die ein Problem mit einem Satz lösen können. 😎
    Schön, das wir dich auf den Pfad der Tugend geführt haben und du kapiert hast das man sein Wissen und Können erarbeiten muss.

    Keine Macht den Dummen!

    Bye, TGGC (Der Held ist zurück)



  • @interpreter: Stimmt, gibt nicht viele, die ein Problem mit einem Satz lösen können. 😎

    Noch ist es nicht gelöst.

    Schön, das wir dich auf den Pfad der Tugend geführt haben und du kapiert hast das man sein Wissen und Können erarbeiten muss.

    Dass ist aber definitiv nicht dein Verdienst.

    Keine Macht den Dummen!

    Da stimmte ich dir zu 🙂



  • Du kannst es ruhig zugeben.

    Bye, TGGC (Der Held ist zurück)



  • auf die idee die beispiele im sdk anzuschaun bin ich ja bisher garnich gekommen 😉

    ichd anke euch

    btw: tggc, bisher dachte ich eigentlich, dass du ein übermäßiger spamer bist,und dein können hinter tausenden vollironischen sätzen begräbst, aber vielleicht ändere ich ja bald mal meine meinung über dich 😉



  • otze schrieb:

    btw: tggc, bisher dachte ich eigentlich, dass du ein übermäßiger spamer bist,und dein können hinter tausenden vollironischen sätzen begräbst, aber vielleicht ändere ich ja bald mal meine meinung über dich 😉

    Tu' uns alle einen Gefallen und bleib' bei Deiner Meinung! 🤡 👍
    😉



  • Man hilft doch immer wieder gern.

    Bye, TGGC (Der Held ist zurück)



  • Ich werd das Gefühl nicht los, dass TGGC die provokante Version des Unix Programms "fortune" ist. Alle x Stunden kommt er online, postet 2,3 meist sinnlose Kommentare und beendet sich dann wieder.



  • interpreter schrieb:

    Ich werd das Gefühl nicht los, dass TGGC die provokante Version des Unix Programms "fortune" ist. Alle x Stunden kommt er online, postet 2,3 meist sinnlose Kommentare und beendet sich dann wieder.

    Ich existiere nur zu deiner Pein.

    Bye, TGGC (Der Held ist zurück)



  • so falls damit jemand was anfangen kann / will:

    // Strukturen
    struct ADAPTER
    {
    	UINT iAdapterID;
    	string strDriverName;
    	string strDriverDescription;
    	string strDeviceName;
    };
    
    struct RESOLUTION
    {
    	UINT _x, _y;
    };
    
    enum MODES
    {
    	FDX_16BIT = D3DFMT_R5G6B5,
    	FDX_32BIT = D3DFMT_X8R8G8B8
    };
    
    enum BACKMODES
    {
    	FDX_BA16BIT = D3DFMT_A4R4G4B4,
    	FDX_BA32BIT = D3DFMT_A8R8G8B8,
    	FDX_B16BIT = D3DFMT_R5G6B5,
    	FDX_B32BIT = D3DFMT_X8R8G8B8
    };
    
    enum DEPTHSTENCIL
    {
    	FDX_D0 = 0,
    	FDX_D16 = D3DFMT_D16,
    	FDX_D32 = D3DFMT_D32,
    	FDX_D15S1 = D3DFMT_D15S1,
    	FDX_D24S8 = D3DFMT_D24S8
    };
    
    struct SCREENFORMAT
    {
    	MODES mode;
    	BACKMODES backmode;
    	DEPTHSTENCIL depthstencil;
    	bool bAlpha;
    	bool bFullscreen;
    	bool bHAL;
    	bool bDepthBuffer;
    	bool bStencilBuffer;
    	bool b8BitStencil;
    };
    
    // Gibt die Anzahl der Grafik-Adapter zurück
    UINT FDX::Engine::GetAdapterCount(void)
    {
    	if(m_sInit == 0 || !m_pDX9)
    		return 0;
    
    	return m_pDX9->GetAdapterCount();
    }
    
    // Gibt die Details zu jedem Adapter zurück
    vector<FDX::ADAPTER> FDX::Engine::GetAdapterDetails()
    {
    	if(m_sInit == 0 || !m_pDX9)
    		return vector<FDX::ADAPTER>();
    
    	D3DADAPTER_IDENTIFIER9 structDetails;
    	vector<FDX::ADAPTER> vecAdapter;
    	ADAPTER structAdapter;
    	UINT iAdapterCount = m_pDX9->GetAdapterCount();
    
    	for(UINT i=0; i<iAdapterCount; i++)
    	{
    		if(FAILED(m_pDX9->GetAdapterIdentifier(i, 0, &structDetails)))
    			return vector<FDX::ADAPTER>();
    
    		structAdapter.iAdapterID = i;
    		structAdapter.strDeviceName = structDetails.DeviceName;
    		structAdapter.strDriverDescription = structDetails.Description;
    		structAdapter.strDriverName = structDetails.Driver;
    
    		vecAdapter.insert(vecAdapter.end(), structAdapter);
    	}
    
    	return vecAdapter;
    }
    
    // Gibt alle möglichen Auflösungen zurück
    vector<FDX::RESOLUTION> FDX::Engine::GetAdapterResulotions(UINT iAdapterID, FDX::MODES mode)
    {
    	if(m_sInit == 0 || !m_pDX9)
    		return vector<FDX::RESOLUTION>();
    
    	if(iAdapterID >= m_pDX9->GetAdapterCount())
    		return vector<FDX::RESOLUTION>();
    
    	D3DDISPLAYMODE pstructModes;
    	vector<FDX::RESOLUTION> vecResolutions;
    	FDX::RESOLUTION structResolution;
    	bool ifInserted = false;
    
    	UINT iModes = m_pDX9->GetAdapterModeCount(iAdapterID, (D3DFORMAT)FDX::FDX_16BIT);
    
    	for(UINT i=0; i<iModes; i++)
    	{
    		if(FAILED(m_pDX9->EnumAdapterModes(iAdapterID, (D3DFORMAT)FDX::FDX_16BIT, i, &pstructModes)))
    			return vector<FDX::RESOLUTION>();
    
    		ifInserted = false;
    		for(UINT u=0; u<vecResolutions.size(); u++)
    		{
    			if(vecResolutions[u]._x == pstructModes.Width && vecResolutions[u]._y == pstructModes.Height)
    			{
    				ifInserted = true;
    				break;
    			}
    		}
    
    		if(!ifInserted)
    		{
    			structResolution._x = pstructModes.Width;
    			structResolution._y = pstructModes.Height;
    			vecResolutions.insert(vecResolutions.begin(), structResolution);
    		}
    	}
    
    	return vecResolutions;
    }
    
    // Gibt alle möglichen Farbtiefenvarianten zurück
    vector<FDX::SCREENFORMAT> FDX::Engine::GetAdapterModes(UINT iAdapterID, bool bFullscreen)
    {
    	if(m_sInit == 0 || !m_pDX9)
    		return vector<FDX::SCREENFORMAT>();
    
    	if(iAdapterID >= m_pDX9->GetAdapterCount())
    		return vector<FDX::SCREENFORMAT>();
    
    	// Farbtiefe für Frontbuffer
    	MODES modeArray[] = {FDX_16BIT, FDX_32BIT};
    
    	// Farbtiefe für Backbuffer (1 für mit Alpha, 0 ohne Alpha)
    	UINT backmodeArray[][2] = {	FDX_BA16BIT, 1,
    								FDX_BA32BIT, 1,
    								FDX_B16BIT, 0,
    								FDX_B32BIT, 0};
    
    	// DepthStencil Buffer, Stencil vorhanden, 8 Bit Stencil
    	UINT dsArray[][3] = {	FDX_D16, 0, 0,
    							FDX_D32, 0, 0,
    							FDX_D15S1, 1, 0,
    							FDX_D24S8, 1, 1 };
    
    	UINT imodeArraySize = sizeof(modeArray)/sizeof(MODES);
    	UINT idsArraySize = sizeof(dsArray)/sizeof(UINT)/3;
    	UINT ibmodeArraySize = sizeof(backmodeArray)/sizeof(UINT)/2;
    
    	// Jedes Frontbufferformat mit Backbufferformat testen sowie Depth Stencil
    	vector<FDX::SCREENFORMAT> vecReturn;
    	FDX::SCREENFORMAT structScreenFormat;
    	// Front
    	for(UINT i=0; i<imodeArraySize; i++)
    	{
    		// Back
    		for(UINT u=0; u<ibmodeArraySize; u++)
    		{
    			if(!FAILED(m_pDX9->CheckDeviceType(iAdapterID, D3DDEVTYPE_HAL, 
    												(D3DFORMAT)modeArray[i], 
    												(D3DFORMAT)backmodeArray[u][0], 
    												!bFullscreen)))
    			{
    				structScreenFormat.bAlpha = (backmodeArray[u][1]==1)?true:false;
    				structScreenFormat.bFullscreen = bFullscreen;
    				structScreenFormat.bHAL = true;
    				structScreenFormat.mode = (MODES)modeArray[i];
    				structScreenFormat.backmode = (BACKMODES)backmodeArray[u][0];
    			}
    			else
    				continue;
    
    			structScreenFormat.b8BitStencil = false;
    			structScreenFormat.bDepthBuffer = false;
    			structScreenFormat.bStencilBuffer = false;
    			structScreenFormat.depthstencil = FDX_D0;
    
    			// Ohne Depth Stencil hinzufügen
    			vecReturn.insert(vecReturn.end(), structScreenFormat);
    
    			// DS Varianten durchgehen
    			for(UINT z=0; z<idsArraySize; z++)
    			{
    				if(!FAILED(m_pDX9->CheckDepthStencilMatch(iAdapterID, D3DDEVTYPE_HAL,
    															(D3DFORMAT)structScreenFormat.mode,
    															(D3DFORMAT)structScreenFormat.backmode,
    															(D3DFORMAT)dsArray[z][0])))
    				{
    					structScreenFormat.b8BitStencil = (dsArray[z][2]==1)?true:false;
    					structScreenFormat.bDepthBuffer = true;
    					structScreenFormat.bStencilBuffer = (dsArray[z][1]==1)?true:false;
    					structScreenFormat.depthstencil = (DEPTHSTENCIL)dsArray[z][0];
    
    					// Mit DS adden
    					vecReturn.insert(vecReturn.end(), structScreenFormat);
    				}
    			}
    		}
    	}
    
    	return vecReturn;
    }
    
    vector<UINT> FDX::Engine::GetRefreshRates(UINT iAdapterID, RESOLUTION structRes)
    {
    	if(m_sInit == 0 || !m_pDX9)
    		return vector<UINT>();
    
    	if(iAdapterID >= m_pDX9->GetAdapterCount())
    		return vector<UINT>();
    
    	D3DDISPLAYMODE pstructModes;
    	vector<UINT> vecRates;
    	bool ifInserted = false;
    
    	UINT iModes = m_pDX9->GetAdapterModeCount(iAdapterID, (D3DFORMAT)FDX::FDX_16BIT);
    
    	for(UINT i=0; i<iModes; i++)
    	{
    		if(FAILED(m_pDX9->EnumAdapterModes(iAdapterID, (D3DFORMAT)FDX::FDX_16BIT, i, &pstructModes)))
    			return vector<UINT>();
    
    		// Wenn gewünschte Auflösung
    		if(structRes._x == pstructModes.Width && structRes._y == pstructModes.Height)
    		{
    			// Abfragen ob Refresh Rate schon gespeichert
    			ifInserted = false;
    			for(UINT u=0; u<vecRates.size(); u++)
    			{
    				if(vecRates[u] == pstructModes.RefreshRate)
    				{
    					ifInserted = true;
    					break;
    				}
    			}
    
    			if(!ifInserted)
    				vecRates.insert(vecRates.end(), pstructModes.RefreshRate);
    		}
    	}
    
    	return vecRates;
    }
    


  • doppelpost



  • ok, ich hab das jetzt so gelöst:
    Zuerst suche ich mir für jede karte jeden möglichen modus raus, und vergleich sie am ende mithilfe des bubblesort algorythmus, die beste einstellung wird dann als quality, und die schlechteste als speed gespeichert, der rest verfällt
    das ganze is teil eines Dx klassenconstructors(bitte schlagen wenn das mies is)
    natürlich fehlt noch was, da ich noch nich alle features kenne, aber es sollte eigentlich kein problem sein, dass zu verändern/erweitern, jetzt wo ich den dreh raus hab

    bei dem backbuffertest bin ich mir aber nich so sicher, da ich nich so ganz den unterschied zwischen videomode(frontbuffer?) und backbuffermode herausbekommen hab,und da ich auch in meinem schlauen buch keinen hinweis drauf bekommen hab, wo ich nun im zweifelsfall den frontbuffer ändern kann,hab ich dafür bis auf weiteres einen festen wert genommen,natürlich werd ich es sofort ändern, wenn mir jemand sagt, wie ich den frontbuffer ändern kann

    struct CardCaps{
        int Adapter;
        D3DMULTISAMPLE_TYPE Multisampletype;
        DWORD* MultiSampleQuality;
        D3DFORMAT BackbufferFormat;
        D3DFORMAT DepthStencilformat;
        UINT Width;
        UINT Height;
    };
    bool DXclass::getAdapter(){
        int Adapters=D3D->GetAdapterCount();
        vector<CardCaps> Cardcaps;
    
        D3DFORMAT Bildbuffer[2];
        Bildbuffer[0]=D3DFMT_X8R8G8B8;
        Bildbuffer[1]=D3DFMT_R5G6B5;
    
        D3DFORMAT ZBuffer[4];
        ZBuffer[0]=D3DFMT_D24FS8;
        ZBuffer[1]=D3DFMT_D24S8;
        ZBuffer[2]=D3DFMT_D24X4S4;
        ZBuffer[3]=D3DFMT_D32;
    
        D3DMULTISAMPLE_TYPE Multisampling[3];
        Multisampling[0]=D3DMULTISAMPLE_4_SAMPLES;
        Multisampling[1]=D3DMULTISAMPLE_2_SAMPLES;
        Multisampling[2]=D3DMULTISAMPLE_NONE;
    
        DWORD* BQuality;
        DWORD* ZQuality;
    
        for(int Adapter=0;Adapter<Adapters;Adapter++){//hier werden für jeden adapter die wichtigsten eigenschaften rausgesucht
            for(int Bildformat=0;Bildformat<2;Bildformat++){//backbuffer
                if(SUCCEEDED(D3D->CheckDeviceFormat(Adapter,D3DDEVTYPE_HAL,D3DFMT_X8R8G8B8,D3DUSAGE_DEPTHSTENCIL,D3DRTYPE_SURFACE,Bildbuffer[Bildformat]))&&SUCCEEDED(D3D->CheckDeviceType(Adapter,D3DDEVTYPE_HAL,D3DFMT_X8R8G8B8,Bildbuffer[Bildformat],false))){
                    for(int Zformat=0;Zformat<4;Zformat++){//z-stencil buffer
                        if(SUCCEEDED(D3D->CheckDeviceFormat(Adapter,D3DDEVTYPE_HAL,D3DFMT_X8R8G8B8,D3DUSAGE_DEPTHSTENCIL,D3DRTYPE_SURFACE,ZBuffer[Zformat]))&&SUCCEEDED(D3D->CheckDepthStencilMatch(Adapter,D3DDEVTYPE_HAL,D3DFMT_X8R8G8B8,Bildbuffer[Bildformat],ZBuffer[Zformat]))){
                            for(int Multisampleformat=0;Multisampleformat<3;Multisampleformat++){//multisampling
                                if(SUCCEEDED(D3D->CheckDeviceMultiSampleType(Adapter,D3DDEVTYPE_HAL,Bildbuffer[Bildformat],false,Multisampling[Multisampleformat],BQuality))&&SUCCEEDED(D3D->CheckDeviceMultiSampleType(Adapter,D3DDEVTYPE_HAL,ZBuffer[Zformat],false,Multisampling[Multisampleformat],ZQuality))){//quality des multisamplings
                                    Cardcaps.push_back();
                                    if(ZQuality<BQuality){
                                        Cardcaps.back().MultiSampleQuality=ZQuality-1;
                                    }
                                    else
                                    {
                                        Cardcaps.back().MultiSampleQuality=BQuality-1;
                                    }
                                    Cardcaps.back().Multisampletype=Multisampling[Multisampleformat];
                                    Cardcaps.back().BackbufferFormat=Bildbuffer[Bildformat];
                                    Cardcaps.back().DepthStencilformat=ZBuffer[Zformat];
                                }
                            }
                        }
                    }
                }
            }
        }
        //BUBBLE SORT ALGORITHMUS schlechtestes-bestes
        unsigned int size=Cardcaps.size();
        if(size>0){
            bool wechsel=true;
            CardCaps temp;
            while(wechsel==true){
                wechsel=false;
                for(unsigned int mode=0;mode<(size-1);mode++){
                    if(Cardcaps[mode].BackbufferFormat>Cardcaps[mode+1].BackbufferFormat){
                        temp=Cardcaps[mode];
                        Cardcaps[mode]=Cardcaps[mode+1];
                        Cardcaps[mode+1]=temp;
                        wechsel=true;
                    }
                    else
                    {
                        if(Cardcaps[mode].DepthStencilformat>Cardcaps[mode+1].DepthStencilformat){
                            temp=Cardcaps[mode];
                            Cardcaps[mode]=Cardcaps[mode+1];
                            Cardcaps[mode+1]=temp;
                            wechsel=true;
                        }
                        else
                        {
                            if(Cardcaps[mode].Multisampletype>Cardcaps[mode+1].Multisampletype){
                                temp=Cardcaps[mode];
                                Cardcaps[mode]=Cardcaps[mode+1];
                                Cardcaps[mode+1]=temp;
                                wechsel=true;
                            }
                            else
                            {
                                if(Cardcaps[mode].MultiSampleQuality>Cardcaps[mode+1].MultiSampleQuality){
                                    temp=Cardcaps[mode];
                                    Cardcaps[mode]=Cardcaps[mode+1];
                                    Cardcaps[mode+1]=temp;
                                    wechsel=true;
                                }
                            }
                        }
                    }
                }
            }
            this->Speedmode=Cardcaps[0];
            this->Qualitymode=Cardcaps[size-1];
            return true;
        }
        else
        {
            return false;
        }
    

Log in to reply