《OGRE 3D 渲染引擎原理与架构》2.3 对象工厂

MovableObjectFactory 是注册进 Root 的造物工厂:getType 提供类型名,createInstanceImpl 纯虚钩子供子类实现,destroyInstance 默认 delete;requestTypeFlags 为真时由 Root 分配唯一类型掩码用于场景查询过滤。lab 复现工厂创建/销毁与类型标志分配。

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 自定义资源类型 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图