《OGRE 3D 渲染引擎原理与架构》8.1 GLES2 后端

GLES2RenderSystem 是 OpenGL ES 2.x/3.x 的渲染后端:_initialise 启动 GL 支持并建纹理管理器,createRenderSystemCapabilities 从 GL 字符串与扩展集合点亮 RSC_* 能力位(stencil、GL>=3.0、压缩格式细分、各向异性)。lab 复现版本解析、扩展匹配与能力判定分支。

8.1 GLES2 后端

OGRE 的 GLES2RenderSystem 支撑 OpenGL ES 2.x/3.x(iOS、Android、Emscripten)。它继承 GLRenderSystemCommon,核心职责之一是「能力检测」:从 GL 上下文查询版本、厂商、扩展,转成一份 RenderSystemCapabilities,供场景层决定特性开关。

本章与站内既有内容的分工

卷一讲过 RenderSystem 基类的抽象接口;本节是它的一个具体后端。能力检测(createRenderSystemCapabilities)是后端的自我介绍,8.2/8.3 的 Vulkan、Metal/D3D11 后端各自重复这一职责但走完全不同的 API。lab 聚焦能力位点亮逻辑,不含实际 GL 调用。

初始化:_initialise 与能力创建入口

_initialise 先让 GLSupport 启动(建上下文/加载 GLES 符号),再创建纹理管理器;createRenderSystemCapabilities 是 RenderSystem 基类在初始化流程里调用的纯虚函数,负责探测:

// RenderSystems/GLES2/src/OgreGLES2RenderSystem.cpp:GLES2RenderSystem::_initialise(v14.6.3 源码摘录,已删减)
    void GLES2RenderSystem::_initialise()
    {
        RenderSystem::_initialise();

        mGLSupport->start();
        // Create the texture manager
        mTextureManager = OGRE_NEW GLES2TextureManager(this);
    }

    RenderSystemCapabilities* GLES2RenderSystem::createRenderSystemCapabilities() const
    {
        RenderSystemCapabilities* rsc = OGRE_NEW RenderSystemCapabilities();

        rsc->setCategoryRelevant(CAPS_CATEGORY_GL, true);
        rsc->setDriverVersion(mDriverVersion);

        const char* deviceName = (const char*)glGetString(GL_RENDERER);
        if (deviceName)
        {
            rsc->setDeviceName(deviceName);
        }

        rsc->setRenderSystemName(getName());
        rsc->setVendor(mVendor);

        // Multitexturing support and set number of texture units
        GLint units;
        OGRE_CHECK_GL_ERROR(glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &units));
        rsc->setNumTextureUnits(std::min(OGRE_MAX_TEXTURE_LAYERS, units));

        glGetIntegerv( GL_MAX_VERTEX_ATTRIBS , &units);
        rsc->setNumVertexAttributes(units);
...

GL_MAX_TEXTURE_IMAGE_UNITS 的查询结果被 OGRE_MAX_TEXTURE_LAYERS(编译期上限)截断,防止过大的纹理单元数突破引擎的固定数组(如 mTextureTypes[OGRE_MAX_TEXTURE_LAYERS])。

能力位:stencil 与版本判定

能力位按「查询到的整数或布尔 + 版本/扩展组合」点亮。模板值板(stencil bits)与版本阈值是最直观的两类:

