2.3 对象工厂
2.1、2.2 回答了「自定义对象长什么样」;这一节回答「引擎怎么按类型名造出它们」。OGRE 用工厂模式统一对象创建:SceneManager::createMovableObject(type, name) 拿到类型名,去 Root 的注册表里找对应工厂,工厂负责 new 一个实例出来。这一节解剖 MovableObjectFactory 的真实接口。
本章与站内既有内容的分工
卷一 3.x 的插件章节见过 SceneManagerFactory 被插件注册进 Root;这里的 MovableObjectFactory 是同一模式、更细一档的版本——它造的是场景内容而不是场景管理器。卷三 1.x 的 Entity 就是经 EntityFactory 造的,本节讲这个机制的抽象层。
工厂接口
MovableObjectFactory 的结构很清晰:一个必须覆写的实现钩子(createInstanceImpl)+ 一个公有入口(createInstance)+ 一个默认的销毁实现(destroyInstance)+ 一套类型标志机制:
// OgreMain/include/OgreMovableObject.h:MovableObjectFactory(v14.6.3 源码摘录,已删减)
class _OgreExport MovableObjectFactory : public MovableAlloc
{
private:
/// Type flag, allocated if requested
uint32 mTypeFlag;
/// Internal implementation of create method - must be overridden
virtual MovableObject* createInstanceImpl(
const String& name, const NameValuePairList* params = 0) = 0;
public:
MovableObjectFactory() : mTypeFlag(0xFFFFFFFF) {}
virtual ~MovableObjectFactory() {}
/// Get the type of the object to be created
virtual const String& getType(void) const = 0;
/** Create a new instance of the object.
@param name The name of the new object
@param manager The SceneManager instance that will be holding the
instance once created.
@param params Name/value pair list of additional parameters required to
construct the object (defined per subtype). Optional.
*/
MovableObject* createInstance(
const String& name, SceneManager* manager,
const NameValuePairList* params = 0);
/** Destroy an instance of the object */
virtual void destroyInstance(MovableObject* obj) { delete obj; }
...
virtual bool requestTypeFlags(void) const { return false; }
...
void _notifyTypeFlags(uint32 flag) { mTypeFlag = flag; }
...
uint32 getTypeFlags(void) const { return mTypeFlag; }
};
要点拆解:
| 成员 | 类型 | 说明 |
|---|---|---|
createInstanceImpl | 私有纯虚 | 子类必须实现的创建钩子;只收名字和参数表,造出裸对象 |
getType() | 纯虚 | 类型名,注册表查找键 |
createInstance | 公有非虚 | 调 createInstanceImpl,附带场景管理器上下文;工厂的子类可以覆写它做额外初始化 |
destroyInstance | 公有虚,默认 delete obj | 需要池化/引用管理时覆写 |
requestTypeFlags() | 默认 false | 是否需要 Root 分配唯一类型掩码 |
_notifyTypeFlags(flag) | 非虚 | Root 分配后回写掩码 |
getTypeFlags() | 返回 mTypeFlag | 本工厂所有实例的查询类型掩码 |
为什么默认类型标志是 0xFFFFFFFF(全 1)? 注释解释得很清楚:MovableObject::getTypeFlags 默认返回全 1,匹配任何查询掩码——所以不关心查询过滤的对象可以什么都不做。只有当你希望对象能按类型被场景查询排除/包含时,才让 requestTypeFlags() 返回 true,让 Root 给你分一块(尽量)唯一的掩码,再经 _notifyTypeFlags 回写。createInstanceImpl 被放进 private 是有意的:对外只有 createInstance 一个入口,子类想改创建流程就覆写它。
注册与查找
工厂生命周期挂在插件骨架上:1.3 节的 OctreePlugin::install 创建工厂、initialise 注册,SceneManager 持有一个 MovableObjectFactory 注册表,createMovableObject(type, name, params) 用它按 getType() 精确查找。MovableObject 的 mCreator 成员反向指回工厂,方便按对象销毁时找到它的创建者。
自定义对象的注册与生命周期
flowchart TD
P["宿主或插件持有 MovableObjectFactory"] -->|"注册"| R["Root 工厂表"]
A["SceneManager 创建类型化对象"] -->|"按类型查找"| R
R --> F["对应工厂"]
F -->|"createInstance"| O["MovableObject"]
A -->|"登记对象"| O
O -.->|"可附着到"| S["SceneNode"]
O -->|"从节点脱离、再由工厂回收"| X["destroyInstance"]
X -->|"相关实例释放后"| U["撤销工厂注册"]
谁管理实例,谁知道怎么销毁
Root 的工厂表按类型定位创建者。SceneManager 以类型和名字登记对象。对象挂到节点只建立场景附着关系。销毁时仍要走对应类型的工厂,避免直接删除导致场景登记残留。
原生插件先由 SceneManager 销毁实例,再撤销工厂。在重复创建案例中同时记录对象名和类型,验证重复登记或重名分支。
原生插件与分页 附有可装载动态库及宿主验证命令。
源码定位
OgreMain/include/OgreMovableObject.h:MovableObjectFactory类声明(560)、mTypeFlag(562)、createInstanceImpl纯虚(566-568)、构造函数(570)、getType(573)、createInstance(584-586)、destroyInstance(588)、requestTypeFlags(603)、_notifyTypeFlags(612)、getTypeFlags(619)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面用纯 C++ 复现工厂模式:类型名、创建钩子、默认销毁、类型标志分配(手动与 Root 侧两条路径)。它与 src/02-3-object-factory.cpp 逐字节一致:
// file: src/02-3-object-factory.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/02-3-object-factory.cpp -o bin/02-3-object-factory && ./bin/02-3-object-factory
//
// 复现 MovableObjectFactory 模式(对应 OgreMain/include/OgreMovableObject.h 560- 的类、
// 566-568 的 createInstanceImpl 纯虚、573 的 getType、584-586 的 createInstance、
// 588 的 destroyInstance、603 的 requestTypeFlags、612 的 _notifyTypeFlags、619 的 getTypeFlags):
// 子类实现 getType + createInstanceImpl;destroyInstance 默认 delete;
// 默认类型标志 0xFFFFFFFF(匹配任何查询),requestTypeFlags 为真时由 Root 分配掩码。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <string>
#include <vector>
namespace ogre_repro {
// 对应 NameValuePairList:极简参数表
struct NameValuePairList {};
// 对应 MovableObject:极简(2.1 的抽象版)
class MovableObjectBase {
public:
explicit MovableObjectBase(const std::string& name) : mName(name) {}
virtual ~MovableObjectBase() {}
virtual const std::string& getMovableType() const = 0;
std::string mName;
};
class MyMovable : public MovableObjectBase {
public:
explicit MyMovable(const std::string& name) : MovableObjectBase(name) {}
const std::string& getMovableType() const override { return sType; }
static const std::string sType;
};
const std::string MyMovable::sType = "MyMovable";
// 对应 OgreMovableObject.h 560-:抽象对象工厂
class MovableObjectFactoryBase {
public:
MovableObjectFactoryBase() : mTypeFlag(0xFFFFFFFF) {}
virtual ~MovableObjectFactoryBase() {}
virtual const std::string& getType() const = 0;
// 私有纯虚在派生类中实现;此处为演示置 protected
virtual MovableObjectBase* createInstanceImpl(
const std::string& name, const NameValuePairList* params = nullptr) = 0;
MovableObjectBase* createInstance(
const std::string& name, const NameValuePairList* params = nullptr) {
return createInstanceImpl(name, params);
}
virtual void destroyInstance(MovableObjectBase* obj) { delete obj; }
virtual bool requestTypeFlags() const { return false; }
void _notifyTypeFlags(uint32_t flag) { mTypeFlag = flag; }
uint32_t getTypeFlags() const { return mTypeFlag; }
protected:
uint32_t mTypeFlag;
};
// 具体工厂:创建 MyMovable,请求类型标志
class MyMovableFactory : public MovableObjectFactoryBase {
public:
const std::string& getType() const override { return MyMovable::sType; }
MovableObjectBase* createInstanceImpl(
const std::string& name, const NameValuePairList* params) override {
++mCreateCalls;
return new MyMovable(name);
}
bool requestTypeFlags() const override { return true; }
void destroyInstance(MovableObjectBase* obj) override {
++mDestroyCalls;
MovableObjectFactoryBase::destroyInstance(obj);
}
int mCreateCalls = 0;
int mDestroyCalls = 0;
};
// 不请求类型标志的工厂
class NoFlagFactory : public MovableObjectFactoryBase {
public:
const std::string& getType() const override { return sNoFlag; }
MovableObjectBase* createInstanceImpl(
const std::string& name, const NameValuePairList* params) override {
return new MyMovable(name);
}
static const std::string sNoFlag;
};
const std::string NoFlagFactory::sNoFlag = "NoFlagMovable";
// 对应 Root:为 requestTypeFlags 为真的工厂分配掩码
class SimRoot {
public:
void addFactory(MovableObjectFactoryBase* f) {
mFactories.push_back(f);
if (f->requestTypeFlags()) f->_notifyTypeFlags(1u << mNextBit++);
}
std::vector<MovableObjectFactoryBase*> mFactories;
int mNextBit = 4; // 从第 4 位开始分配
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
MyMovableFactory factory;
// 默认类型标志:全 1(匹配任何查询)
CHECK_EQ(factory.getTypeFlags(), uint32_t(0xFFFFFFFF));
// 类型名
CHECK_EQ(factory.getType(), "MyMovable");
// 需要类型标志
CHECK(factory.requestTypeFlags());
// 创建实例:经公有入口调私有钩子
MovableObjectBase* obj = factory.createInstance("myObj");
CHECK(obj != nullptr);
CHECK_EQ(obj->getMovableType(), "MyMovable");
CHECK_EQ(obj->mName, "myObj");
CHECK_EQ(factory.mCreateCalls, 1);
// 手动通知类型标志(Root 之外的用途)
factory._notifyTypeFlags(1u << 5);
CHECK_EQ(factory.getTypeFlags(), uint32_t(1u << 5));
// 销毁实例:默认 delete
factory.destroyInstance(obj);
CHECK_EQ(factory.mDestroyCalls, 1);
// 不请求类型标志的工厂保持全 1
NoFlagFactory nf;
CHECK(!nf.requestTypeFlags());
CHECK_EQ(nf.getTypeFlags(), uint32_t(0xFFFFFFFF));
// Root 侧:请求类型标志的工厂被分配掩码,未请求的不动
SimRoot root;
root.addFactory(&factory);
CHECK_EQ(root.mFactories.size(), size_t(1));
CHECK_EQ(factory.getTypeFlags(), uint32_t(1u << 4)); // 被分配第 4 位
root.addFactory(&nf);
CHECK_EQ(nf.getTypeFlags(), uint32_t(0xFFFFFFFF)); // 未请求则保持全 1
CHECK_EQ(root.mFactories.size(), size_t(2));
return lab::report("2.3 对象工厂");
}
本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 15/15 通过。
小结
MovableObjectFactory有两个纯虚:getType(类型名/注册表键)与createInstanceImpl(创建钩子);createInstance是公有入口。destroyInstance默认delete obj,需池化时可覆写。- 默认类型标志
0xFFFFFFFF(全 1)匹配任何查询;requestTypeFlags()返回true时 Root 分配唯一掩码并经_notifyTypeFlags回写。 - 工厂注册进 Root 后,
SceneManager::createMovableObject靠类型名找到它并创建实例。
阅读导航:上一节:2.2 自定义可渲染对象 · 下一节:3.1 自定义资源类型 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。