spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

#include"Game.h"

void Game::Init(LPDIRECT3DDEVICE9 D3DDEV)
{
    mdl.Init(D3DDEV);
    tr.Init(D3DDEV);
}

void Game::Render(void)
{
    mdl.Update(D3DXVECTOR3(0,0,5),D3DXVECTOR3(1,1,1),D3DXVECTOR3(0,0,0));
    mdl.Render();
    tr.Render();
}

void Game::Clean(void)
{
    tr.Clean();
}

Quellcode

#include"Terrain.h"

void Terrain::Init(LPDIRECT3DDEVICE9 D3DDEV)
{
    d3ddev = D3DDEV;
    D3DXCreateTextureFromFile(D3DDEV,"C:\\Program Files (x86)\\3D\\Bodensteine12.JPG",&tex);
    D3DDEV->SetTexture(0,tex);

    CUSTOMVERTEX vertices[(MAP_WIDTH+1)*(MAP_HEIGHT+1)];
    for(int x = 0;x < MAP_WIDTH+1;x++)
    {
        for(int z = 0;z < MAP_HEIGHT+1;z++)
        {
            vertices[x+z*(MAP_WIDTH+1)].x = x;
            vertices[x+z*(MAP_WIDTH+1)].y = 0;
            vertices[x+z*(MAP_WIDTH+1)].z = z;
            vertices[x+z*(MAP_WIDTH+1)].u = x;
            vertices[x+z*(MAP_WIDTH+1)].v = z;
        }
    }

    D3DDEV->CreateVertexBuffer((MAP_WIDTH+1)*(MAP_HEIGHT+1)*sizeof(CUSTOMVERTEX),0,D3DFVF_XYZ | D3DFVF_TEX1,D3DPOOL_DEFAULT,&v_buffer,NULL);

    VOID* pVoid;
    v_buffer->Lock(0,0,(void**)&pVoid,0);
    memcpy(pVoid,vertices,sizeof(vertices));
    v_buffer->Unlock();

    int index = 0;
    short indices[MAP_WIDTH*MAP_HEIGHT*6];
    for(int x = 0;x < MAP_WIDTH;x++)
    {
        for(int z = 0;z < MAP_HEIGHT;z++)
        {
            short downLeft = x + z * (MAP_WIDTH+1);
            short downRight = (x+1) + z * (MAP_WIDTH+1);
            short upLeft = x + (z+1) * (MAP_WIDTH+1);
            short upRight = (x+1) + (z+1) * (MAP_WIDTH+1);

            indices[index++] = downLeft;
            indices[index++] = upLeft;
            indices[index++] = downRight;

            indices[index++] = downRight;
            indices[index++] = upLeft;
            indices[index++] = upRight;
        }
    }

    D3DDEV->CreateIndexBuffer(MAP_WIDTH*MAP_HEIGHT*6*sizeof(short),0,D3DFMT_INDEX16,D3DPOOL_DEFAULT,&i_buffer,NULL);

    i_buffer->Lock(0,0,&pVoid,0);
    memcpy(pVoid,indices,sizeof(indices));
    i_buffer->Unlock();
}

void Terrain::Render(void)
{
    d3ddev->SetFVF(D3DFVF_XYZ | D3DFVF_TEX1);
    d3ddev->SetStreamSource(0,v_buffer,0,sizeof(CUSTOMVERTEX));
    d3ddev->SetIndices(i_buffer);
    d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,0,0,(MAP_WIDTH+1)*(MAP_HEIGHT+1),0,MAP_WIDTH*MAP_HEIGHT*2);
}

void Terrain::Clean(void)
{

}

Quellcode

#include"Model.h"

void Model::Init(LPDIRECT3DDEVICE9 D3DDEV)
{
    d3ddev = D3DDEV;
    HRESULT hr=D3DXLoadMeshFromX("C:\\Program Files (x86)\\3D\\Wuerfel.x",D3DXMESH_SYSTEMMEM,D3DDEV,NULL,&materialBuffer,NULL,&numMaterials,&mesh);
    d3dxMaterials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
    meshMaterials = new D3DMATERIAL9[numMaterials];
    meshTextures = new LPDIRECT3DTEXTURE9[numMaterials];
    for (DWORD i = 0;i < numMaterials;i++)
    {
        meshMaterials[i] = d3dxMaterials[i].MatD3D;
        meshMaterials[i].Ambient = meshMaterials[i].Diffuse;
        meshTextures[i] = NULL;

        if(d3dxMaterials[i].pTextureFilename)
            D3DXCreateTextureFromFile(D3DDEV,d3dxMaterials[i].pTextureFilename,&meshTextures[i]);
    }
}

void Model::Update(D3DXVECTOR3 pos,D3DXVECTOR3 scale,D3DXVECTOR3 Rot)
{
    D3DXMATRIX world;
    D3DXMatrixTranslation(&world,pos.x,pos.y,pos.z);
    d3ddev->SetTransform(D3DTS_WORLD,&world);
}

void Model::Render(void)
{
    for (DWORD i = 0;i < numMaterials; i++)
    {
        d3ddev->SetMaterial(&meshMaterials[i]);
        d3ddev->SetTexture(0,meshTextures[i]);
        mesh->DrawSubset(i);
    }
}

void Model::Clean(void)
{
    
}

Quellcode

d3ddev->SetTexture(0,tex)