// RenderSystems/GLES2/src/OgreGLES2RenderSystem.cpp:GLES2RenderSystem::createRenderSystemCapabilities(v14.6.3 源码摘录,已删减)
        // Check for hardware stencil support and set bit depth
        GLint stencil;

        OGRE_CHECK_GL_ERROR(glGetIntegerv(GL_STENCIL_BITS, &stencil));

        if(stencil)
        {
            rsc->setCapability(RSC_HWSTENCIL);
            rsc->setCapability(RSC_TWO_SIDED_STENCIL);
        }

        if(hasMinGLVersion(3, 0) ||
                (checkExtension("GL_EXT_sRGB") && checkExtension("GL_NV_sRGB_formats")))
            rsc->setCapability(RSC_HW_GAMMA);

        // Vertex Buffer Objects are always supported by OpenGL ES
        if(hasMinGLVersion(3, 0) || checkExtension("GL_OES_element_index_uint"))
            rsc->setCapability(RSC_32BIT_INDEX);

        // Check for hardware occlusion support
        if(hasMinGLVersion(3, 0) || checkExtension("GL_EXT_occlusion_query_boolean"))
        {
            rsc->setCapability(RSC_HWOCCLUSION);
        }

hasMinGLVersion(3, 0) 把 GL_VERSION 字符串(如 "OpenGL ES 3.2")解析成主/次版本号后比较。GL ES 3.0 起 32 位索引与遮挡查询都是核心特性,因此旧版上要靠对应的 OES/EXT 扩展名兜底。

压缩格式:扩展名列表与细分

RSC_TEXTURE_COMPRESSION 是大类,任何一款压缩扩展都点亮它;然后按厂商/平台命名再细分 PVRTC、DXT、ETC1、ATC、ASTC 等子能力位。注意这里 checkExtension 是精确名称匹配,"GL_IMG_texture_compression_pvrtc" 与 "GL_IMG_texture_compression_pvrtc2" 是两个不同条目:

// RenderSystems/GLES2/src/OgreGLES2RenderSystem.cpp:GLES2RenderSystem::createRenderSystemCapabilities(v14.6.3 源码摘录,已删减)
        // OpenGL ES - Check for these extensions too
        // For 2.0, http://www.khronos.org/registry/gles/api/2.0/gl2ext.h

        if (checkExtension("GL_IMG_texture_compression_pvrtc") ||
            checkExtension("GL_EXT_texture_compression_dxt1") ||
            checkExtension("GL_EXT_texture_compression_s3tc") ||
            checkExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
            checkExtension("GL_AMD_compressed_ATC_texture") ||
            checkExtension("WEBGL_compressed_texture_s3tc") ||
            checkExtension("WEBGL_compressed_texture_atc") ||
            checkExtension("WEBGL_compressed_texture_pvrtc") ||
            checkExtension("WEBGL_compressed_texture_etc1") ||
            checkExtension("WEBGL_compressed_texture_astc") ||
            checkExtension("GL_KHR_texture_compression_astc_ldr"))

        {
            rsc->setCapability(RSC_TEXTURE_COMPRESSION);

            if(checkExtension("GL_IMG_texture_compression_pvrtc") ||
               checkExtension("GL_IMG_texture_compression_pvrtc2") ||
               checkExtension("WEBGL_compressed_texture_pvrtc"))
                rsc->setCapability(RSC_TEXTURE_COMPRESSION_PVRTC);

            if((checkExtension("GL_EXT_texture_compression_dxt1") &&
               checkExtension("GL_EXT_texture_compression_s3tc")) ||
               checkExtension("WEBGL_compressed_texture_s3tc"))
                rsc->setCapability(RSC_TEXTURE_COMPRESSION_DXT);

            if(checkExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
               checkExtension("WEBGL_compressed_texture_etc1"))
                rsc->setCapability(RSC_TEXTURE_COMPRESSION_ETC1);
...

DXT 需要 dxt1 与 s3tc 两个扩展同时存在才点亮——这是 OGRE 的一个保守策略:仅 dxt1 会让部分纹理通道格式不可用。

各向异性与兜底能力

各向异性过滤是可选扩展,点亮 RSC_ANISOTROPY 并把最大各向异性值也存进能力集;RSC_HWRENDER_TO_TEXTURE 作为 GLES2 平台几乎必然的能力无条件点亮:

// RenderSystems/GLES2/src/OgreGLES2RenderSystem.cpp:GLES2RenderSystem::createRenderSystemCapabilities(v14.6.3 源码摘录,已删减)
        // Check for Anisotropy support
        if (checkExtension("GL_EXT_texture_filter_anisotropic"))
        {
            GLfloat maxAnisotropy = 0;
            OGRE_CHECK_GL_ERROR(glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy));
            rsc->setMaxSupportedAnisotropy(maxAnisotropy);
            rsc->setCapability(RSC_ANISOTROPY);
        }

        rsc->setCapability(RSC_HWRENDER_TO_TEXTURE);

