4. Viereck zeichnen

Viereck zeichnen

  • ?

    @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.

    0
  • M

    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.

    0

  • @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?

    0 1 Antwort

  • @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.

    1
  • M

    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();
}
    0

  • @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).

    0
  • M

    Dieser Beitrag wurde gelöscht!
    0
  • M

    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.

    0
    F
     1 Antwort

  • OK. Und die Frage ist...?

    0
  • F

    @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 🙂

    0
Anmelden zum Antworten