Sign in to follow this  
jYeon2061

Don't understand how these triangles are being made

Recommended Posts

jYeon2061    122
Can someone explain to me how this code makes 2 instances of triangles?
// d3d.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
// 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 and keyboard macros
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// 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 t_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 = (WNDPROC)WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    // wc.hbrBackground = (HBRUSH)COLOR_WINDOW;    // not needed any more
    wc.lpszClassName = L"WindowClass";

    RegisterClassEx(&wc);

    hWnd = CreateWindowEx(NULL, L"WindowClass", L"Our Direct3D Program",
                          WS_EX_TOPMOST | WS_POPUP, 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)
    {
        DWORD starting_point = GetTickCount();

        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
                break;

            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        render_frame();

        // check the 'escape' key
        if(KEY_DOWN(VK_ESCAPE))
            PostMessage(hWnd, WM_DESTROY, 0, 0);

        while ((GetTickCount() - starting_point) < 25);
    }

    // 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 = FALSE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow = hWnd;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.BackBufferWidth = SCREEN_WIDTH;
    d3dpp.BackBufferHeight = SCREEN_HEIGHT;
    d3dpp.EnableAutoDepthStencil = TRUE;    // automatically run the z-buffer for us
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;    // 16-bit pixel format for the z-buffer

    // 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
    d3ddev->SetRenderState(D3DRS_ZENABLE, TRUE);    // turn on the z-buffer

    return;
}


// 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->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

    d3ddev->BeginScene();

    // select which vertex format we are using
    d3ddev->SetFVF(CUSTOMFVF);

      // set the view transform
      D3DXMATRIX matView;    // the view transform matrix
    D3DXMatrixLookAtLH(&matView,
                       &D3DXVECTOR3 (0.0f, 0.0f, 15.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

    // set the projection transform
    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, t_buffer, 0, sizeof(CUSTOMVERTEX));

    D3DXMATRIX matTranslateA;    // a matrix to store the translation for triangle A
    D3DXMATRIX matTranslateB;    // a matrix to store the translation for triangle B
    D3DXMATRIX matRotateYA;    // a matrix to store the rotation for each triangle
    D3DXMATRIX matRotateYB;    // a matrix to store the rotation for the reverse sides
    static float index = 0.0f; index+=0.05f; // an ever-increasing float value

    // build MULTIPLE matrices to rotate and translate the model
    D3DXMatrixTranslation(&matTranslateA, 0.0f, 0.0f, 2.0f);
    D3DXMatrixTranslation(&matTranslateB, 0.0f, 0.0f, -2.0f);
    D3DXMatrixRotationY(&matRotateYA, index);    // the front side
    D3DXMatrixRotationY(&matRotateYB, index + 3.14159f);    // the reverse side

    // tell Direct3D about each world transform, and then draw another triangle
    d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateA * matRotateYA));
    d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

    d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateA * matRotateYB));
    d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

    d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateB * matRotateYA));
    d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

    d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateB * matRotateYB));
    d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

    d3ddev->EndScene(); 

    d3ddev->Present(NULL, NULL, NULL, NULL);

    return;
}


// this is the function that cleans up Direct3D and COM
void cleanD3D(void)
{
      t_buffer->Release();    // close and release the vertex buffer
    d3ddev->Release();    // close and release the 3D device
    d3d->Release();    // close and release Direct3D

    return;
}


// this is the function that puts the 3D models into video RAM
void init_graphics(void)
{
    // create the vertices using the CUSTOMVERTEX struct
    CUSTOMVERTEX t_vert[] =
    {
        { 2.5f, -3.0f, 0.0f, D3DCOLOR_XRGB(0, 0, 255), },
        { 0.0f, 3.0f, 0.0f, D3DCOLOR_XRGB(0, 255, 0), },
        { -2.5f, -3.0f, 0.0f, D3DCOLOR_XRGB(255, 0, 0), },
    };

    // create a vertex buffer interface called t_buffer
    d3ddev->CreateVertexBuffer(3*sizeof(CUSTOMVERTEX),
                               0,
                               CUSTOMFVF,
                               D3DPOOL_MANAGED,
                               &t_buffer,
                               NULL);

    VOID* pVoid;    // a void pointer

    // lock t_buffer and load the vertices into it
    t_buffer->Lock(0, 0, (void**)&pVoid, 0);
    memcpy(pVoid, t_vert, sizeof(t_vert));
    t_buffer->Unlock();

    return;
}

