Nebel Effekt



  • Hallo Leute,

    ich habe ein Problem mit dem Nebeleffekt. Und zwar habe ich einen Mix aus denn Vertex-, Indexbuffer und dem Texturenbeispiel aus dem Buch von David Scherfgen gemacht(2048 Cubes die sich in einem Raum verteilen und dazu 1024 Polygone die sich auseinderbewegen). Jetzt möchte ich einen Nebeleffekt dazu bringen. Nur klappt das nicht, obwohl ich die Render-States gesetzt habe.

    thx maurice

    Hier die Renderfunktion.

    HRESULT                     hResult;
    
                tbMatrix            mScaling;                     // Skalierungsmatrix
    
                tbMatrix            mTranslation;    // Translationsmatrix
    
                tbMatrix            mWorld;                                   // Vereinende Weltmatrix
    
                float                  fAspect;
    
                tbMatrix            mCamera;
    
                tbMatrix            mProjection;
    
                // Den Bildpuffer und den Z-Buffer leeren
    
                if(FAILED(hResult = g_pD3DDevice->Clear(0,
    
                                                                               NULL,
    
                                                                               D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
    
                                                                               D3DCOLOR_XRGB(0, 0, 63),
    
                                                                               1.0f,
    
                                                                                0)))
    
                {
    
                            // Fehler beim Leeren!
    
                            TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    
                }
    
                // Szene beginnen
    
                g_pD3DDevice->BeginScene();
    
                // Nebel-Render-States einstellen
    
                g_pD3DDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
    
                g_pD3DDevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_EXP);
    
                g_pD3DDevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
    
                g_pD3DDevice->SetRenderState(D3DRS_FOGCOLOR, (DWORD)(tbColor(1.0f, 0.0f, 0.0f)));
    
                g_pD3DDevice->SetRenderState(D3DRS_FOGDENSITY, 0.25f);
    
                g_pD3DDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);
    
                // Jedes einzelne Dreieck zeichnen
    
                for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    
                {
    
                            // Skalierungsmatrix anhand der Größe des Dreiecks erstellen
    
                            mScaling = tbMatrixScaling(tbVector3(g_aTriangle[iTriangle].fSize));
    
                            // Translationsmatrix
    
                            mTranslation = tbMatrixTranslation(g_aTriangle[iTriangle].vPosition);
    
                            // Alle Matrizen kombinieren und als Weltmatrix einsetzen
    
                            mWorld = mScaling * mTranslation;
    
                            g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));
    
                            if(FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST,                                       // Dreiecksliste
    
                                                                                                           1,                                                                       // 1 Dreieck
    
                                                                                                           g_aTriangle[iTriangle].aVertex,                              // Vertexdaten
    
                                                                                                           sizeof(SVertex))))                                                // Vertexgröße
    
                            {
    
                                       // Fehler beim Zeichnen!
    
                                       TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult, TB_STOP);
    
                            }
    
                }
    
                // ------------------------------------------------------------------
    
                // Die Kameramatrix erzeugen und einsetzen.
    
                // Dafür benötigen wir die Kameraposition, den Blickpunkt der Kamera und
    
                // die lokale y-Achse der Kamera, die normalerweise (0, 1, 0) ist (es sei denn,
    
                // die Kamera "rollt").
    
                mCamera = tbMatrixCamera(g_vCameraPosition, g_vCameraPosition + tbVector3(sinf(g_fCameraAngle),
    
                                                          0.0f, cosf(g_fCameraAngle)), tbVector3(0.0f, 1.0f, 0.0f));
    
               g_pD3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)(&mCamera));
    
                // Das Bildseitenverhältnis berechnen
    
                fAspect =   (float)(g_Direct3DParameters.VideoMode.Width)
    
                          / (float)(g_Direct3DParameters.VideoMode.Height);
    
                // Die Projektionsmatrix erzeugen und einsetzen.
    
                // Das geschieht hier einmal pro Bild, weil das Sichtfeld variabel ist.
    
                mProjection = tbMatrixProjection(g_fFOV,          // Sichtfeld
    
                                                                                fAspect,      // Bildseitenverhältnis
    
                                                                                0.1f,                        // Nahe Clipping-Ebene
    
                                                                                250.0f);        // Ferne Clipping-Ebene
    
                g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));
    
                // ------------------------------------------------------------------
    
                // Alle Würfel auf einmal zeichnen.
    
                // Zuerst den Vertex- und den Index-Buffer als Datenquelle aktivieren.
    
                g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(SVertex));
    
                g_pD3DDevice->SetIndices(g_pIndexBuffer);
    
                // Zeichnen!
    
                hResult = g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,            // Dreiecksliste
    
                                                                                                    0,                               // Basisvertexindex
    
                                                                                                   0,                                // Der kleinste Index
    
                                                                                                   g_iNumCubes * 8,        // Diff. zw. größtem u. kleinstem Index
    
                                                                                                   0,                                // Von Anfang an zeichnen
    
                                                                                                   g_iNumCubes * 12);     // 12 Dreiecke pro Würfel
    
                if(FAILED(hResult))
    
                {
    
                            // Fehler beim Zeichnen!
    
                            TB_ERROR_DIRECTX("g_pD3DDevice->DrawIndexedPrimitive", hResult, TB_STOP);
    
                }
    
                // Szene beenden
    
                g_pD3DDevice->EndScene();
    
                // Der große Moment: den Bildpuffer sichtbar machen
    
                g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
    
                return TB_OK;
    
    }
    


  • g_pD3DDevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);

    Was genau soll diese Zeile erreichen?



  • um pixel fog zu deaktivieren



  • g_pD3DDevice->SetRenderState(D3DRS_FOGDENSITY, 0.25f);
    

    Wenn ich mal die DX-SDK zitieren darf:

    Values for this render state are floating-point values. Because the IDirect3DDevice8::SetRenderState method accepts DWORD values, your application must cast a variable that contains the value, as shown in the following code example.

    pd3dDevice8->SetRenderState(D3DRS_FOGDENSITY, *((DWORD*) (&fFogDensity)));
    

    Deshalb muss man das verwenden:

    float f = 0.25f;
    g_pD3DDevice->SetRenderState(D3DRS_FOGDENSITY, *(DWORD*)&f);
    


  • Aber du hast ihn doch nie aktiviert?



  • @a=a->next das, habe ich vorher schon so versucht, nur sind dann alle Objekte in der Nebelfarbe(Rot).

    @tggc na man kann bei DirectX zwischen Vertex- und Pixelnebel unterscheiden und indem Buch steht drin: "am besten immer eines der beiden Render States auf D3DFOG_NONE setzen".



  • mosta schrieb:

    @a=a->next das, habe ich vorher schon so versucht, nur sind dann alle Objekte in der Nebelfarbe(Rot).

    @tggc na man kann bei DirectX zwischen Vertex- und Pixelnebel unterscheiden und indem Buch steht drin: "am besten immer eines der beiden Render States auf D3DFOG_NONE setzen".

    Wahrscheinlich war der Nebel dann einfach zu stark.

    Naja, auf NONE setzen brauchst du nur, wenn du schonmal auf irgendwas anderes gesetzt hattest.



  • Jetzt sehe ich den Nebeleffekt auch(Wobei er mir noch nicht gefällt).

    danke tggc


Anmelden zum Antworten