3

我正在编写一个游戏引擎，我为对象设置了这个类：

class SceneManager //controls everything in the "world" game
{
    public:
        void Add(SceneObject* object); //adds to the vector
    private:
        vector<SceneObject*> _worldObjects; //the vector that contains all of them
}

我在游戏中工作的所有类都继承自 SceneObject：

class SceneObject
{
    public: 
        virtual void Draw() = 0;
}

class Image : public SceneObject
{ }
class Sprite : public SceneObject
{ }
class Model3D : public SceneObject
{ }

所以我知道我可以为向量中的所有对象调用 Draw()。但是我一直在进行优化，我试图摆脱所有继承和虚函数，而是使用组合，因为它们不能被内联，并且在每个对象上执行时似乎是一个主要的性能问题基础。

我正在寻找一些 C++ 技术，我可以使用它来在我的向量中存储一堆场景对象，然后在其上调用 Draw() 并正确绘制与之相关的对象。这也适用于我用作虚拟的 Update() 函数。

所以这段代码：

void SceneManager::Add(SceneObject* object)
{
    _worldObjects.push_back(object);
}
void SceneManager::DrawTheWorld()
{
    for(unsigned int i = 0; i < _worldObjects.size(); i++)
    {
        _worldObjects[i]->Draw(); //SceneObject's being called
    }
}

...会成为：

void SceneManager::Add(Image* image)
{
    SceneObject* object = new SceneObject();
    //link object to image somehow, tried to use it as a member of image
    _worldObjects.push_back(object);
}
void SceneManager::DrawTheWorld()
{
    for(unsigned int i = 0; i < _worldObjects.size(); i++)
    {
        //_worldObjects[i]->
        //I need somehow to be able to get the pointer back to the original class
        //It can be an image, sprite, model3d, anything
    }
}

我不认为如果我添加一个开关或 if/elses 并删除虚拟我会获得任何性能，所以我试图弄清楚是否有一种干净的方法来处理这个问题。

有任何想法吗？

4

3 回答 3

12

您可以使用自由函数对drawable对象的方面进行建模：

#include <iostream>

class Image { };
class Sprite { };
class Model3D { };

namespace draw_aspect
{
    void draw(Image const& image)     { std::cout << "drawing image\n";   } 
    void draw(Sprite const& sprite)   { std::cout << "drawing sprite\n";  } 
    void draw(Model3D const& model3D) { std::cout << "drawing model3D\n"; } 
}

现在，要么使用三个单独的向量（这很可能是最佳的，取决于集合中对象之间的排序关系？），或者考虑一个变体类型向量：

1.使用变体类型

#include <boost/variant.hpp>
using SceneObject = boost::variant<Image, Sprite, Model3D>;

namespace draw_aspect {    

    struct draw_visitor : boost::static_visitor<> {
        template <typename T> void operator()(T const& t) const { draw(t); }
    };

    void draw(SceneObject const& sobj) { 
        static const draw_visitor _vis;
        boost::apply_visitor(_vis, sobj);
    }
}

后者概念的完整证明：Live on Coliru

#include <vector>

class SceneManager //controls everything in the "world" game
{
    public:
        void Add(SceneObject v) { _worldObjects.emplace_back(std::move(v)); }
        friend void draw(SceneManager const& sm) { return sm.draw(); }
    private:
        void draw() const {
            for(auto& sobj : _worldObjects)
                draw_aspect::draw(sobj);
        } 
        std::vector<SceneObject> _worldObjects; //the vector that contains all of them
};

int main()
{
    SceneManager sman;

    sman.Add(Image());
    sman.Add(Sprite());
    sman.Add(Model3D());
    sman.Add(Image());

    draw(sman);
}

输出

drawing image
drawing sprite
drawing model3D
drawing image

2. 分开收藏

使用单独向量的替代方案：Live on Coliru

class SceneManager //controls everything in the "world" game
{
    public:
        void Add(Image v)   { _images  .emplace_back(std::move(v)); }
        void Add(Sprite v)  { _sprites .emplace_back(std::move(v)); }
        void Add(Model3D v) { _model3Ds.emplace_back(std::move(v)); }

        friend void draw(SceneManager const& sm) { return sm.draw(); }
    private:
        void draw() const {
            for(auto& sobj : _images)   draw_aspect::draw(sobj);
            for(auto& sobj : _sprites)  draw_aspect::draw(sobj);
            for(auto& sobj : _model3Ds) draw_aspect::draw(sobj);
        } 
        std::vector<Image> _images;
        std::vector<Sprite> _sprites;
        std::vector<Model3D> _model3Ds;
};

int main()
{
    SceneManager sman;

    sman.Add(Image());
    sman.Add(Sprite());
    sman.Add(Model3D());
    sman.Add(Image());

    draw(sman);
}

请注意，输出是不同的（排序）：

drawing image
drawing image
drawing sprite
drawing model3D
于 2013-09-17T21:09:10.373 回答
1

解决您的具体请愿书是其他人已经做过的一件事。

但是，我认为您应该退后一步，考虑整体情况。这是一个明智的步骤吗？虚拟函数的任何可能替代方案都会引入可维护性问题，即难以修改甚至难以理解代码。

问题是：这真的有必要吗？真的会补偿吗？

虚函数涉及取消引用两个指针，而不仅仅是一个。是的，它确实不会被内联。然而，我不认为这是一个真正的问题。我确实会专注于算法级别的优化，并在删除虚拟函数之前浪费所有其他方法。

考虑到至少一个解决方案涉及将虚函数转换为常规函数（不是成员函数），消除了众所周知的虚函数（即对象本身的类）相对于 if 链的优势。

也就是说，这是你的电话。

于 2013-09-18T07:39:06.713 回答
0

由于您似乎具有固定数量的类型，因此似乎一种合理的方法是每种类型使用一个向量并为每种类型分别应用操作：处理一系列异构对象是否使用虚函数都会造成一些干扰不是。将如何调用各个对象的框架放入函数模板中将方便地处理共性。

于 2013-09-17T20:59:38.440 回答