Viereck zeichnen



  • Dieser Beitrag wurde gelöscht!


  • @Sunix sagte in Viereck zeichnen:

    Wenn der Drehsinn dann nicht passt, muss mit den Punkten (Koordinaten) vorher etwas nicht stimmen!

    Nö.

    Mit Hilfe der Eckpunkte des Dreiecks wird ein Normalenvektor berechnet. Dieser steht senkrecht auf der Dreiecksfläche. Nun hat ein Dreieck zwei Seiten und deswegen auch zwei Normalenvektoren. Abhängig vom Drehsinn bekommt man den einen oder anderen Normalenvektor heraus.

    Nehmen wir mal an, wir hätten zwei flache Dreiecke (z=0). Wenn nun beide Dreiecke im gleichen Drehsinn angegeben werden, so zeigen beide Normalenvektoren in die gleiche Richtung. Wenn der Drehsinn aber unterschiedlich ist, so zeigen die Normalenvektoren in unterschiedliche Richtungen.

    Dadurch erkennt DirectX das eine Dreieck als Back Face und stellt dies ggf. nicht dar.

    Es hat also nichts mit den Koordinaten zu tun, sondern nur mit dem Drehsinn.



  • @Quiche-Lorraine sagte in Viereck zeichnen:

    Mit Hilfe der Eckpunkte des Dreiecks wird ein Normalenvektor berechnet.

    Ja, mit dem Kreuz- oder Dotprodukt?

    @Quiche-Lorraine sagte in Viereck zeichnen:

    Es hat also nichts mit den Koordinaten zu tun, sondern nur mit dem Drehsinn.

    Anstandslos was gemeint war. (Ich komme auf 3! = 1 * 2 * 3 = 6 Reihenfolgen)

    @Quiche-Lorraine sagte in Viereck zeichnen:

    Es hat also nichts mit den Koordinaten zu tun

    Nichts mit den Koordinaten zu tun? Es hat mit der Reihenfolge der Koordinaten zu tun. Koordinaten ohne Reihenfolge? Gut, die Koordinaten haben an für sich keine Reihenfolge.



  • Das Basisdreieck besteht aus Spitze oben und 2 Ecken unten links und unten rechts.
    Die 4., neue Koordinate für das Viereck befindet sich links von der Dreiecksspitze.
    Bei der Reihenfolge untere rechte Ecke, untere linke Ecke, Spitze, 4. Koordinate
    klappt es.
    "A triangle is made up of three vertices, each defined in your program in clockwise order". Das beantwortet wohl die Frage zur Reihenfolge.



  • @Sunix sagte in Viereck zeichnen:

    @hustbaer sagte in Viereck zeichnen:

    Er verwendet ja D3DPT_TRIANGLESTRIP. Da reichen schon 4 Eckpunkte für 2 Dreiecke.

    Ohne einen zweiten Buffer, (bin auch nur am überfliegen) mit den Indizien für die Koordinaten?

    Ja. Mit D3DPT_TRIANGLESTRIP zeichnet er die Dreiecke
    0, 1, 2
    1, 2, 3
    2, 3, 4
    ...

    4 Punkte -> 2 Dreiecke
    5 Punkte -> 3 Dreiecke
    6 Punkte -> 4 Dreiecke
    etc.

    Das wurde vor Index-Puffern eingeführt, damit nicht so viele Punkte doppelt transformiert werden müssen.

    (Ist wie jemand die Worte gegenüber jemandem braucht, ohne die Worte so hintereinanderuzulegen, dass es gasförmig wird).

    Betrunken?



  • @hustbaer sagte in Viereck zeichnen:

    Betrunken?

    Das ist doch der Zweitaccount von KlagenderLamer. Da wurde irgendwann mal durch 0 geteilt oder 'ne Exception nicht gefangen, seitdem herrscht da UB.



  • Im Beispielcode rotiert das Dreieck. Beim Kompilieren des Codes ercheinen 3
    Fehlermeldungen "error: taking address of temporary [-fpermissive]",
    verursacht durch die Funktionsparameter aus der Funktion D3DXMatrixLookAtLH.
    Hier der Code, den ich nur kopiert habe:

    // include the basic windows header files and the Direct3D header file
    #include <windows.h>
    #include <windowsx.h>
    #include <d3d9.h>
    #include <d3dx9.h>
    
    // define the screen resolution
    #define SCREEN_WIDTH 800
    #define SCREEN_HEIGHT 600
    
    // include the Direct3D Library files
    #pragma comment (lib, "d3d9.lib")
    #pragma comment (lib, "d3dx9.lib")
    
    // global declarations
    LPDIRECT3D9 d3d;    // the pointer to our Direct3D interface
    LPDIRECT3DDEVICE9 d3ddev;    // the pointer to the device class
    LPDIRECT3DVERTEXBUFFER9 v_buffer = NULL;    // the pointer to the vertex buffer
    
    // function prototypes
    void initD3D(HWND hWnd);    // sets up and initializes Direct3D
    void render_frame(void);    // renders a single frame
    void cleanD3D(void);    // closes Direct3D and releases memory
    void init_graphics(void);    // 3D declarations
    
    struct CUSTOMVERTEX {FLOAT X, Y, Z; DWORD COLOR;};
    #define CUSTOMFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE)
    
    // the WindowProc function prototype
    LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
    
    
    // the entry point for any Windows program
    int WINAPI WinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPSTR lpCmdLine,
                       int nCmdShow)
    {
        HWND hWnd;
        WNDCLASSEX wc;
    
        ZeroMemory(&wc, sizeof(WNDCLASSEX));
    
        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = WindowProc;
        wc.hInstance = hInstance;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.lpszClassName = L"WindowClass";
    
        RegisterClassEx(&wc);
    
        hWnd = CreateWindowEx(NULL, L"WindowClass", L"Our Direct3D Program",
                              WS_OVERLAPPEDWINDOW, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
                              NULL, NULL, hInstance, NULL);
    
        ShowWindow(hWnd, nCmdShow);
    
        // set up and initialize Direct3D
        initD3D(hWnd);
    
        // enter the main loop:
    
        MSG msg;
    
        while(TRUE)
        {
            while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
    
            if(msg.message == WM_QUIT)
                break;
    
            render_frame();
        }
    
        // clean up DirectX and COM
        cleanD3D();
    
        return msg.wParam;
    }
    
    
    // this is the main message handler for the program
    LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch(message)
        {
            case WM_DESTROY:
                {
                    PostQuitMessage(0);
                    return 0;
                } break;
        }
    
        return DefWindowProc (hWnd, message, wParam, lParam);
    }
    
    
    // this function initializes and prepares Direct3D for use
    void initD3D(HWND hWnd)
    {
        d3d = Direct3DCreate9(D3D_SDK_VERSION);
    
        D3DPRESENT_PARAMETERS d3dpp;
    
        ZeroMemory(&d3dpp, sizeof(d3dpp));
        d3dpp.Windowed = TRUE;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.hDeviceWindow = hWnd;
        d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
        d3dpp.BackBufferWidth = SCREEN_WIDTH;
        d3dpp.BackBufferHeight = SCREEN_HEIGHT;
    
        // create a device class using this information and the info from the d3dpp stuct
        d3d->CreateDevice(D3DADAPTER_DEFAULT,
                          D3DDEVTYPE_HAL,
                          hWnd,
                          D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                          &d3dpp,
                          &d3ddev);
    
        init_graphics();    // call the function to initialize the triangle
    
        d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);    // turn off the 3D lighting
    }
    
    
    // this is the function used to render a single frame
    void render_frame(void)
    {
        d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
    
        d3ddev->BeginScene();
    
        // select which vertex format we are using
        d3ddev->SetFVF(CUSTOMFVF);
    
        // SET UP THE PIPELINE
    
        D3DXMATRIX matRotateY;    // a matrix to store the rotation information
    
        static float index = 0.0f; index+=0.05f;    // an ever-increasing float value
    
        // build a matrix to rotate the model based on the increasing float value
        D3DXMatrixRotationY(&matRotateY, index);
    
        // tell Direct3D about our matrix
        d3ddev->SetTransform(D3DTS_WORLD, &matRotateY);
    
        D3DXMATRIX matView;    // the view transform matrix
    
        D3DXMatrixLookAtLH(&matView,
                           &D3DXVECTOR3 (0.0f, 0.0f, 10.0f),    // the camera position
                           &D3DXVECTOR3 (0.0f, 0.0f, 0.0f),    // the look-at position
                           &D3DXVECTOR3 (0.0f, 1.0f, 0.0f));    // the up direction
    
        d3ddev->SetTransform(D3DTS_VIEW, &matView);    // set the view transform to matView
    
        D3DXMATRIX matProjection;     // the projection transform matrix
    
        D3DXMatrixPerspectiveFovLH(&matProjection,
                                   D3DXToRadian(45),    // the horizontal field of view
                                   (FLOAT)SCREEN_WIDTH / (FLOAT)SCREEN_HEIGHT, // aspect ratio
                                   1.0f,    // the near view-plane
                                   100.0f);    // the far view-plane
    
        d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection);    // set the projection
    
        // select the vertex buffer to display
        d3ddev->SetStreamSource(0, v_buffer, 0, sizeof(CUSTOMVERTEX));
    
        // copy the vertex buffer to the back buffer
        d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
    
        d3ddev->EndScene();
    
        d3ddev->Present(NULL, NULL, NULL, NULL);
    }
    
    
    // this is the function that cleans up Direct3D and COM
    void cleanD3D(void)
    {
        v_buffer->Release();    // close and release the vertex buffer
        d3ddev->Release();    // close and release the 3D device
        d3d->Release();    // close and release Direct3D
    }
    
    
    // this is the function that puts the 3D models into video RAM
    void init_graphics(void)
    {
        // create the vertices using the CUSTOMVERTEX struct
        CUSTOMVERTEX vertices[] = 
        {
            { 3.0f, -3.0f, 0.0f, D3DCOLOR_XRGB(0, 0, 255), },
            { 0.0f, 3.0f, 0.0f, D3DCOLOR_XRGB(0, 255, 0), },
            { -3.0f, -3.0f, 0.0f, D3DCOLOR_XRGB(255, 0, 0), },
        };
    
        // create a vertex buffer interface called v_buffer
        d3ddev->CreateVertexBuffer(3*sizeof(CUSTOMVERTEX),
                                   0,
                                   CUSTOMFVF,
                                   D3DPOOL_MANAGED,
                                   &v_buffer,
                                   NULL);
    
        VOID* pVoid;    // a void pointer
    
        // lock v_buffer and load the vertices into it
        v_buffer->Lock(0, 0, (void**)&pVoid, 0);
        memcpy(pVoid, vertices, sizeof(vertices));
        v_buffer->Unlock();
    }
    
    


  • @member sagte in Viereck zeichnen:

    D3DXMatrixLookAtLH(&matView,
                       &D3DXVECTOR3 (0.0f, 0.0f, 10.0f),    // the camera position
                       &D3DXVECTOR3 (0.0f, 0.0f, 0.0f),    // the look-at position
                       &D3DXVECTOR3 (0.0f, 1.0f, 0.0f));    // the up direction
    

    D3DXVECTOR3 erstellt ein sog. temporäres Objekt, also ein Objekt das keinen Namen hat und nur temporär existiert (vereinfacht gesagt bis zum nächsten ;).

    Und C++ hat eine Regel die sagt dass es nicht erlaubt ist direkt die Adresse von temporären Objekten zu nehmen. Sinn der Regel ist dass es meist keinen Sinn macht die Adresse von temporären Objekten zu nehmen, und leicht zu Fehlern führen kann. (In diesem Fall ist es OK, aber das ist halt eher die Ausnahme als die Regel.) Visual C++ erlaubt es aber aus historischen Gründen, wenn mit der "permissive" Einstellung kompiliert wird. Da es kein Standard C++ ist, bekommst du aber trotzdem eine Warnung.

    Möglichkeiten das zu lösen gibt es einige, z.B.:

    • Du kannst benannte Variablen für die 3 Parameter machen, und dann die Adresse der Variable nehmen, also
    auto const camPos = D3DXVECTOR3 (0.0f, 0.0f, 10.0f);
    auto const lookAt = D3DXVECTOR3 (0.0f, 0.0f, 0.0f);
    auto const upDirection = D3DXVECTOR3 (0.0f, 1.0f, 0.0f);
    D3DXMatrixLookAtLH(&matView, &camPos, &lookAt, &upDirection));
    
    • Du kannst dir eine Hilfsfunktion bauen um die Regel zu umgehen, ala
    template <class T>
    T const* getAddress(T const& t) {
        return &t;
    }
    
    // ...
    
        D3DXMatrixLookAtLH(&matView,
                           getAddress(D3DXVECTOR3 (0.0f, 0.0f, 10.0f)),    // the camera position
                           getAddress(D3DXVECTOR3 (0.0f, 0.0f, 0.0f)),    // the look-at position
                           getAddress(D3DXVECTOR3 (0.0f, 1.0f, 0.0f)));    // the up direction
    
    • Du kannst die Warnung deaktivieren
    • Du kannst die Warnung ignorieren

    Die letzten beiden würde ich aber nicht unbedingt empfehlen. Damit gewöhnst du dir nur an non-Standard Features zu verwenden, oder noch schlimmer, Compiler-Warnungen zu ignorieren.

    Ich persönlich würde vermutlich die erste Variante verwenden. Sie kommt ohne zusätzliche Hilfsfunktionen aus, und hat gleichzeitig noch den Vorteil dass durch die Variablen-Namen selbst-dokumentierender Code entsteht (die Namen der Variablen ersetzen die Kommentare).



  • Dieser Beitrag wurde gelöscht!


  • Jetzt, nachdem mir das Viereck in 3D gelungen ist, wollte ich nur noch fragen, wie
    eine Kugel in DirectX 9 erstellt werden kann. In diesem Tutorial wird ein Würfel
    modelliert. Für das Modellieren einer Kugel wird die Funktion D3DXCreateSphere
    zur Verfügung gestellt, welche in diesem eBook Seite 84 aufgezählt wird.



  • OK. Und die Frage ist...?



  • @member sagte in Viereck zeichnen:

    Jetzt, nachdem mir das Viereck in 3D gelungen ist, wollte ich nur noch fragen, wie
    eine Kugel in DirectX 9 erstellt werden kann.
    [...]
    Für das Modellieren einer Kugel wird die Funktion D3DXCreateSphere
    zur Verfügung gestellt, welche in diesem eBook Seite 84 aufgezählt wird.

    Wenn ich mir die Funktion D3DXCreateSphere ansehe:

    HRESULT D3DXCreateSphere(
      _In_  LPDIRECT3DDEVICE9 pDevice,
      _In_  FLOAT             Radius,
      _In_  UINT              Slices,
      _In_  UINT              Stacks,
      _Out_ LPD3DXMESH        *ppMesh,
      _Out_ LPD3DXBUFFER      *ppAdjacency
    );
    

    ... dann sieht das für mich so aus, dass diese ein D3DXMESH und einen D3DXBUFFER erzeugt (Out-Parameter). Das LP vor dem Namen bedeutet einfach nur, dass es Pointer auf ID3DXMesh/ID3DXBUFFER-Interfaces implementierende Objekte sind ("Long Pointer", die Skelette im Keller der 16-Bit-Vergangenheit von Windows 😁).

    In dem von dir verlinkten eBook werden ab Kapitel 10 (Buchseite 160) Meshes besprochen (Meshes Part I/II). Dort heisst es unter "Objectives":

    To learn how to render an ID3DXMesh.

    Das sollten alle Bausteine sein, mit denen du dir die Antwort zusammensetzen kannst - ich gehe mal davon aus, dass du mit "eine Kugel erstellen" diese "auf dem Bildschirm darstellen" meinst. "Erstellt" wird sie ja eigentlich bereits mit D3DXCreateSphere.

    Alternativ kannst du die Kugel auch selbst rendern, ohne D3DXCreateSphere zu verwenden - so wie du dein Viereck dargestellt hast - z.B. ebenfalls mit Triangle Strips oder du generierst eben ein Mesh (sollte man auch lernen, was es mit denen auf sich hat). Sich zu erarbeiten, wie man diese zusammensetzt und die Koordinaten der Eckpunkte berechnet, würde ich als gute Übungsaufgabe erachten. Es schadet nicht, sowas selbst hinbekommen zu können, wenn man ernsthaft 3D-Grafik machen will 🙂


Anmelden zum Antworten