• <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游戲編程相關鏈接

            搜索

            最新評論

            亚洲伊人久久大香线蕉综合图片| 色综合色天天久久婷婷基地| 久久综合给合久久狠狠狠97色| 久久国产精品无码一区二区三区 | 俺来也俺去啦久久综合网| 麻豆一区二区99久久久久| 国内精品久久久久影院网站| 久久夜色精品国产噜噜噜亚洲AV| 国产精品熟女福利久久AV| 色婷婷久久综合中文久久蜜桃av | 91久久精品视频| 少妇精品久久久一区二区三区| 久久国产成人| 久久综合九色综合欧美狠狠| 亚洲人成精品久久久久| 久久婷婷人人澡人人| 久久九九亚洲精品| 久久精品国产99久久无毒不卡| 久久久www免费人成精品| 久久精品无码av| 国产精品日韩欧美久久综合| 久久国产精品久久精品国产| 日产精品99久久久久久| 亚洲欧美伊人久久综合一区二区 | 国产午夜福利精品久久2021 | www.久久精品| 久久久久久亚洲AV无码专区| 亚洲AV日韩精品久久久久| 狠狠色丁香婷婷久久综合五月 | 中文字幕乱码久久午夜| 一级a性色生活片久久无| 人妻无码精品久久亚瑟影视| 久久综合九色欧美综合狠狠 | 人妻丰满AV无码久久不卡| 精品久久久无码人妻中文字幕| 久久毛片一区二区| 天天爽天天狠久久久综合麻豆 | 99久久精品九九亚洲精品| 精品久久人人爽天天玩人人妻| 久久精品二区| 久久国产精品无|