能力集创建完成后,initialiseFromRenderSystemCapabilities 用 hasCapability 决定各子系统(程序/缓冲/纹理)的创建方式。GLES2RenderSystem 的类声明同时揭示了它的状态缓存与着色器工厂成员:

// RenderSystems/GLES2/include/OgreGLES2RenderSystem.h:GLES2RenderSystem(v14.6.3 源码摘录,已删减)
    class _OgreGLES2Export GLES2RenderSystem : public GLRenderSystemCommon
    {
        private:
            /// Last min & mip filtering options, so we can combine them
            FilterOptions mMinFilter;
            FilterOptions mMipFilter;

            /// Holds texture type settings for every stage
            GLenum mTextureTypes[OGRE_MAX_TEXTURE_LAYERS];

            /// State cache manager which responsible to reduce redundant state changes
            GLES2StateCacheManager* mStateCacheManager;

            GLSLESProgramManager* mProgramManager;
            GLSLESProgramFactory* mGLSLESProgramFactory;
...
            bool mGLInitialised;
...
        public:
            GLES2RenderSystem();
            virtual ~GLES2RenderSystem();

            const String& getName(void) const override;

            void _initialise() override;

            RenderSystemCapabilities* createRenderSystemCapabilities() const override;

            void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* = NULL) override;

            void shutdown(void) override;

            RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height, 
                bool fullScreen, const NameValuePairList *miscParams = 0) override;
...

mStateCacheManager 缓存 GL 状态避免冗余切换,mTextureTypes 固定数组因此受 OGRE_MAX_TEXTURE_LAYERS 约束——这与能力检测里 std::min(OGRE_MAX_TEXTURE_LAYERS, units) 的截断互为因果。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面复现 GLES2 后端的能力检测:模拟 GL 上下文(版本串、扩展集合、stencil 位、纹理单元数),实现 hasMinGLVersion/checkExtension 与 createRenderSystemCapabilities 的判定分支。它与 src/ogre-ext-08-1-gles2-backend.cpp 逐字节一致:

// file: src/ogre-ext-08-1-gles2-backend.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/ogre-ext-08-1-gles2-backend.cpp -o bin/ogre-ext-08-1-gles2-backend && ./bin/ogre-ext-08-1-gles2-backend
//
// 复现 GLES2RenderSystem 的能力检测
// (对应 OgreGLES2RenderSystem.cpp 231-341、OgreGLES2RenderSystem.h 63-124):
//   createRenderSystemCapabilities 从 GL 上下文取 renderer/vendor/纹理单元数,
//   按 stencil bits、GL 版本、扩展名组合点亮 RSC_* 能力位;
//   hasMinGLVersion 解析 "OpenGL ES 3.2" 版本串;
//   checkExtension 精确匹配扩展集合;纹理压缩按 PVRTC/DXT/ETC1 细分。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <algorithm>
#include <cctype>
#include <cstdint>
#include <string>
#include <vector>

