Код рефакторинга для компонентов игровых компонентов

Question

Как я могу преломлять следующее, чтобы перенести мои функции рисования из h-файла в класс GraphicsManager?

//drawingFunctions.h 
void drawTexturedQuad(Texture texture, Vector2 pos, Vector2 dim) { 
    // bind texture... 
    glBegin(...); // draw 
    //... 
    glEnd(...); 
} 

//class file 
#include "drawingFunctions.h" 
class Player { 
    void drawPlayer(){ drawTexturedQuad(texture, pos, dim) } 
}; 
class Enemy { 
    void drawEnemy(){ drawTexturedQuad(texture, pos, dim) } 
}; 
class Item { 
    void drawItem(){ drawTexturedQuad(texture, pos, dim) } 
}; 
// and so on for the other components 

//gameloop file 
// instantiate components objects 
while (true) { 
    // input, logic 
    Player.drawPlayer(); 
    Enemy.drawEnemy(); 
    Item.drawItem(); 
    // and so on 
} 

(код явно упрощена, я просто спрашиваю о розыгрыше здесь)

Должен ли я ...

• передать указатель на GraphicsManager для каждого вызова drawPlayer, drawEnemy и т. д. изнутри gameloop
• У игрока, Enemy и т. д. есть указатель на GraphicsManger в качестве члена данных
• есть игрок, враг и т.д. leGameComponent, который имеет указатель на GraphicsManager в качестве члена данных
• что-то еще?

Answer 1

Это звучит как идеальный вариант использования для наследования:

class Drawable 
{ 
public: 
    void draw() 
    { 
     // gl stuff 
    } 

protected: 
    Texture _texture; 
    Vector2 _pos; 
    Vector2 _dim; 
}; 


class Player : Drawable 
{ 
public: 
    // should modify _texture _pos and _dim somewhere.  
}; 

// same thing for the other objects. 

Answer 2

Я хотел бы пойти на первой же возможности: передавая указатель на GraphicsManager в вызове. Несмотря на то, что это кажется немного переполненным, знание того, какой GraphicsManager используется, поддерживается на более высоком уровне и может быть изменено позже.

Сказав это, я все равно унаследовал бы от интерфейса Drawable и поместил бы элементы, которые нужно нарисовать в контейнере, чтобы вы могли просто прокручивать его, чтобы отображать элементы с помощью виртуальной функции drawItem(). Как и (C++ 03, не тестировался):

std::vector<Drawable*> Items; 
Items.push_back(&player); 
Items.push_back(&enemy); 
... 
for (std::vector<Drawable*>::iterator it = Items.begin(); it != Items.end(): ++it) 
{ 
    (*it)->drawItem(&graphMgr); 
} 

Answer 3

я передам рендерер к модели, и попросите его нарисовать себя.

class Player 
{ 
public: 
    void draw(Renderer& renderer); 
}; 

class Enemy 
{ 
public: 
    void draw(Renderer& renderer); 
}; 

Примечание Вы не должны назвать функцию drawPlayer или drawEnemy, потому что вы уже знаете, что это Player или Enemy типом класса. Это единое соглашение о вызовах идеально подходит для извлечения в общий интерфейс:

class Model 
{ 
public: 
    virtual void draw(Renderer& renderer) = 0; 

    virtual ~Model() {} 
}; 

Тогда вы можете иметь каждый из ваших моделей наследуют от Model, и каждый реализации draw.

Как я уже упоминал в комментарии к ответу @ J.N., вы также можете быть рендерером абстрактного класса. Например, я работал над проектом, который использовал OpenGL, GDI +, а также для создания распечаток схем.

class Renderer 
{ 
public: 
    virtual render(const Triangle& triangle, const Texture& texture) = 0; 

    virtual ~Renderer() {} 
};