none
C++ e Directx - Ajudem-me; RRS feed

  • Pergunta

  • Olá galera, acho que já estou enchendo o saco de vcs, mas estou com o seguinte problema, estou utilizando o VS2003, e a linguagem C++, então no form crio um groupbox e dentro do groupbox quero chamar uma janela que é criada num código de exemplo de utilização do directx, que é quebrado em 3 arquivos, seguem os arquivos:

    D3DUtility.h --------------------------------------------------------------------------------------------------------------------------------

    #ifndef __d3dUtilityH__

    #define __d3dUtilityH__

    #include <d3dx9.h>

    #include <string>

    namespace d3d

    {

    bool InitD3D(

    HINSTANCE hInstance, // [in] Application instance.

    int width, int height, // [in] Backbuffer dimensions.

    bool windowed, // [in] Windowed (true)or full screen (false).

    D3DDEVTYPE deviceType, // [in] HAL or REF

    IDirect3DDevice9** device);// [out]The created device.

    int EnterMsgLoop(

    bool (*ptr_display)(float timeDelta));

    LRESULT CALLBACK WndProc(

    HWND hwnd,

    UINT msg,

    WPARAM wParam,

    LPARAM lParam);

    template<class T> void Release(T t)

    {

    if( t )

    {

    t->Release();

    t = 0;

    }

    }

    template<class T> void Delete(T t)

    {

    if( t )

    {

    delete t;

    t = 0;

    }

    }

    const D3DXCOLOR WHITE( D3DCOLOR_XRGB(255, 255, 255) );

    const D3DXCOLOR BLACK( D3DCOLOR_XRGB( 0, 0, 0) );

    const D3DXCOLOR RED( D3DCOLOR_XRGB(255, 0, 0) );

    const D3DXCOLOR GREEN( D3DCOLOR_XRGB( 0, 255, 0) );

    const D3DXCOLOR BLUE( D3DCOLOR_XRGB( 0, 0, 255) );

    const D3DXCOLOR YELLOW( D3DCOLOR_XRGB(255, 255, 0) );

    const D3DXCOLOR CYAN( D3DCOLOR_XRGB( 0, 255, 255) );

    const D3DXCOLOR MAGENTA( D3DCOLOR_XRGB(255, 0, 255) );

    //

    // Lights

    //

    D3DLIGHT9 InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color);

    D3DLIGHT9 InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color);

    D3DLIGHT9 InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color);

    //

    // Materials

    //

    D3DMATERIAL9 InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p);

    const D3DMATERIAL9 WHITE_MTRL = InitMtrl(WHITE, WHITE, WHITE, BLACK, 2.0f);

    const D3DMATERIAL9 RED_MTRL = InitMtrl(RED, RED, RED, BLACK, 2.0f);

    const D3DMATERIAL9 GREEN_MTRL = InitMtrl(GREEN, GREEN, GREEN, BLACK, 2.0f);

    const D3DMATERIAL9 BLUE_MTRL = InitMtrl(BLUE, BLUE, BLUE, BLACK, 2.0f);

    const D3DMATERIAL9 YELLOW_MTRL = InitMtrl(YELLOW, YELLOW, YELLOW, BLACK, 2.0f);

    }

    #endif // __d3dUtilityH__

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    D3DUtility.cpp ------------------------------------------------------------------------------------------------------------------------------------------------------------------

    #include "d3dUtility.h"

    bool d3d::InitD3D(

    HINSTANCE hInstance,

    int width, int height,

    bool windowed,

    D3DDEVTYPE deviceType,

    IDirect3DDevice9** device)

    {

    //

    // Create the main application window.

    //

    WNDCLASS wc;

    wc.style = CS_HREDRAW | CS_VREDRAW;

    wc.lpfnWndProc = (WNDPROC)d3d::WndProc;

    wc.cbClsExtra = 0;

    wc.cbWndExtra = 0;

    wc.hInstance = hInstance;

    wc.hIcon = LoadIcon(0, IDI_APPLICATION);

    wc.hCursor = LoadCursor(0, IDC_ARROW);

    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

    wc.lpszMenuName = 0;

    wc.lpszClassName = "Teste";

    if( !RegisterClass(&wc) )

    {

    ::MessageBox(0, "RegisterClass() - FAILED", 0, 0);

    return false;

    }

    HWND hwnd = 0;

    hwnd = ::CreateWindow("Teste", "Teste",

    WS_EX_TOPMOST,

    0, 0, width, height,

    0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/);

    if( !hwnd )

    {

    ::MessageBox(0, "CreateWindow() - FAILED", 0, 0);

    return false;

    }

    ::ShowWindow(hwnd, SW_SHOW);

    ::UpdateWindow(hwnd);

    //

    // Init D3D:

    //

    HRESULT hr = 0;

    // Step 1: Create the IDirect3D9 object.

    IDirect3D9* d3d9 = 0;

    d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

    if( !d3d9 )

    {

    ::MessageBox(0, "Direct3DCreate9() - FAILED", 0, 0);

    return false;

    }

    // Step 2: Check for hardware vp.

    D3DCAPS9 caps;

    d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);

    int vp = 0;

    if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )

    vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;

    else

    vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    // Step 3: Fill out the D3DPRESENT_PARAMETERS structure.

    D3DPRESENT_PARAMETERS d3dpp;

    d3dpp.BackBufferWidth = width;

    d3dpp.BackBufferHeight = height;

    d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;

    d3dpp.BackBufferCount = 1;

    d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;

    d3dpp.MultiSampleQuality = 0;

    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

    d3dpp.hDeviceWindow = hwnd;

    d3dpp.Windowed = windowed;

    d3dpp.EnableAutoDepthStencil = true;

    d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;

    d3dpp.Flags = 0;

    d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;

    d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

    // Step 4: Create the device.

    hr = d3d9->CreateDevice(

    D3DADAPTER_DEFAULT, // primary adapter

    deviceType, // device type

    hwnd, // window associated with device

    vp, // vertex processing

    &d3dpp, // present parameters

    device); // return created device

    if( FAILED(hr) )

    {

    // try again using a 16-bit depth buffer

    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

    hr = d3d9->CreateDevice(

    D3DADAPTER_DEFAULT,

    deviceType,

    hwnd,

    vp,

    &d3dpp,

    device);

    if( FAILED(hr) )

    {

    d3d9->Release(); // done with d3d9 object

    ::MessageBox(0, "CreateDevice() - FAILED", 0, 0);

    return false;

    }

    }

    d3d9->Release(); // done with d3d9 object

    return true;

    }

    int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )

    {

    MSG msg;

    ::ZeroMemory(&msg, sizeof(MSG));

    static float lastTime = (float)timeGetTime();

    while(msg.message != WM_QUIT)

    {

    if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))

    {

    ::TranslateMessage(&msg);

    ::DispatchMessage(&msg);

    }

    else

    {

    float currTime = (float)timeGetTime();

    float timeDelta = (currTime - lastTime)*0.001f;

    ptr_display(timeDelta);

    lastTime = currTime;

    }

    }

    return msg.wParam;

    }

    D3DLIGHT9 d3d::InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color)

    {

    D3DLIGHT9 light;

    ::ZeroMemory(&light, sizeof(light));

    light.Type = D3DLIGHT_DIRECTIONAL;

    light.Ambient = *color * 0.4f;

    light.Diffuse = *color;

    light.Specular = *color * 0.6f;

    light.Direction = *direction;

    return light;

    }

    D3DLIGHT9 d3d::InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color)

    {

    D3DLIGHT9 light;

    ::ZeroMemory(&light, sizeof(light));

    light.Type = D3DLIGHT_POINT;

    light.Ambient = *color * 0.4f;

    light.Diffuse = *color;

    light.Specular = *color * 0.6f;

    light.Position = *position;

    light.Range = 1000.0f;

    light.Falloff = 1.0f;

    light.Attenuation0 = 1.0f;

    light.Attenuation1 = 0.0f;

    light.Attenuation2 = 0.0f;

    return light;

    }

    D3DLIGHT9 d3d::InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color)

    {

    D3DLIGHT9 light;

    ::ZeroMemory(&light, sizeof(light));

    light.Type = D3DLIGHT_SPOT;

    light.Ambient = *color * 0.4f;

    light.Diffuse = *color;

    light.Specular = *color * 0.6f;

    light.Position = *position;

    light.Direction = *direction;

    light.Range = 1000.0f;

    light.Falloff = 1.0f;

    light.Attenuation0 = 1.0f;

    light.Attenuation1 = 0.0f;

    light.Attenuation2 = 0.0f;

    light.Theta = 0.5f;

    light.Phi = 0.7f;

    return light;

    }

    D3DMATERIAL9 d3d::InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p)

    {

    D3DMATERIAL9 mtrl;

    mtrl.Ambient = a;

    mtrl.Diffuse = d;

    mtrl.Specular = s;

    mtrl.Emissive = e;

    mtrl.Power = p;

    return mtrl;

    }

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    xfile.cpp----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    #include "d3dUtility.h"

    #include <fstream>

    #include <vector>

    //

    // Globals

    //

    IDirect3DDevice9* Device = 0;

    const int Width = 640;

    const int Height = 480;

    ID3DXMesh* Mesh[4] = {0, 0, 0, 0}; //Array contendo info de 4 meshes

    D3DXMATRIX Worlds[4]; //array de 4 matrizes para usar como transladora dos meshes

    //ID3DXMesh* Mesh = 0;

    std::vector<D3DMATERIAL9> Mtrls(0); //setando materiais

    std::vector<IDirect3DTexture9*> Textures(0);//setando texturas

     

     

    std::ofstream OutFile; // used to dump mesh data to file (descarrega info sobre o Mesh)

    //

    // Prototypes //Prototipo das funções de Carregamento das info da tabela de atributo do Mesh

    //

    void dumpVertices(std::ofstream& outFile, ID3DXMesh* mesh);//Info dos vertices contidos

    void dumpIndices(std::ofstream& outFile, ID3DXMesh* mesh);//Info dos indices contidos

    void dumpAttributeBuffer(std::ofstream& outFile, ID3DXMesh* mesh);//Info sobre substrato dos vertices

    void dumpAdjacencyBuffer(std::ofstream& outFile, ID3DXMesh* mesh);//Info sobre adjacencia dos triangulos do mesh

    void dumpAttributeTable(std::ofstream& outFile, ID3DXMesh* mesh);//Info sobre ID de cada vertice e triangulos do mesh

    //

    // Classes and Structures //Classes e structs gerais, de setar Mesh , mostrar, renderizar e carrega um Xfile

    //

    struct Vertex //Estrutura criada pra armazenar as caracteristas gerais dos triangulos do Mesh

    {

    Vertex(){}

    Vertex(float x, float y, float z,

    float nx, float ny, float nz, float u, float v)

    {

    _x = x; _y = y; _z = z; //coordenadas eixo X Y Z

    _nx = nx; _ny = ny; _nz = nz;// Normais dos eixos

    _u = u; _v = v; //Texturas

    }

    float _x, _y, _z, _nx, _ny, _nz, _u, _v;

    static const DWORD FVF; //tipo de formato dos Vertices

    };

    const DWORD Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1; //Formato de Vertice setado anteriormente, para XYZ, Normais e possuir texturas

    //

    // Framework functions

    ///////////////////////////////////

    //Funçoes ou métodos utilizados no carregamento do Mesh, o preenchimento de

    //seus atributos dentro de uma tabela, suas caracteristas etc

    ///////////////////////////////////

    bool Setup()

    {

    HRESULT hr = 0;

    //

    // Load the XFile data.

    ///////////////////////////////////////////////////////////////////

    //Carrega o Xfile em questao q será utilizado para servir de padrão

    //no projeto, no caso os eixos q serão progressivos e atualizados e um mesh estatico q será o

    //plano cartesiano

    ///////////////////////////////////////////////////////////////////

    ID3DXBuffer* adjBuffer = 0; //buffer de memoria para armazenar as adjacencias entre triangulos do mesh

    ID3DXBuffer* mtrlBuffer = 0; //buffer para armazenar os tipos de materiais

    DWORD numMtrls = 0; //o tipo de material

    int j=0;

    Vertex* v=0;

    for(j=0; j<4; j++) //Loop para fazer carregamento de 4 meshes

    {

    ////////////////////

    //função q carrega um Mesh a partir de um Xfile, um modelo pronto criado em programas de modelagem 3d

    ////////////

    //OBS: testar uso de D3DUSAGE_DYNAMIC ao inves de D3DXMESH_MANAGED

    ///////////////

    hr = D3DXLoadMeshFromX(

    "bigship1.x",

    D3DXMESH_MANAGED,

    Device,

    &adjBuffer,

    &mtrlBuffer,

    0,

    &numMtrls,

    &Mesh[j]);

    if(FAILED(hr))

    {

    ::MessageBox(0, "D3DXLoadMeshFromX() - FAILED", 0, 0);//em caso de falha de carregamento do Mesh exibe essa mensagem de erro, try e catch da vida

    return false;

    }

    //

    // Extract the materials, and load textures.

    ////////////////////////////////////////////

    //Obtenção dos materiais e texturas do Mesh (apenas os materiais serão mais atuantes no

    //projeto, pq eles q servirao de ponto de referencia para os Mesh serem atualizados

    ////////////////////////////////////////////

    if( mtrlBuffer != 0 && numMtrls != 0 )

    {

    D3DXMATERIAL* mtrls = (D3DXMATERIAL*)mtrlBuffer->GetBufferPointer();

    for(int i = 0; i < numMtrls; i++)

    {

    // the MatD3D property doesn't have an ambient value set

    // when its loaded, so set it now:

    ////////////////////////////

    //se o n possue nenhum material ele seta como difuso (transparente)

    ////////////////////////////

    mtrlsIdea.MatD3D.Ambient = mtrlsIdea.MatD3D.Diffuse;

    // save the ith material

    Mtrls.push_back( mtrlsIdea.MatD3D );

    // check if the ith material has an associative texture

    //checa associação entre uma textura e um material no mesh

    if( mtrlsIdea.pTextureFilename != 0 )

    {

    // yes, load the texture for the ith subset

    //se tiver associação carregar a textura para o substrato em questao

    IDirect3DTexture9* tex = 0;

    D3DXCreateTextureFromFile(

    Device,

    mtrlsIdea.pTextureFilename,

    &tex);

    // save the loaded texture

    Textures.push_back( tex );

    }

    else

    {

    // no texture for the ith subset

    //nenhuma textura para associar com um substrato

    Textures.push_back( 0 );

    }

    }

    }

    d3d::Release<ID3DXBuffer*>(mtrlBuffer); // done w/ buffer //fecha o Buffer

    //

    // Optimize the mesh.

    //Optimização do Mesh

    hr = Mesh[j]->OptimizeInplace(

    D3DXMESHOPT_ATTRSORT |

    D3DXMESHOPT_COMPACT |

    D3DXMESHOPT_VERTEXCACHE,

    (DWORD*)adjBuffer->GetBufferPointer(),

    0, 0, 0);

    d3d::Release<ID3DXBuffer*>(adjBuffer); // done w/ buffer //fecha buffer

    if(FAILED(hr))

    {

    ::MessageBox(0, "OptimizeInplace() - FAILED", 0, 0);

    return false;

    }

    //

    // Fill in vertices

    /////////////////////////////////////////////////

    //Importante: carrega atributos do Mesh carregado a partir do Xfile e preenche dentro de

    //um array de vertices do tipo Vertex q é uma struct que criamos

    /////////////////////////////////////////////////

    // Vertex* v=0;

    // Mesh[j]->GetVertexBuffer(&v);

    Mesh[j]->LockVertexBuffer(0, (void**)&v);//apenas carrega o buffer

    Mesh[j]->UnlockVertexBuffer();//fecha o buffer

    //

    // Define the triangles of the box

    ///////////////////////////////////////////////////

    //Importante: carrega atributos do Mesh carregado a partir do Xfile e preenche dentro de

    //um array de indices, para então formar os triangulos ou primitivas constituintes do Mesh

    ///////////////////////////////////////////////////

    WORD* i=0;

    Mesh[j]->LockIndexBuffer(0, (void**)&i);//carrega o buffer com os indices

     

    Mesh[j]->UnlockIndexBuffer();//fecha o buffer

     

    //

    // Dump the Mesh Data to file.

    /////////////////////////////

    //Estou trabalhando nisso ainda, se trata das funções que carregam e soltam as informações

    //gerais do Mesh dentro de um .txt, super util para arranjar informaçoes do mesh em questao

    //, consegui apenas fazer isso com 1 mesh, com um array de mesh ele vai sobreescrevendo

    //as informações contidas a cada laço do Loop, preciso resolver isso ainda

    //////////////////////////////

    OutFile.open("Mesh Dump.txt"); //criação do arquivo .txt

    dumpVertices(OutFile, Mesh[j]); //carrega info sobre vertices

    dumpIndices(OutFile, Mesh[j]);//carrega info sobre os indices

    dumpAttributeTable(OutFile, Mesh[j]); //carrega info da ID

    dumpAttributeBuffer(OutFile, Mesh[j]); //info dos substratos

    dumpAdjacencyBuffer(OutFile, Mesh[j]); //adjacencia dos triangulos

    OutFile.close();

    //////////////////////////////

    //NOTA: resolver problema de passagem de argumento para essa função, ainda não consegui fazer

    //o TXT carrega info de todos os meshs carregados e armazenados em Buffer

    //////////////////////////////

    }

    //

    // Build world matrices - position the objects in world space.

    //////////////////////////////////////////////////////////////

    ///Seta Locais dentro do espaço global aonde ficarão os mesh, notoriamente é util

    //pra posicionar os meshs que serão criados a medida q serão passados os argumentos

    // para V1, V2 e também o plano cartesiano q será estatico

    //////////////////////////////////////////////////////////////

    D3DXMatrixTranslation(&Worlds[0], 0.0f, 0.0f, 0.0f);//matriz transladora posicionando o mesh 1

    D3DXMatrixTranslation(&Worlds[1], 0.0f, -4.0f, 0.0f);//matriz transladora posicionando o mesh 2

    D3DXMatrixTranslation(&Worlds[2], -4.0f, 0.0f, 0.0f);//matriz transladora posicionando o mesh 3

    D3DXMatrixTranslation(&Worlds[3], 4.0f, 4.0f, 0.0f);//matriz transladora posicionando o mesh 4

     

    /* Mesh[0]->LockVertexBuffer(0, (void**)&v);

    for(int i = 0; i < Mesh[0]->GetNumVertices(); i++)

    {

    vIdea._x +=4.0; vIdea._y +=0.0; vIdea._z +=0.0;

    vIdea._nx +=4.0; vIdea._ny +=0.0; vIdea._nz +=0.0;

    }

    Mesh[0]->UnlockVertexBuffer();

    */

    /*

    for(int h=0; h<4; h++)

    {

    DWORD* attributeBuffer = 0;

    Mesh[0]->LockAttributeBuffer(0, &attributeBuffer);

    // an attribute for each face

    for(int i = 0; i < Mesh[0]->GetNumFaces(); i++)

    {

    if(attributeBufferIdea==0)

    {

    Mesh[0]->LockVertexBuffer(0, (void**)&v);

    for(int k = 0; k < Mesh[0]->GetNumVertices(); k++)

    {

    v[k]._x=v[k]._x+1; v[k]._y +=0.0; v[k]._z +=0.0;

    v[k]._nx +=0.0; v[k]._ny +=0.0; v[k]._nz +=0.0;

    }

    Mesh[0]->UnlockVertexBuffer();

    }

    }

    Mesh[0]->UnlockAttributeBuffer();

    }

    */

    //

    // Set texture filters.

    //

    Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);

    Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);

    Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

    //

    // Set Lights.

    //Setar luzes, tipo de luz, cor, posição etc

    D3DXVECTOR3 dir(1.0f, -1.0f, 1.0f); //direção da luz

    D3DXCOLOR col(1.0f, 1.0f, 1.0f, 1.0f);//cor da luz a incidir no Mesh

    D3DLIGHT9 light = d3d::InitDirectionalLight(&dir, &col);//Tipo de luz criada, passando como argumentos direção e cor

    Device->SetLight(0, &light); //setando o tipo de luz

    Device->LightEnable(0, true); //habilitando luz no espaço global

    Device->SetRenderState(D3DRS_NORMALIZENORMALS, true); //renderizar a partir das normais

    Device->SetRenderState(D3DRS_SPECULARENABLE, true); //

    //

    // Set camera.

    //Seta camera, posição, tipo, direçao aonde esta apontando etc

    D3DXVECTOR3 pos(4.0f, 4.0f, -13.0f); //posição da camera no espaço global

    D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);//para aonde esta apontada a camera

    D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);// esse indica o lado de cima e baixo da camera,

    //exemplo: se tivermos a camera apontando para uma arvora e o Up estiver de acorde com o lado

    //de cima da arvore, mostrará na tela a arvore normal, se o up estiver setado ao contrario eh

    //como se a camera estivesse segurada de cabeça para baixo e a arvore desenhada na tela será

    //de cabeça para baixo

    D3DXMATRIX V; //cria-se uma matriz 3d(diferente do tipo de estrutura de dado matriz) para a camera

    D3DXMatrixLookAtLH(

    &V,

    &pos,

    &target,

    &up);

    //////////////////////

    //Função do directx que seta uma camera e para aonde está olhando, passado como argumentos

    //uma matriz 3d q será a camera dentro do espaço global, um posicionamento dela, posição para

    // aonde está apontando seu foco ou lente de exibição (frustum) e seu lado de "cima"

    //////////////////////

     

    Device->SetTransform(D3DTS_VIEW, &V);//método q recebe info da camera

    //

    // Set projection matrix.

    //Matriz projeção da camera, é como setar o FOV ou campo de visão da camera, seu frustum

    D3DXMATRIX proj;

    D3DXMatrixPerspectiveFovLH(

    &proj,

    D3DX_PI * 0.5f, // 90 - degree// foco da projeção, quanto maior for esse valor mais distante camera os meshs aparentarão estar, pois a perpectiva na verdade se trata da abertura angular da visão ou foco da camera

    (float)Width / (float)Height,

    1.0f,

    1000.0f);

    //função q seta perspectiva da camera

    Device->SetTransform(D3DTS_PROJECTION, &proj);

    return true;

    }

    void Cleanup()

    {

    for(int j=0; j<4; j++)

    {

    d3d::Release<ID3DXMesh*>(Mesh[j]);

    for(int i = 0; i < Textures.size(); i++)

    d3d::Release<IDirect3DTexture9*>( TexturesIdea );

    }

    }

    //////////////

    //Função que desenha o Mesh, o espaço global em si dentro da tela e o exibe

    ////////////

    bool Display(float timeDelta)

    {

    if( Device )

    {

    /*Vertex* v;

    //aumenta em 1 o eixo do X no vertice 2

    if(::GetAsyncKeyState('A') & 0x8000f)

    {

    for(int j=0; j<4; j++)

    {

    Mesh[j]->LockVertexBuffer(0, (void**)&v);

    for(int i = 0; i < Mesh[j]->GetNumVertices(); i++)

    {

    vIdea._x +=4.0;

    }

    Mesh[j]->UnlockVertexBuffer();

    }

    }*/

    /*

    //

    // Update: Rotate the mesh.

    //

    static float y = 0.0f;

    D3DXMATRIX yRot;

    D3DXMatrixRotationY(&yRot, y);

    y += timeDelta;

    if( y >= 6.28f )

    y = 0.0f;

    D3DXMATRIX World = yRot;

    Device->SetTransform(D3DTS_WORLD, &World);

    */

    //

    // Render

    //Renderização do Mesh, texturas, ou seja, desenhar os substratos

    Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);

    Device->BeginScene(); //método para começar a "cena" criada em 3d

    for(int j=0; j<4; j++)

    {

    /* Vertex* v;

    Mesh[j]->LockVertexBuffer(0, (void**)&v);

    if(::GetAsyncKeyState('A') & 0x8000f)

    {

    for(int i = 0; i < Mesh[j]->GetNumVertices(); i++)

    {

    vIdea._x +=4.0;

    }

    }

    Mesh[j]->UnlockVertexBuffer();

    */

    for(int i = 0; i < Mtrls.size(); i++)

    {

    Device->SetMaterial( &MtrlsIdea ); //seta materiais

    Device->SetTexture(0, TexturesIdea); //seta texturas

    Mesh[j]->DrawSubset(i); //tendo texturas, materiais, agora podemos desenhar os substratos, ou seja, o Mesh

    Device->SetTransform(D3DTS_WORLD, &Worlds[j]);//método necessário para desenhar os meshs dentro do espaço global de acordo co a matriz transladora que setamos anteriormente na Função SETUP()

    }

    }

    Device->EndScene(); //finaliza a cena

    Device->Present(0, 0, 0, 0);

    }

    return true;

    }

    //

    // WndProc

    //

    LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

    {

    switch( msg )

    {

    case WM_DESTROY:

    ::PostQuitMessage(0);

    break;

    case WM_KEYDOWN:

    if( wParam == VK_ESCAPE )

    ::DestroyWindow(hwnd);

    break;

    }

    return ::DefWindowProc(hwnd, msg, wParam, lParam);

    }

    //

    // WinMain

    //Função principal que inicia o aplicativo em janela de Windows

    /*

    int WINAPI WinMain(HINSTANCE hinstance,

    HINSTANCE prevInstance,

    PSTR cmdLine,

    int showCmd)

    {

    if(!d3d::InitD3D(hinstance,

    Width, Height, true, D3DDEVTYPE_HAL, &Device))

    {

    ::MessageBox(0, "InitD3D() - FAILED", 0, 0);

    return 0;

    }

    if(!Setup())

    {

    ::MessageBox(0, "Setup() - FAILED", 0, 0);

    return 0;

    }

    d3d::EnterMsgLoop( Display );//função criada semelhante ao message loop comum, serve normalmente

    // para desenhar as janelas na tela e mante-la lá estatica e não apenas abrir ela e já de imediato fechar

    //seria um loop ou delay da execução do programa em janela para q n feche de imediato, nesse caso foi

    //criado essa função e passado como argumento a função Display que é a função que criamos para

    //desenhar os Mesh, o espaço global na tela, normalmente omitir essa função apenas fará o programa

    // abrir rapidamente e fechar, a aplicação de um msg loop comum apenas abriria uma janela em branco

    // e que permaneceria estática esperando um comando (normalmente o escape para finalizar o programa)

    ////////////////////////////////////////////////////////////////////////////////

    Cleanup();

    Device->Release();

    return 0;

    }

    */

     

    //

    // Prototype Implementations

    //

    void dumpVertices(std::ofstream& outFile, ID3DXMesh* mesh)

    {

    outFile << "Vertices:" << std::endl;

    outFile << "---------" << std::endl << std::endl;

    Vertex* v = 0;

    mesh->LockVertexBuffer(0, (void**)&v);

    for(int i = 0; i < mesh->GetNumVertices(); i++)

    {

    outFile << "Vertex " << i << ": (";

    outFile << vIdea._x << ", " << vIdea._y << ", " << vIdea._z << ", ";

    outFile << vIdea._nx << ", " << vIdea._ny << ", " << vIdea._nz << ", ";

    outFile << vIdea._u << ", " << vIdea._v << ")" << std::endl;

    }

    mesh->UnlockVertexBuffer();

    outFile << std::endl << std::endl;

    }

    void dumpIndices(std::ofstream& outFile, ID3DXMesh* mesh)

    {

    outFile << "Indices:" << std::endl;

    outFile << "--------" << std::endl << std::endl;

    WORD* indices = 0;

    mesh->LockIndexBuffer(0, (void**)&indices);

    for(int i = 0; i < mesh->GetNumFaces(); i++)

    {

    outFile << "Triangle " << i << ": ";

    outFile << indices[i * 3 ] << " ";

    outFile << indices[i * 3 + 1] << " ";

    outFile << indices[i * 3 + 2] << std::endl;

    }

    mesh->UnlockIndexBuffer();

    outFile << std::endl << std::endl;

    }

    void dumpAttributeBuffer(std::ofstream& outFile, ID3DXMesh* mesh)

    {

    outFile << "Attribute Buffer:" << std::endl;

    outFile << "-----------------" << std::endl << std::endl;

    DWORD* attributeBuffer = 0;

    mesh->LockAttributeBuffer(0, &attributeBuffer);

    // an attribute for each face

    for(int i = 0; i < mesh->GetNumFaces(); i++)

    {

    outFile << "Triangle lives in subset " << i << ": ";

    outFile << attributeBufferIdea << std::endl;

    }

    mesh->UnlockAttributeBuffer();

    outFile << std::endl << std::endl;

    }

    void dumpAdjacencyBuffer(std::ofstream& outFile, ID3DXMesh* mesh)

    {

    outFile << "Adjacency Buffer:" << std::endl;

    outFile << "-----------------" << std::endl << std::endl;

    // three enttries per face

    std::vector<DWORD> adjacencyBuffer(mesh->GetNumFaces() * 3);

    mesh->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

    for(int i = 0; i < mesh->GetNumFaces(); i++)

    {

    outFile << "Triangle's adjacent to triangle " << i << ": ";

    outFile << adjacencyBuffer[i * 3 ] << " ";

    outFile << adjacencyBuffer[i * 3 + 1] << " ";

    outFile << adjacencyBuffer[i * 3 + 2] << std::endl;

    }

    outFile << std::endl << std::endl;

    }

    void dumpAttributeTable(std::ofstream& outFile, ID3DXMesh* mesh)

    {

    outFile << "Attribute Table:" << std::endl;

    outFile << "----------------" << std::endl << std::endl;

    // number of entries in the attribute table

    DWORD numEntries = 0;

    mesh->GetAttributeTable(0, &numEntries);

    std::vector<D3DXATTRIBUTERANGE> table(numEntries);

    mesh->GetAttributeTable(&table[0], &numEntries);

    for(int i = 0; i < numEntries; i++)

    {

    outFile << "Entry " << i << std::endl;

    outFile << "-----------" << std::endl;

    float vert=0;

    vert=mesh->GetNumVertices();

    outFile << "Subset ID: " << tableIdea.AttribId << std::endl;

    outFile << "Face Start: " << tableIdea.FaceStart << std::endl;

    outFile << "Face Count: " << tableIdea.FaceCount << std::endl;

    outFile << "Vertex Start: " << tableIdea.VertexStart << std::endl;

    outFile << "Vertex Count: " << tableIdea.VertexCount << std::endl;

    outFile << "Vertex Number Total: "<< vert << std::endl;

    outFile << std::endl;

    }

    outFile << std::endl << std::endl;

    }

     

     

    // fazer funcionar ainda

    /*

    void dumpVertices(std::ofstream& outFile, &mesh)

    {

    outFile << "Vertices:" << std::endl;

    outFile << "---------" << std::endl << std::endl;

    Vertex* v = 0;

    mesh->LockVertexBuffer(0, (void**)&v);

    for(int i = 0; i < mesh->GetNumVertices(); i++)

    {

    outFile << "Vertex " << i << ": (";

    outFile << vIdea._x << ", " << vIdea._y << ", " << vIdea._z << ", ";

    outFile << vIdea._nx << ", " << vIdea._ny << ", " << vIdea._nz << ", ";

    outFile << vIdea._u << ", " << vIdea._v << ")" << std::endl;

    }

    mesh[j]->UnlockVertexBuffer();

    outFile << std::endl << std::endl;

    }

    void dumpIndices(std::ofstream& outFile, ID3DXMesh* Mesh[4])

    {

    for(int j=0; j<4; j++)

    {

    outFile << "Indices:" << std::endl;

    outFile << "--------" << std::endl << std::endl;

    WORD* indices = 0;

    Mesh[j]->LockIndexBuffer(0, (void**)&indices);

    for(int i = 0; i < Mesh[j]->GetNumFaces(); i++)

    {

    outFile << "Triangle " << i << ": ";

    outFile << indices[i * 3 ] << " ";

    outFile << indices[i * 3 + 1] << " ";

    outFile << indices[i * 3 + 2] << std::endl;

    }

    Mesh[j]->UnlockIndexBuffer();

    outFile << std::endl << std::endl;

    }

    }

    void dumpAttributeBuffer(std::ofstream& outFile, ID3DXMesh* Mesh[4])

    {

    for(int j=0; j<4; j++)

    {

    outFile << "Attribute Buffer:" << std::endl;

    outFile << "-----------------" << std::endl << std::endl;

    DWORD* attributeBuffer = 0;

    Mesh[j]->LockAttributeBuffer(0, &attributeBuffer);

    // an attribute for each face

    for(int i = 0; i < Mesh[j]->GetNumFaces(); i++)

    {

    outFile << "Triangle lives in subset " << i << ": ";

    outFile << attributeBufferIdea << std::endl;

    }

    Mesh[j]->UnlockAttributeBuffer();

    outFile << std::endl << std::endl;

    }

    }

    void dumpAdjacencyBuffer(std::ofstream& outFile, ID3DXMesh* Mesh[4])

    {

    for(int j=0; j<4; j++)

    {

    outFile << "Adjacency Buffer:" << std::endl;

    outFile << "-----------------" << std::endl << std::endl;

    // three enttries per face

    std::vector<DWORD> adjacencyBuffer(Mesh[j]->GetNumFaces() * 3);

    Mesh[j]->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

    for(int i = 0; i < Mesh[j]->GetNumFaces(); i++)

    {

    outFile << "Triangle's adjacent to triangle " << i << ": ";

    outFile << adjacencyBuffer[i * 3 ] << " ";

    outFile << adjacencyBuffer[i * 3 + 1] << " ";

    outFile << adjacencyBuffer[i * 3 + 2] << std::endl;

    }

    outFile << std::endl << std::endl;

    }

    }

    void dumpAttributeTable(std::ofstream& outFile, ID3DXMesh* Mesh[4])

    {

    for(int j=0; j<4; j++)

    {

    outFile << "Attribute Table:" << std::endl;

    outFile << "----------------" << std::endl << std::endl;

    // number of entries in the attribute table

    DWORD numEntries = 0;

    Mesh[j]->GetAttributeTable(0, &numEntries);

    std::vector<D3DXATTRIBUTERANGE> table(numEntries);

    Mesh[j]->GetAttributeTable(&table[0], &numEntries);

    for(int i = 0; i < numEntries; i++)

    {

    outFile << "Entry " << i << std::endl;

    outFile << "-----------" << std::endl;

    outFile << "Subset ID: " << tableIdea.AttribId << std::endl;

    outFile << "Face Start: " << tableIdea.FaceStart << std::endl;

    outFile << "Face Count: " << tableIdea.FaceCount << std::endl;

    outFile << "Vertex Start: " << tableIdea.VertexStart << std::endl;

    outFile << "Vertex Count: " << tableIdea.VertexCount << std::endl;

    outFile << std::endl;

    }

    outFile << std::endl << std::endl;

    }

    }

    */

    -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    Então amigos, se compilar esses 3 arquivos, ele cria uma janela manualmente, com a função CreateWindow, e dentro da janela desenha a mashe que eu preciso que desenhe dentro do groupbox, no form, será que alguém consegue me informar como faço para chamar essa janela que cria dentro do groupbox, pois nesse código ele cria, instancia e chama a janela, então quando tento instanciar dentro do groupbox da erro, pois fala que estou chamando 2 vezes o winmain, pois nesse código tbm possui um winmain, e o form que criei com o groupbox tbm, será que alguém poderia me ajudar? Agradeço desde já e peço desculpas pelas várias linhas ocupadas.....

     

    Marcus

    terça-feira, 18 de julho de 2006 02:45