namespace ogre_repro {

constexpr int kMaxTextureLayers = 32;  // 对应 OGRE_MAX_TEXTURE_LAYERS

// RenderSystemCapabilities 能力位(OgreRenderSystemCapabilities.h 的 RSC_* 简化)
enum Capability {
  RSC_HWSTENCIL,
  RSC_TWO_SIDED_STENCIL,
  RSC_HW_GAMMA,
  RSC_32BIT_INDEX,
  RSC_HWOCCLUSION,
  RSC_TEXTURE_COMPRESSION,
  RSC_TEXTURE_COMPRESSION_PVRTC,
  RSC_TEXTURE_COMPRESSION_DXT,
  RSC_TEXTURE_COMPRESSION_ETC1,
  RSC_ANISOTROPY,
  RSC_HWRENDER_TO_TEXTURE,
  RSC_CAP_COUNT
};

// 模拟 GL 上下文(glGetString / glGetIntegerv 的返回值来源)
struct GLContext {
  std::string version;                  // GL_VERSION
  std::string renderer;                 // GL_RENDERER
  std::string vendor;                   // 厂商
  std::vector<std::string> extensions;  // 已支持的扩展
  int maxTextureUnits = 16;             // GL_MAX_TEXTURE_IMAGE_UNITS
  int stencilBits = 0;                  // GL_STENCIL_BITS
  float maxAnisotropy = 16.0f;          // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
};

// RenderSystemCapabilities(OgreRenderSystemCapabilities.h 简化)
class RenderSystemCapabilities {
 public:
  void setCapability(Capability c) { mCaps[c] = true; }
  bool hasCapability(Capability c) const { return mCaps[c]; }
  void setDeviceName(const std::string& n) { mDeviceName = n; }
  void setVendor(const std::string& v) { mVendor = v; }
  void setNumTextureUnits(int n) { mNumTextureUnits = n; }
  void setMaxSupportedAnisotropy(float a) { mMaxAnisotropy = a; }
  const std::string& getDeviceName() const { return mDeviceName; }
  const std::string& getVendor() const { return mVendor; }
  int getNumTextureUnits() const { return mNumTextureUnits; }
  float getMaxSupportedAnisotropy() const { return mMaxAnisotropy; }

