Vertex + Textur + DirectInput

Webdesigner's
Verfügbare Informationen zu "Vertex + Textur + DirectInput"

  • Qualität des Beitrags: 0 Sterne
  • Beteiligte Poster: Snowball
  • Forum: Webdesigner's
  • Forenbeschreibung: Das Hilfe Forum für alle Webdesigner
  • aus dem Unterforum: DirectX 9 & c++
  • Antworten: 1
  • Forum gestartet am: Freitag 20.07.2007
  • Sprache: deutsch
  • Link zum Originaltopic: Vertex + Textur + DirectInput
  • Letzte Antwort: vor 16 Jahren, 28 Tagen, 5 Stunden, 29 Minuten
  • Alle Beiträge und Antworten zu "Vertex + Textur + DirectInput"

    Re: Vertex + Textur + DirectInput

    Snowball - 29.03.2008, 00:44

    Vertex + Textur + DirectInput
    Code: #include <windows.h>
    #include <windowsx.h>
    #include <d3d9.h>
    #include <d3dx9.h>
    #include <dinput.h>

    #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)


    #pragma comment (lib, "d3d9.lib")
    #pragma comment (lib, "d3dx9.lib")
    #pragma comment (lib, "dinput.lib")
    #pragma comment (lib, "dinput8.lib")
    #pragma comment (lib, "dxguid.lib")



    LPDIRECT3D9 d3d;   
    LPDIRECT3DDEVICE9 d3ddev;   
    LPDIRECT3DVERTEXBUFFER9 t_buffer = NULL; 
    LPDIRECTINPUT8 din;    // the pointer to our DirectInput interface
    LPDIRECTINPUTDEVICE8 dinkeyboard;    // the pointer to the keyboard device



    LPDIRECT3DTEXTURE9 texture_1;   
    static float index2 = 10.0f;


    void initD3D(HWND hWnd);   
    void render_frame(void);   
    void cleanD3D(void);   
    void init_graphics(void);
    void initDInput(HINSTANCE hInstance, HWND hWnd);    // sets up and initializes DirectInput
    void detect_keys(void);    // gets the current keys being pressed
    void cleanDInput(void);    // closes DirectInput and releases memory

    struct CUSTOMVERTEX {FLOAT X, Y, Z; DWORD COLOR; FLOAT U, V;};
    #define CUSTOMFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)


    LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);


    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.lpszClassName = "WindowClass";

        RegisterClassEx(&wc);

        hWnd = CreateWindowEx(NULL, "WindowClass", "Our Direct3D Program",
                              WS_EX_TOPMOST | WS_POPUP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT,
                              NULL, NULL, hInstance, NULL);

        ShowWindow(hWnd, nCmdShow);

        initDInput(hInstance, hWnd);
        initD3D(hWnd);

       

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

           
            if(KEY_DOWN(VK_ESCAPE))
                PostMessage(hWnd, WM_DESTROY, 0, 0);

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

       
     

        return msg.wParam;
    }



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



    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;

     
        d3d->CreateDevice(D3DADAPTER_DEFAULT,
                          D3DDEVTYPE_HAL,
                          hWnd,
                          D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                          &d3dpp,
                          &d3ddev);

        init_graphics();   

        d3ddev->SetRenderState(D3DRS_LIGHTING, FALSE);   
        d3ddev->SetRenderState(D3DRS_ZENABLE, TRUE);   

        return;
    }



    void render_frame(void)
    {
        d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

        d3ddev->BeginScene();

       
        d3ddev->SetFVF(CUSTOMFVF);

        // SET UP THE PIPELINE

        D3DXMATRIX matRotateY;   

        static float index = 0.0f; index+=0.05f;   
       
       
        D3DXMatrixRotationY(&matRotateY, index);

       
        d3ddev->SetTransform(D3DTS_WORLD, &matRotateY);

        D3DXMATRIX matView;   

        D3DXMatrixLookAtLH(&matView,
                           &D3DXVECTOR3 (0.0f, 0.0f, index2),   
                           &D3DXVECTOR3 (0.0f, 0.0f, 0.0f),   
                           &D3DXVECTOR3 (0.0f, 1.0f, 0.0f));   

        d3ddev->SetTransform(D3DTS_VIEW, &matView);   

        D3DXMATRIX matProjection;     

        D3DXMatrixPerspectiveFovLH(&matProjection,
                                   D3DXToRadian(45),   
                                   (FLOAT)SCREEN_WIDTH / (FLOAT)SCREEN_HEIGHT,
                                   1.0f,   
                                   100.0f);   

        d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection);   

       
        d3ddev->SetStreamSource(0, t_buffer, 0, sizeof(CUSTOMVERTEX));


        d3ddev->SetTexture(0, texture_1);

     
            // draw the textured square
        d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 1);

        d3ddev->EndScene();

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

        return;
    }



    void cleanD3D(void)
    {
        t_buffer->Release();   
       texture_1->Release();   
        d3ddev->Release();   
        d3d->Release();   

        return;
    }



    void init_graphics(void)
    {

       
        D3DXCreateTextureFromFile(d3ddev,
                                  "stone.png",
                                  &texture_1);

       
        CUSTOMVERTEX t_vert[] =
        {
            { 5.0f, -5.0f, 0.0f, 0xffffffff, 1, 0 },
            { 0.0f, 5.0f, 0.0f, 0xffffffff, 1, 1 },
            { -5.0f, -5.0f, 0.0f, 0xffffffff, 0, 1 },
        };
     
        d3ddev->CreateVertexBuffer(3*sizeof(CUSTOMVERTEX),
                                   0,
                                   CUSTOMFVF,
                                   D3DPOOL_MANAGED,
                                   &t_buffer,
                                   NULL);

        VOID* pVoid;   

       
        t_buffer->Lock(0, 0, (void**)&pVoid, 0);
        memcpy(pVoid, t_vert, sizeof(t_vert));
        t_buffer->Unlock();

        return;
    }

    void initDInput(HINSTANCE hInstance, HWND hWnd)
    {
        // create the DirectInput interface
        DirectInput8Create(hInstance,    // the handle to the application
                           DIRECTINPUT_VERSION,    // the compatible version
                           IID_IDirectInput8,    // the DirectInput interface version
                           (void**)&din,    // the pointer to the interface
                           NULL);    // COM stuff, so we'll set it to NULL

        // create the keyboard device
        din->CreateDevice(GUID_SysKeyboard,    // the default keyboard ID being used
                          &dinkeyboard,    // the pointer to the device interface
                          NULL);    // COM stuff, so we'll set it to NULL

        dinkeyboard->SetDataFormat(&c_dfDIKeyboard); // set the data format to keyboard format

        // set the control you will have over the keyboard
        dinkeyboard->SetCooperativeLevel(hWnd,
                                         DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);

          return;    // return to WinMain()
    }

    void detect_keys(void)
    {
        static BYTE keystate[256];    // create a static storage for the key-states

        dinkeyboard->Acquire();    // get access if we don't have it already

        dinkeyboard->GetDeviceState(256, (LPVOID)keystate);    // fill keystate with values

          if(keystate[DIK_A] & 0x80)    // if the 'A' key was pressed...

            // then inform the user of this very important message:
            index2 = 20.0f;

        return;
    }



    Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken



    Weitere Beiträge aus dem Forum Webdesigner's

    WinAPI - WinAPI Installieren - gepostet von Snowball am Sonntag 22.07.2007



    Ähnliche Beiträge wie "Vertex + Textur + DirectInput"

    Bewerbung Chip und Chap - berserker (Sonntag 04.02.2007)
    Bewerbung Pladin - Anonymous (Sonntag 24.06.2007)
    Bewerbung von Ghostsnapper - Anonymous (Dienstag 13.03.2007)
    Bewerbung 60er Druide[Tryout failed] - Eridan (Dienstag 05.12.2006)
    Regeln zum schreiben einer Bewerbung - mitsurugi (Sonntag 09.01.2005)
    Bewerbung Kingspartan - Anonymous (Samstag 03.11.2007)
    Bewerbung - RaStA PoLe (Montag 22.05.2006)
    Bewerbung für Kara und den 25er Raid - Horax (Montag 15.10.2007)
    Bewerbung eines Hexenmeisters[Tryout failed] - Ryu (Donnerstag 18.01.2007)
    Bewerbung eines Hexenmeisters - Anonymous (Montag 03.12.2007)