[Edited by - jYeon2061 on March 21, 2008 3:38:10 PM]

Share this post


Link to post
Share on other sites
jYeon2061    122
I'm not sure exactly how to explain this but I hope you understand what my question is.

I know it makes it, I don't understand how. There is a struct that holds the vertices' information, but I see no parameters or anything to pass that information to the render_frame() method.

Share this post


Link to post
Share on other sites
jYeon2061    122
Actually nevermind, I think see what is happening. The CUSTOMVERTEX struct is stored in a vertex buffer. Then the render_frame() function uses that vertex buffer when it is set by SetStreamSource().

Am I right?

Share this post


Link to post
Share on other sites
ET3D    810
render_frame does two things before rendering: SetStreamSource and SetFVF. Together they define what is rendered (what vertex buffer and what format it has). Then it renders, setting several transforms, and rendering a triangle for each.

I don't know where this code is from, but drawing a triangle at a time is certainly not a high performance way of rendering.

Share this post


Link to post
Share on other sites
SgtArchAngel    133
Quote:
Original post by jYeon2061
Actually nevermind, I think see what is happening. The CUSTOMVERTEX struct is stored in a vertex buffer. Then the render_frame() function uses that vertex buffer when it is set by SetStreamSource().

Am I right?


yes its being stored in t_buffer

Quote:
Original post by jYeon2061
the code is from directxtutorial.com and what do you mean "at a time"?


he means instead of calling

// tell Direct3D about each world transform, and then draw another triangle
d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateA * matRotateYB));
d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateA * matRotateYA));
d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

d3ddev->SetTransform(D3DTS_WORLD, &(matTranslateA * matRotateYB));
d3ddev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);



3 times in a row you can group them into a single buffer and call it once to render all 3 or thousands

Share this post


Link to post
Share on other sites
jYeon2061    122
Quote:
Original post by SgtArchAngel
Quote:
Original post by jYeon2061
Actually nevermind, I think see what is happening. The CUSTOMVERTEX struct is stored in a vertex buffer. Then the render_frame() function uses that vertex buffer when it is set by SetStreamSource().

Am I right?


yes its being stored in t_buffer

Quote:
Original post by jYeon2061
the code is from directxtutorial.com and what do you mean "at a time"?


he means instead of calling
*** Source Snippet Removed ***

3 times in a row you can group them into a single buffer and call it once to render all 3 or thousands


I don't quite understand what you mean, could you give me an example code?

Share this post


Link to post
Share on other sites
jYeon2061    122
Another question, does the CUSTOMVERTEX struct contain the cartesian coordinates for the trianges? Or is it just the format. If so, how are 2 seperate instances of triangles made and at different locations?

Share this post


Link to post
Share on other sites
Zenroth    127
Each of the triangles is being represented by its own matrix that has been offset. When rendering the vertexes in the buffer are transformed and rotated according to the individual matrix for each triangle, thus giving you the differnt position/rotation.

Share this post


Link to post
Share on other sites
Zenroth    127
Do the triangles rotate? It looks like index is being used as a rotation amount, that increments every draw call. This should result in the triangles spinning about their Y axis from what I make of the code.

Share this post


Link to post
Share on other sites
FoxHunter2    157
Well, it's not really an illusion. Maybe an illusion in terms of a flat object being rendered on a flat screen that looks like it has depth.
But in fact all the calculations being done are pure maths, no illusion. Each triangle has three coordinates (X,Y,Z). By setting the world matrix each of the triangle gets multiplied with this matrix before being rendered to screen (also the view and projection matrix).

The world matrix contains all transformations that will be applied to the vertices so that it finally appears in "world space", which includes translation, rotation, scaling and shearing. So this formula will be applied to every single vertex in the stream:

vertex * WorldMatrix = vertexInWorldSpace


You may want to take a look at the following links to see what's going on under the hood:
This one and
This one

the latter is pretty maths heavy, but you should really understand the concept before working with matrices in DirectX/OpenGL

regards

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this