 private:
  bool mCaps[RSC_CAP_COUNT] = {};
  std::string mDeviceName;
  std::string mVendor;
  int mNumTextureUnits = 0;
  float mMaxAnisotropy = 1.0f;
};

// hasMinGLVersion(OgreGLES2RenderSystem.cpp 266 起):解析版本串前两个数字
int parseGLMajor(const std::string& v) {
  for (size_t i = 0; i < v.size(); ++i)
    if (std::isdigit(static_cast<unsigned char>(v[i]))) return v[i] - '0';
  return 0;
}
int parseGLMinor(const std::string& v) {
  size_t dot = v.find('.');
  if (dot != std::string::npos && dot + 1 < v.size() &&
      std::isdigit(static_cast<unsigned char>(v[dot + 1])))
    return v[dot + 1] - '0';
  return 0;
}
bool hasMinGLVersion(const GLContext& ctx, int major, int minor) {
  int vmaj = parseGLMajor(ctx.version);
  int vmin = parseGLMinor(ctx.version);
  return (vmaj > major) || (vmaj == major && vmin >= minor);
}

// checkExtension:精确匹配扩展名
bool checkExtension(const GLContext& ctx, const std::string& ext) {
  for (const auto& e : ctx.extensions)
    if (e == ext) return true;
  return false;
}

// createRenderSystemCapabilities(OgreGLES2RenderSystem.cpp 231-341 复现)
RenderSystemCapabilities createRenderSystemCapabilities(const GLContext& ctx) {
  RenderSystemCapabilities rsc;
  rsc.setDeviceName(ctx.renderer);
  rsc.setVendor(ctx.vendor);
  rsc.setNumTextureUnits(std::min(kMaxTextureLayers, ctx.maxTextureUnits));

  if (ctx.stencilBits > 0) {
    rsc.setCapability(RSC_HWSTENCIL);
    rsc.setCapability(RSC_TWO_SIDED_STENCIL);
  }

  if (hasMinGLVersion(ctx, 3, 0) ||
      (checkExtension(ctx, "GL_EXT_sRGB") && checkExtension(ctx, "GL_NV_sRGB_formats")))
    rsc.setCapability(RSC_HW_GAMMA);

  if (hasMinGLVersion(ctx, 3, 0) || checkExtension(ctx, "GL_OES_element_index_uint"))
    rsc.setCapability(RSC_32BIT_INDEX);

  if (hasMinGLVersion(ctx, 3, 0) || checkExtension(ctx, "GL_EXT_occlusion_query_boolean"))
    rsc.setCapability(RSC_HWOCCLUSION);

  if (checkExtension(ctx, "GL_IMG_texture_compression_pvrtc") ||
      checkExtension(ctx, "GL_EXT_texture_compression_dxt1") ||
      checkExtension(ctx, "GL_EXT_texture_compression_s3tc") ||
      checkExtension(ctx, "GL_OES_compressed_ETC1_RGB8_texture") ||
      checkExtension(ctx, "WEBGL_compressed_texture_s3tc") ||
      checkExtension(ctx, "WEBGL_compressed_texture_pvrtc") ||
      checkExtension(ctx, "WEBGL_compressed_texture_etc1")) {
    rsc.setCapability(RSC_TEXTURE_COMPRESSION);

    if (checkExtension(ctx, "GL_IMG_texture_compression_pvrtc") ||
        checkExtension(ctx, "WEBGL_compressed_texture_pvrtc"))
      rsc.setCapability(RSC_TEXTURE_COMPRESSION_PVRTC);

    if (checkExtension(ctx, "GL_EXT_texture_compression_dxt1") &&
        checkExtension(ctx, "GL_EXT_texture_compression_s3tc"))
      rsc.setCapability(RSC_TEXTURE_COMPRESSION_DXT);

    if (checkExtension(ctx, "GL_OES_compressed_ETC1_RGB8_texture") ||
        checkExtension(ctx, "WEBGL_compressed_texture_etc1"))
      rsc.setCapability(RSC_TEXTURE_COMPRESSION_ETC1);
  }

  if (checkExtension(ctx, "GL_EXT_texture_filter_anisotropic")) {
    rsc.setMaxSupportedAnisotropy(ctx.maxAnisotropy);
    rsc.setCapability(RSC_ANISOTROPY);
  }

  rsc.setCapability(RSC_HWRENDER_TO_TEXTURE);
  return rsc;
}

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // GL ES 3.2:现代能力齐全
  GLContext gles32;
  gles32.version = "OpenGL ES 3.2";
  gles32.renderer = "Apple A14 GPU";
  gles32.vendor = "Apple";
  gles32.stencilBits = 8;
  gles32.extensions = {"GL_EXT_texture_filter_anisotropic",
                       "GL_IMG_texture_compression_pvrtc"};
  auto caps = createRenderSystemCapabilities(gles32);
  CHECK(caps.getDeviceName() == "Apple A14 GPU");
  CHECK(caps.getVendor() == "Apple");
  CHECK(caps.getNumTextureUnits() == 16);          // min(32, 16)
  CHECK(caps.hasCapability(RSC_HWSTENCIL));
  CHECK(caps.hasCapability(RSC_TWO_SIDED_STENCIL));
  CHECK(caps.hasCapability(RSC_HW_GAMMA));         // GL >= 3.0
  CHECK(caps.hasCapability(RSC_32BIT_INDEX));
  CHECK(caps.hasCapability(RSC_HWOCCLUSION));
  CHECK(caps.hasCapability(RSC_TEXTURE_COMPRESSION));
  CHECK(caps.hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC));
  CHECK(caps.hasCapability(RSC_ANISOTROPY));
  CHECK(caps.getMaxSupportedAnisotropy() == 16.0f);
  CHECK(caps.hasCapability(RSC_HWRENDER_TO_TEXTURE));  // 始终设置

  // GL ES 2.0 + 无扩展:仅基础能力
  GLContext gles20;
  gles20.version = "OpenGL ES 2.0";
  gles20.renderer = "Skia";
  gles20.vendor = "Software";
  gles20.stencilBits = 0;
  auto caps2 = createRenderSystemCapabilities(gles20);
  CHECK(!caps2.hasCapability(RSC_HWSTENCIL));
  CHECK(!caps2.hasCapability(RSC_HW_GAMMA));
  CHECK(!caps2.hasCapability(RSC_32BIT_INDEX));
  CHECK(!caps2.hasCapability(RSC_HWOCCLUSION));
  CHECK(!caps2.hasCapability(RSC_TEXTURE_COMPRESSION));
  CHECK(caps2.hasCapability(RSC_HWRENDER_TO_TEXTURE));

  // GL ES 2.0 + GL_OES_element_index_uint:仅点亮 32 位索引
  GLContext gles20ext = gles20;
  gles20ext.extensions = {"GL_OES_element_index_uint"};
  auto caps3 = createRenderSystemCapabilities(gles20ext);
  CHECK(caps3.hasCapability(RSC_32BIT_INDEX));
  CHECK(!caps3.hasCapability(RSC_HWOCCLUSION));

  // GL ES 2.0 + DXT 组合:纹理压缩 + DXT 细分
  GLContext dxt = gles20;
  dxt.extensions = {"GL_EXT_texture_compression_dxt1", "GL_EXT_texture_compression_s3tc"};
  auto caps4 = createRenderSystemCapabilities(dxt);
  CHECK(caps4.hasCapability(RSC_TEXTURE_COMPRESSION));
  CHECK(caps4.hasCapability(RSC_TEXTURE_COMPRESSION_DXT));
  CHECK(!caps4.hasCapability(RSC_TEXTURE_COMPRESSION_ETC1));

  // 仅 PVRTC:纹理压缩 + PVRTC,无 DXT
  GLContext pvrtc = gles20;
  pvrtc.extensions = {"GL_IMG_texture_compression_pvrtc"};
  auto caps5 = createRenderSystemCapabilities(pvrtc);
  CHECK(caps5.hasCapability(RSC_TEXTURE_COMPRESSION));
  CHECK(caps5.hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC));
  CHECK(!caps5.hasCapability(RSC_TEXTURE_COMPRESSION_DXT));

  // hasMinGLVersion 解析
  CHECK(parseGLMajor(gles32.version) == 3);
  CHECK(parseGLMinor(gles32.version) == 2);
  CHECK(hasMinGLVersion(gles32, 3, 0));
  CHECK(!hasMinGLVersion(gles20, 3, 0));
  CHECK(hasMinGLVersion(gles20ext, 2, 0));

  // 纹理单元数受 OGRE_MAX_TEXTURE_LAYERS 上限约束
  GLContext many;
  many.version = "OpenGL ES 3.0";
  many.maxTextureUnits = 64;
  auto caps6 = createRenderSystemCapabilities(many);
  CHECK(caps6.getNumTextureUnits() == kMaxTextureLayers);

  return lab::report("08-1 GLES2 后端");
}

本机实测(Apple clang,clang++ -std=c++20 -Wall):编译通过(零警告),断言 33/33 通过。

小结

  • _initialise 启动 GLSupport 并创建纹理管理器;能力检测由 createRenderSystemCapabilities 完成。
  • stencil bits 非零点亮 RSC_HWSTENCIL + RSC_TWO_SIDED_STENCIL;hasMinGLVersion 解析版本串做阈值判断。
  • 纹理压缩先点大类 RSC_TEXTURE_COMPRESSION,再按扩展精确名称细分 PVRTC/DXT/ETC1 等。
  • DXT 需要 dxt1 与 s3tc 两个扩展同时存在;各向异性可选点亮并记录最大值。
  • mTextureTypes 固定数组与能力检测中的 OGRE_MAX_TEXTURE_LAYERS 截断互为因果。

阅读导航:上一节:7.3 示例工程结构 · 下一节:8.2 Vulkan 后端 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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