• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            天行健 君子當(dāng)自強而不息

            D3D Animation Basis(5)

            Loading Meshes

            The first of the mesh−related helper functions is load_mesh. Actually there are three versions of the load_mesh function. The first version is used to load a mesh from an .X file using the D3DXLoadMeshFromX function. That means all meshes contained within the .X file are compressed into a single mesh object, which is subsequently stored in a D3DXMESHCONTAINER_EX object.

            All iterations of the load_mesh function contain pointers to a valid 3D device object, the directory path to where your meshes' textures are stored, and the mesh loading flags and optional flexible vertex format that the load_mesh functions use to clone the meshes after loading. That means you can force your loaded meshes to use specific vertex formats!

            Here's the prototype of the first load_mesh function:

            HRESULT load_mesh(D3DXMESHCONTAINER_EX** ret_mesh_container,
              IDirect3DDevice9* device,
              const char* filename,
              const char* texture_path,
              DWORD new_fvf,
              DWORD load_flags);

            The first load_mesh function takes a pointer to a D3DXMESHCONTAINER_EX object pointer that you want to use for storing the loaded mesh data. Notice I said pointer to a pointer. The load_mesh function will allocate the appropriate objects for you and store the pointers in the pointer you pass to load_mesh. This is similar to the way the InitD3D function stores the Direct3D and 3D device object pointers.

            Also, you must pass a valid 3D device object to the load_mesh function (as the device pointer)−you use this device object to create the mesh container and texture buffers. The mesh that you want to load is specified as filename, and the directory in which your textures are located is specified in texture_path. This texture directory path is prefixed to any texture file names as they are loaded.

            Finally, there are new_fvf and load_flags. You use the new_fvf parameter to force the mesh being loaded to use a specific FVF. For instance, if you only wanted to use 3D coordinates and normals, then you would set new_fvf to (D3DFVF_XYZ|D3DFVF_NORMAL). The load_mesh function will use CloneMeshFVF to clone the mesh using the specific FVF you specified.

            The load_flags parameter is used to set the mesh loading flags as specified by the D3DXLoadMeshFromX function in the DX SDK documents. The default value for this parameter is D3DXMESH_SYSTEMMEM, meaning that the mesh is loaded into system memory (as opposed to hardware memory).

            Here is implement of load_mesh function:

            HRESULT load_mesh(D3DXMESHCONTAINER_EX** ret_mesh_container,
                              IDirect3DDevice9
            * device,
                              
            const char* filename,
                              
            const char* texture_path,
                              DWORD new_fvf,
                              DWORD load_flags)
            {
                
            // error checking
                if(ret_mesh_container == NULL || device == NULL || filename == NULL || texture_path == NULL)
                    
            return E_FAIL;

                
            // use system memory if converting FVF
                if(new_fvf)
                    load_flags 
            = D3DXMESH_SYSTEMMEM;

                
            // load the mesh using D3DX routines

                ID3DXBuffer
            *    material_buffer;
                ID3DXBuffer
            *    adj_buffer;
                DWORD            num_materials;
                ID3DXMesh
            *        mesh;

                HRESULT hr 
            = D3DXLoadMeshFromX(filename, load_flags, device, &adj_buffer, &material_buffer, NULL,
                                               
            &num_materials, &mesh);

                
            if(FAILED(hr))
                    
            return hr;

                
            // convert to new FVF first as needed
                if(new_fvf)
                {
                    ID3DXMesh
            * clone_mesh;
                    hr 
            = mesh->CloneMeshFVF(load_flags, new_fvf, device, &clone_mesh);

                    
            if(FAILED(hr))
                    {
                        release_com(adj_buffer);
                        release_com(material_buffer);
                        release_com(mesh);

                        
            return hr;
                    }

                    
            // free prior mesh and store new pointer
                    release_com(mesh);
                    mesh 
            = clone_mesh; clone_mesh = NULL;
                }

                D3DXMESHCONTAINER_EX
            * mesh_container = new D3DXMESHCONTAINER_EX;
                
            *ret_mesh_container = mesh_container;

                
            // store mesh name (filename), type, and mesh pointer.
                mesh_container->Name           = strdup(filename);
                mesh_container
            ->MeshData.Type  = D3DXMESHTYPE_MESH;
                mesh_container
            ->MeshData.pMesh = mesh;

                mesh 
            = NULL;

                
            // store adjacency information

                DWORD adj_buffer_size 
            = adj_buffer->GetBufferSize();

                
            if(adj_buffer_size)
                {
                    mesh_container
            ->pAdjacency = new DWORD[adj_buffer_size];
                    memcpy(mesh_container
            ->pAdjacency, adj_buffer->GetBufferPointer(), adj_buffer_size);
                }

                release_com(adj_buffer);

                
            // build material list

                mesh_container
            ->NumMaterials = num_materials;

                
            if(num_materials == 0)
                {
                    
            // create a default material
                    mesh_container->NumMaterials = 1;
                    mesh_container
            ->pMaterials     = new D3DXMATERIAL[1];
                    mesh_container
            ->textures     = new IDirect3DTexture9*[1];

                    ZeroMemory(mesh_container
            ->pMaterials, sizeof(D3DXMATERIAL));

                    mesh_container
            ->pMaterials[0].MatD3D.Diffuse.r = 1.0f;
                    mesh_container
            ->pMaterials[0].MatD3D.Diffuse.g = 1.0f;
                    mesh_container
            ->pMaterials[0].MatD3D.Diffuse.b = 1.0f;
                    mesh_container
            ->pMaterials[0].MatD3D.Diffuse.a = 1.0f;
                    mesh_container
            ->pMaterials[0].MatD3D.Ambient   = mesh_container->pMaterials[0].MatD3D.Diffuse;
                    mesh_container
            ->pMaterials[0].MatD3D.Specular  = mesh_container->pMaterials[0].MatD3D.Diffuse;
                    mesh_container
            ->pMaterials[0].pTextureFilename = NULL;
                    mesh_container
            ->textures[0]                       = NULL;
                }
                
            else
                {
                    
            // load the materials
                    D3DXMATERIAL* xmaterials   = (D3DXMATERIAL*) material_buffer->GetBufferPointer();
                    mesh_container
            ->pMaterials = new D3DXMATERIAL[mesh_container->NumMaterials];
                    mesh_container
            ->textures   = new IDirect3DTexture9*[mesh_container->NumMaterials];

                    
            for(DWORD i = 0; i < mesh_container->NumMaterials; i++)
                    {
                        mesh_container
            ->pMaterials[i].MatD3D = xmaterials[i].MatD3D;
                        mesh_container
            ->pMaterials[i].MatD3D.Ambient = mesh_container->pMaterials[i].MatD3D.Diffuse;

                        mesh_container
            ->textures[i] = NULL;

                        
            // load the texture if one exists
                        if(xmaterials[i].pTextureFilename)
                        {
                            
            char texture_file[MAX_PATH];
                            sprintf(texture_file, 
            "%s%s", texture_path, xmaterials[i].pTextureFilename);
                            D3DXCreateTextureFromFile(device, texture_file, 
            &mesh_container->textures[i]);
                        }
                    }
                }

                release_com(material_buffer);

                mesh_container
            ->MeshData.pMesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);
                mesh_container 
            = NULL;

                
            return S_OK;
            }

             

            And that's it for the first load_mesh function! Let's check out how to use it. Suppose you want to load a mesh (from a file called Mesh.x) using the load_mesh function just shown. To demonstrate the ability to specify a new FVF, specify that you want to use XYZ components, normals, and texture coordinates for your mesh. Also, suppose your textures are in a subdirectory called \textures. As for the mesh loading flags, leave those alone to allow the mesh to load into system memory (as per the default flag shown in the prototype). Here's the code:

            // Instance the mesh object
            D3DXMESHCONTAINER_EX *Mesh = NULL;

            // Load a mesh − notice the pointer to the mesh object
            load_mesh(&Mesh, pD3DDevice, "Mesh.x", "..\\Textures\\", (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1));

            Once the mesh has been loaded, you can access the mesh object via the Mesh−>MeshData.pMesh object pointer. Also, material data is stored in Mesh−>pMaterials, and texture data is stored in Mesh−>textures. The number of materials a mesh uses is stored in Mesh−>>NumMaterials. To render a loaded mesh, you can use the following code:

            // pMesh = pointer to D3DXMESHCONTAINER_EX object

            // Go through all material subsets
            for(DWORD i=0;i<pMesh−>NumMaterials;i++) {
              // Set material and texture
              pD3DDevice−>SetMaterial(&pMesh−>pMaterials[i].MatD3D);
              pD3DDevice−>SetTexture(0, pMesh−>pTextures[i]);

             // Draw the mesh subset
             pDrawMesh−>DrawSubset(i);
            }


            posted on 2008-04-14 15:52 lovedday 閱讀(353) 評論(0)  編輯 收藏 引用


            只有注冊用戶登錄后才能發(fā)表評論。
            網(wǎng)站導(dǎo)航: 博客園   IT新聞   BlogJava   博問   Chat2DB   管理


            公告

            導(dǎo)航

            統(tǒng)計

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關(guān)鏈接

            搜索

            最新評論

            国产∨亚洲V天堂无码久久久| 伊人热热久久原色播放www| 午夜天堂av天堂久久久| 久久人妻少妇嫩草AV无码专区| 99精品久久精品| 色婷婷综合久久久久中文字幕| 久久91精品国产91| 欧美精品久久久久久久自慰| www.久久99| 要久久爱在线免费观看| 久久精品国产亚洲av水果派| 久久精品国产清自在天天线| 久久久久AV综合网成人| 66精品综合久久久久久久| 久久夜色精品国产亚洲| 青青草原综合久久| 国内精品伊人久久久久妇| 精品久久一区二区三区| 伊人久久精品无码av一区| 久久精品国产亚洲一区二区| yy6080久久| 久久香蕉国产线看观看猫咪?v| 国内精品伊人久久久久AV影院| 精品国产乱码久久久久久人妻| 一本大道久久a久久精品综合| 久久精品国产亚洲av影院| 精品多毛少妇人妻AV免费久久| 久久国产精品免费一区| 99久久99久久精品国产片| 好久久免费视频高清| 77777亚洲午夜久久多喷| 97久久国产露脸精品国产| 日本WV一本一道久久香蕉| 久久这里只有精品首页| 亚洲伊人久久综合中文成人网| 综合久久一区二区三区 | 国产日韩久久久精品影院首页| 97久久国产亚洲精品超碰热| 热re99久久精品国99热| 久久国产免费观看精品3| 韩国免费A级毛片久久|