spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma once

#include <d3dx9.h>
#include <list>
#include <vector>

class Shape
{
public:
    struct Vertex
    {
        D3DXVECTOR3 pos;
        DWORD       color;
        const static DWORD FVF;

        Vertex(D3DXVECTOR2 p, DWORD c);
    };

    Shape(void);
    ~Shape(void);

    void AddPoint(D3DXVECTOR2 pos, DWORD color);
    bool PushToBuffer(LPDIRECT3DDEVICE9 device);
    void Render(LPDIRECT3DDEVICE9 device);
private:
    std::vector<Vertex*> m_Vertizes;
    std::vector<short> m_Indizes;
    unsigned short m_CurrentIndexPos;

    LPDIRECT3DVERTEXBUFFER9 m_VertexBuffer;
    LPDIRECT3DINDEXBUFFER9 m_IndexBuffer;
};

C-/C++-Quelltext

#include "Shape.h"

const DWORD Shape::Vertex::FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

Shape::Shape(void)
    : m_CurrentIndexPos(0)
{
}

Shape::~Shape(void)
{
    std::vector<Vertex*>::iterator it = m_Vertizes.begin();

    for( ; it != m_Vertizes.begin(); ++it)
    {
        delete (*it);
    }

    m_Vertizes.clear();
}

Shape::Vertex::Vertex(D3DXVECTOR2 p, DWORD c)
    : pos(p.x, p.y, 0), color(c)
{
}

void Shape::AddPoint(D3DXVECTOR2 pos, DWORD color)
{
    m_Vertizes.push_back(new Vertex(pos, color));

    if(m_CurrentIndexPos < 2)
    {
        // Nothing :)
    }
    else
    {
        unsigned short index = m_CurrentIndexPos;
        m_Indizes.push_back(index - 2); // Vorvorletzten Index
        m_Indizes.push_back(index - 1); // Vorletzter Index
        m_Indizes.push_back(index);     // letzter Index
    }

    m_CurrentIndexPos++;
}

bool Shape::PushToBuffer(LPDIRECT3DDEVICE9 device)
{
    if(FAILED(device->CreateVertexBuffer(m_Vertizes.size() * sizeof( Vertex ),
                                        D3DUSAGE_WRITEONLY, 
                                        Vertex::FVF,
                                        D3DPOOL_DEFAULT, 
                                        &m_VertexBuffer, 
                                        NULL)))
    {
        // Failed, error
        return false;
    }

    VOID* pVertices;
    if(FAILED(m_VertexBuffer->Lock(0, 0, reinterpret_cast<void**>(&pVertices), 0)))
    {
        // Failed sth. goes wrong -> exit
        return false;
    }
    // Fine Copy vertices..
    memcpy(pVertices, static_cast<void*>(m_Vertizes[0]), m_Vertizes.size() * sizeof( Vertex ));
    // Unlock buffer :)
    m_VertexBuffer->Unlock();

    if(FAILED(device->CreateIndexBuffer(m_Indizes.size() * sizeof(short),
                                        D3DUSAGE_WRITEONLY,
                                        D3DFMT_INDEX16,
                                        D3DPOOL_DEFAULT,
                                        &m_IndexBuffer,
                                        NULL)))
    {
        return false;
    }
    
    // Try to fill the buffer
    VOID* pIndizes;
    if(FAILED(m_IndexBuffer->Lock(0, 0, reinterpret_cast<void**>(&pIndizes), 0)))
    {
        // Failed sth. goes wrong -> exit
        return false;
    }
    memcpy(pIndizes, static_cast<void*>(&m_Indizes[0]), m_Indizes.size() * sizeof(short));
    m_IndexBuffer->Unlock();

    return true;
}

void Shape::Render(LPDIRECT3DDEVICE9 device)
{
    device->SetFVF(Vertex::FVF);
    device->SetStreamSource(0, m_VertexBuffer, 0, sizeof(Vertex));
    device->SetIndices(m_IndexBuffer);
    
    device->BeginScene();

    device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 
                                0, 
                                0, 
                                m_Vertizes.size(), 
                                0, 
                                (m_Indizes.size() / 3));
                                
    device->EndScene();
}