• <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>

            天行健 君子當自強而不息

            Working with Maps and Levels(14)

            cAutomap::cAutomap and cAutomap::~cAutomap

            The constructor and destructor of the cAutomap class ensure that all data is placed
            within a known state and that all used resources are released. The constructor does
            nothing more than clear some variables and orient a camera to point downward.
            You later use that camera to render the map. The destructor calls on the Free
            function to release all used resources.

             

            cAutomap::create and cAutoMap::free

            All right, take a deep breath for this part. The create function is the biggest of the
            bunch. It loads an .X file and converts each mesh within into a separate vertex
            buffer. Starting with its variable declarations, examine the variable in pieces to
            better understand what’s going on:

            bool cAutoMap::create(pcstr filename, long color)
            {
                free();

                cMesh mesh;
                
            if(! mesh.load(filename, ".\\"))
                    
            return false;

                
            // get number of map section, create section visible flag array, vertex buffer array.

                m_num_sections = mesh.get_num_meshes();
                
            if(m_num_sections == 0)
                {
                    mesh.free();
                    
            return false;
                }

                m_visible = 
            new bool[m_num_sections];
                ZeroMemory(m_visible, m_num_sections);

                m_map_vb = 
            new DIRECT3DVERTEXBUFFER9_PTR[m_num_sections];
                
            long num  = m_num_sections - 1;

                
            // get a bounding radius to scale by
                float radius;
                mesh.get_bounds(NULL, NULL, NULL, NULL, NULL, NULL, &radius);
                m_scale = 128.0f / radius;

                
            // go through each mesh in the cMesh object and construct a matching vertex buffer.
                // make sure to start with last section in map to compensate for linked list ordering of mesh in cMesh.
                for(sMeshInfo* mesh_info = mesh.get_root_mesh(); mesh_info != NULL; mesh_info = mesh_info->m_next)
                {
                    
            static long per_vertex_size = D3DXGetFVFVertexSize(mesh_info->m_d3d_mesh->GetFVF());

                    ID3DXMesh* d3d_mesh = mesh_info->m_d3d_mesh;
                    
            ushort* index_ptr;
                    
            char*   vert_ptr;

                    d3d_mesh->LockIndexBuffer(D3DLOCK_READONLY,  (
            void**) &index_ptr);
                    d3d_mesh->LockVertexBuffer(D3DLOCK_READONLY, (
            void**) &vert_ptr);

                    
            long num_faces = d3d_mesh->GetNumFaces();
                    create_vertex_buffer(&m_map_vb[num], num_faces * 3, 
            sizeof(sMapVertex), AUTO_MAP_FVF);

                    sMapVertex* map_vb_ptr;
                    m_map_vb[num]->Lock(0, 0, (
            void**) &map_vb_ptr, 0);

                    
            // pull out vertices and construct map vertex list, then fill into map vertex buffer.
                    for(long i = 0; i < num_faces; i++)
                    {
                        
            for(long j = 0; j < 3; j++)
                        {
                            
            ushort vert_index = *index_ptr;
                            index_ptr++;

                            sVertex* vert = (sVertex*) &vert_ptr[per_vertex_size * vert_index];

                            sMapVertex map_vert;

                            map_vert.x = vert->x * m_scale;
                            map_vert.y = 0.0f;
                            map_vert.z = vert->z * m_scale;
                            map_vert.diffuse = color;

                            memcpy(map_vb_ptr, &map_vert, 
            sizeof(sMapVertex));
                            map_vb_ptr++;
                        }
                    }

                    m_map_vb[num]->Unlock();
                    d3d_mesh->UnlockVertexBuffer();
                    d3d_mesh->UnlockIndexBuffer();

                    num--;
                }

                mesh.free();

                
            // create a character arrow vertex buffer and fill in it

                sMapVertex arrow_verts[3] = 
                {
                    {  0.0f, 0.0f,  10.0f, D3DCOLOR_RGBA(128, 64, 0, 255) },
                    {  5.0f, 0.0f, -10.0f, D3DCOLOR_RGBA(128, 64, 0, 255) },
                    { -5.0f, 0.0f, -10.0f, D3DCOLOR_RGBA(128, 64, 0, 255) }
                };

                create_vertex_buffer(&m_arrow_vb, 3, 
            sizeof(sMapVertex), AUTO_MAP_FVF);
                fill_in_vertex_buffer(m_arrow_vb, 0, 3, arrow_verts);

                
            return true;
            }

            At this point, some variables are declared, a prior auto map is freed (via a call to
            free), and some error checking is being performed. Notice that the variable declarations
            include the vertex definitions for the pointer vertex buffer.

            Now move on, starting with the code that loads the map mesh that is used to create
            the vertex buffers.

            The first order of business is to load the actual .X file from disc. The first sMesh
            structure is grabbed from the cMesh object (remember from the Graphics Core that
            the cMesh class stores meshes in a linked list of sMeshInfo structures).

            Next, you calculate the size of the vertex structure used by the .X file and calculate
            the scaling factor to alter the meshes being loaded. Finally, you store the number
            of map sections in a class variable. Notice that the number of map sections happens
            to be the number of meshes in the .X file.

            Moving on, you allocate an array of bool variables, with each element in the array
            representing whether a map section is visible. Each map section has a matching
            element in the array. You also create an array of vertex buffers.
            These vertex buffers will be used to store the map sections.

            Remember that the meshes are contained with a linked list of structures. Now is
            the time to iterate through each structure in the linked list and query each structure
            for the pointer to the actual Direct3D ID3DXMesh object that contains the mesh
            information for a single map section.

            Next, you lock the index and vertex buffers and start pulling out the vertex data.

            A vertex buffer is being created to match the number of polygon faces in the source
            mesh. The vertex buffer is being locked and a pointer is being retrieved to start storing
            the vertices.

            Two loops now go through every polygon face in the source mesh, and three vertices
            for each face are copied over to the map vertex buffers. Notice that you use only the
            X- and Z-coordinates, although the Y-coordinate is set to 0 (again to flatten the map).
            Last, you set the diffuse color to the color value provided (used to render the map).

            You wrap up the process by unlocking the index and vertex buffers of the source
            mesh and then proceeding to the next map section mesh in the linked list of
            meshes loaded from the .X file. Notice that the num variable is tracking the vertex
            buffer that is being created, and the preceding code decrements it with each mesh
            being processed.

            You decrement rather than increment the num variable because the meshes in the
            cMesh object are stored in reverse order (to make loading faster), so you must compensate
            to make sure that each map section is numbered sequentially to match the
            order those meshes are stored in the .X file.

            The create function finishes up by creating the pointer vertex buffer and copying
            over the vertex definition data defined earlier. The source mesh is freed and control
            returns to the caller.

            In order to free the map sections from memory, you provide a free function that
            releases all the allocated resources and prepares the class to load another map class.

            posted on 2007-12-10 16:00 lovedday 閱讀(278) 評論(0)  編輯 收藏 引用

            公告

            導航

            統計

            常用鏈接

            隨筆分類(178)

            3D游戲編程相關鏈接

            搜索

            最新評論

            久久亚洲欧美国产精品| 国产精品9999久久久久| 亚洲国产成人精品91久久久| 久久久久久久综合综合狠狠| 日本WV一本一道久久香蕉| AV狠狠色丁香婷婷综合久久 | 一本伊大人香蕉久久网手机| 精品久久久久久无码人妻热 | 久久久精品人妻一区二区三区蜜桃| 久久亚洲熟女cc98cm| 久久久久久久99精品免费观看| 亚洲国产婷婷香蕉久久久久久| 丰满少妇人妻久久久久久| 亚洲国产精品狼友中文久久久| 久久精品国产99国产电影网| 久久91精品国产91| 久久精品国产国产精品四凭| 久久久国产精品亚洲一区| 久久乐国产综合亚洲精品| 色综合久久久久| 久久99精品久久久久久hb无码| 国产精品久久久香蕉| 久久综合伊人77777麻豆| 久久精品国内一区二区三区| 少妇内射兰兰久久| 久久亚洲精品无码VA大香大香| 国内精品伊人久久久久网站| 久久精品视频免费| 免费观看成人久久网免费观看| 色狠狠久久AV五月综合| 伊人久久精品无码二区麻豆| 久久这里有精品| 97精品伊人久久大香线蕉| 综合久久精品色| 狠狠色狠狠色综合久久| 精品国产99久久久久久麻豆 | 国产精品久久久久免费a∨| 久久久久久国产精品无码下载| 久久se精品一区精品二区国产| 国产精品女同一区二区久久| 精品一久久香蕉国产线看播放|