// This class manages the vertex buffer. Therefore, it's actually// the 'geometry' of ablock as opposed to the block itself (since the// block itself would manipulate the block geometry, the transform and the// block material through intermediary classes, all hidden behind a block // view class. class block_geometry{public:  // Building the block is the responsibility of the constructor.   // Therefore, you shouldn't need this function at all.   // Also, this function returns an integer, which you ignore whenever  // you call it. So, remove the return value! Yes, I know you're using  // error codes to specify errors, but since you're calling this function  // from a constructor you don't have a choice but to use exceptions  // anyway, so drop the error code idea.   // int buildBlock();  // What does it mean for a position to be a floating-point value?  // You should explain that this is the _vertical_ position only.   // Besides, why are you moving the block around by setting its vertices?  // This is the exact point of matrices! You don't need this function.  // int moveBlock(float newPosition);  // Now, that's interesting. Changing the color? You don't even provide  // the color that it should be changed to! Besides, either you build the  // color into the material (thus, a uniform variable in your shader)   // and therefore don't have to change the block at all, or you have to   // change the components of the entire block and therefore would be   // going faster by simply constructing a new block and making the  // color a constructor argument.  // void changeColor();  // It does not make sense for a block (as you defined it) to dissapear,   // since it does not _appear_ ! Given how you've defined it, it seems  // that your block is merely a polygon mesh, used as a support for a   // material during rendering.  // void disappear();  // So, this is a static function that renders... what? It has no arguments,  // and is not a member: how does it know what to render? At best, the   // function would be a member function, and would render the block.  // static void render();  // This is what we're going to do here: write a 'render' function that   // 'renders' the block. What will actually happen is that the function   // will set the current stream source to the data inside this block,  // so that all rendering performed after that will use the block's data.  // So, the device can 'use()' the block, set the transform, set the   // material, and render (possibly several times to achieve complex  // effects).   void use() const;  // Of course, with this approach, we also need an function to do the   // actual rendering. This one should be called after all other   // render states (material, transform, stream source) are set.   void render() const;  // Cleanup is what a destructor does.  // void cleanup();  // You don't need a comment to tell you that these are constructors and  // destructors.  block_geometry();  ~block_geometry();// Keep non-public things private.private:  // We don't want the block to be copied around or  // assigned to, because handling vertex buffers is hard.   block_geometry(const block_geometry &);  block_geometry &operator=(const block_geometry &);    // What for?  // int blockNumber;  // This is best handled at the material level.  // int blockColor;  // This is best handled at the transform level.  // float blockPosition;  // What does the 'g_p' here mean? It means that it's a global  // pointer. Well, first, it's not a global variable at all,   // so that part is wrong. Second, do you really need to   // be reminded that it's a pointer? No, you don't! You never  // manipulate vertex buffers by value, therefore you just  // know that it's a pointer. Give it a meaningful name.  // LPDIRECT3DVERTEXBUFFER9 g_pVB;  LPDIRECT3DVERTEXBUFFER9 vertex_buffer;};// Summary:class block_geometry{  block_geometry(const block_geometry &);  block_geometry &operator=(const block_geometry &);  LPDIRECT3DVERTEXBUFFER9 vertex_buffer;public:  void use() const;  void render() const;  block_geometry();  ~block_geometry();};

namespace{  // Don't repeat a magic number in several places : give it   // a name once. Not to mention, 49 is a weird number of sides.   const int sides = 49;}// Postcondition : 'vertex_buffer' is a valid vertex buffer// containing the geometry for the block. block_geometry::block_geometry(){  // We do the initialization here instead of a side function,   // and throw an exception if we fail, because otherwise the   // program will crash when trying to use the badly initialized  // block.  if( FAILED( g_pd3dDevice ->    CreateVertexBuffer( (::sides + 1)* 2 * sizeof(CUSTOMVERTEX),                        0, D3DFVF_CUSTOMVERTEX,                        D3DPOOL_DEFAULT, &vertex_buffer, NULL ) ) )  {    throw std::exception("Could not create vertex buffer");  }  // So, now the vertex buffer is a valid buffer. But wait! If an exception is  // thrown now, it will never be destroyed! Therefore, we need to wrap everything  // in a try-catch block to handle this.    try  {    CUSTOMVERTEX *contents;    if( FAILED( vertex_buffer->Lock( 0, 0, (void**)&contents, 0 ) ) )    {      throw std::exception("Failed to lock vertex buffer.");    }    // Our vertex buffer is now locked. But wait, if an exception is thrown    // now, it will never be unlocked! Therefore, we need to do everything    // in a "try" block.       try    {      // Use the native integer types where possible.      for( int i = 0; i < ::sides + 1; i++ )      {        // Don't forget that this is a constant.         const float theta = (2 * D3DX_PI * i) / ::sides;        const float cos = cosf(theta);        const float sin = sinf(theta);        // Drop the 'position' thing: it is being handled at the transform         // level. besides, it's shorter this way.         pVertices[2*i+0].position = D3DXVECTOR3( sin,-1.0f, cos );        pVertices[2*i+0].normal   = D3DXVECTOR3( sin, 0.0f, cos );        pVertices[2*i+1].position = D3DXVECTOR3( sin, 1.0f, cos );        pVertices[2*i+1].normal   = D3DXVECTOR3( sin, 0.0f, cos );      }    }    catch (...)     {      // So, an exception was thrown before we could unlock the buffer.       // Unlock it now, then propagate the exception.      vertex_buffer -> Unlock();      throw;    }    vertex_buffer -> Unlock();  }  catch (...)  {    // So, an exception happened after the buffer was created, but before    // the constructor ended. Meaning we need to destroy the buffer now.    // And then, propagate the exception.    vertex_buffer -> Release();    throw;  }} block_geometry::~block_geometry(){  vertex_buffer -> Release();}void block_geometry::use() const{  g_pd3dDevice->SetStreamSource( 0, vertex_buffer, 0, sizeof(CUSTOMVERTEX) );  g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );}void block_geometry::render() const{  g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, ::sides*2 );}