我正在编写一个游戏引擎,我为对象设置了这个类:
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 ++技术,我可以使用它来在我的向量中存储一堆SceneObjects,然后在它上面调用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并删除虚拟我会获得任何性能,所以我想弄清楚是否有一个干净的方法来解决这个问题。
有什么想法吗?
答案 0 :(得分: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"; }
}
现在,要么使用三个单独的向量(这可能是最优的,取决于跨集合的对象之间的排序关系?),或者考虑变量类型向量:
#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
使用单独的向量的替代方案: 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
答案 1 :(得分:1)
解决您的具体请愿是其他人已经做过的事情。
但是,我认为你应该退一步考虑整个情况。这是明智的一步吗?虚拟函数的任何可能的替代方案都将引入可维护性问题,即难以修改甚至理解代码。
问题是:这真的有必要吗?它会真的补偿吗?
虚拟函数涉及引用两个指针而不是一个指针。是的,它确实不会被内联。但是,我不认为这是一个真正的问题。我确实会专注于算法级优化,并在删除虚拟函数之前浪费所有其他方法。
考虑到至少有一个解决方案涉及将虚函数转换为常规函数(不是成员函数),消除了虚函数的众所周知的优势(即对象本身的类)与if的链。
据说,这是你的电话。
答案 2 :(得分:0)
由于您似乎有固定数字类型,似乎一种合理的方法是每种类型使用一个向量并为每种类型单独应用操作:处理一系列异构对象将构成一些中断,无论它是否使用虚函数不是。将各个对象如何被调用的框架放入函数模板中将方便地处理共性。