Cherno游戏引擎笔记（73~90）

------- scene viewport ----------

》》》》做了两件事：设置视口和设置相机比例

》》》》为什么要设置 m_ViewportSize 为 glm::vec2 而不是 ImVec2 ?

因为后面需要进行 != 运算，而 ImVec2 没有这个运算符的定义，只有 glm::vec2 有这个运算符的定义。

所以需要用 ImVec2 接收 GetContentRegionAvail 返回的 ImVec2类型的 panelSize，然后将两者进行比较。

》》》》发现一个问题

其中，无论对 m_Framebuffer 是否调用 Resize，其渲染结果和响应好像都是一样的，并没有什么影响（实际上这应该对图像的分辨率有一定影响，但为何我没有发现什么明确特征？）。

而且不调用Framebuffer->Resize的话，调整窗口大小的时候图像并不会出现闪烁的现象。（所以说闪烁正是因为帧缓冲对纹理附件的刷新而导致的）

》》》》另一个问题

》》》》值得一提的是，相机的纵横比更新函数参数需要为 float 类型的，而不是 uint 类型，否则会导致窗口尺寸过小时无渲染结果。

-----------ImGui Layer Events---------

》》》》发现一个问题：

Hazel中有一次维护是删除 inline 关键字的，我大致看了眼，觉得没有必要，就没有提交到 Nut，只是添加到待办里面了，这导致一个问题。

操作：

在简化了Input.h之后，只剩下了5个函数的声明，而且这些函数在简化前都是内联函数，在.h文件中就已经定义过了。

建议：

所以在删除掉了定义之后，还应该删除inline关键字，我们要确保使用 inline 关键字的时候就对函数在头文件中定义，否则不添加inline关键字，避免出现错误。

如果仅仅删除了定义，但是没有删除inline关键字，就会出现 LNK2019 的报错，比如：

->

"public: static bool __cdecl Nut::Input::IsKeyPressed(int)" (?IsKeyPressed@Input@Nut@@SA_NH@Z)，

函数 "public: void __cdecl Nut::OrthoGraphicCameraController::OnUpdate(class Nut::Timestep)" (?OnUpdate@OrthoGraphicCameraController@Nut@@QEAAXVTimestep@2@@Z) 中引用了该符号。

问题：

OrthoCameraController本应使用函数，可是为什么会查找不到，或者说对这个函数链接失败呢？

原因：

这正是因为我在头文件中只声明了函数为 inline，然后没在头文件中定义这个函数，而是在 CPP 文件中定义它。

此时编译器会在编译时找不到这个函数的定义，因为头文件已经告诉编译器这是一个 inline 函数，并期望在头文件中找到它的实现。

这样会导致链接错误或重复定义错误，这全都由于 CPP 文件中的定义与头文件中的 inline 声明不匹配。

》》》》提醒：

记得不要写成 ImGui::IsWindowFocused;   :)

----Where to go + Code review（前瞻与代码审核）------

》》》》Cherno 所做的

Cherno 在这一集前8分钟修复了一个小Bug，然后就算是开始审核代码了，基本上讲了自己对游戏引擎的理解与期望，还有接下来的进程。

》》》》我将提交一些维护代码，因为这一集也没什么要做的。

》》》》调整ImGui窗口大小时闪烁的原因是：我们在绘制ImGui窗口时同步更新了FrameBuffer和Camera
 

我们应该先更新，后绘制。

问题出现原理以及解决方法：

在 OnImGuiRender 函数中处理窗口大小变化时，你会在每一帧的渲染过程中检查窗口尺寸并同时处理窗口尺寸。因为在窗口调整时你重新创建了帧缓冲（Framebuffer），那么在调整过程中的某些渲染操作可能会使用未完全准备好的新帧缓冲，这就会导致显示的内容不稳定，从而产生闪烁。

将窗口大小的调整逻辑提前放在 Onupdate 函数中，可以确保在每一帧的渲染之前已经完成了所有的帧缓冲调整。这意味着当 ImGuiRender 执行时，帧缓冲已经是正确的状态，减少了因帧缓冲调整导致的闪烁现象。

未准备好的帧缓冲概念：

1. 帧缓冲（Framebuffer）重建过程:

当窗口大小变化时，通常需要重新创建或调整帧缓冲的尺寸，以适应新的窗口尺寸。这个过程包括删除旧的帧缓冲对象并创建新的对象，同时可能需要重新分配或调整与之关联的纹理和深度缓冲区。

1. 未准备好的帧缓冲:

在帧缓冲重新创建或调整的过程中，新的帧缓冲可能尚未完全配置和初始化。例如，新的纹理可能尚未正确分配或绑定，或者深度缓冲区的设置尚未完成。在这个过渡期间，帧缓冲可能处于一个不稳定的状态，无法正确显示内容。

》》》另外，还要注意一个问题：

第一种逻辑更新方式是不可取的，因为 ImGui::GetContentRefionAvail() 获取的是当前ImGui窗口的面板大小，需要在 ImGui 窗口绘制范围内进行使用，否则获取的Window值为nullptr， 即没有找到可获取的ImGui窗口。

第二种方式可取，因为每一次m_Viewport在ImGui窗口事件触发时更新后，每当下一次绘制开始执行OnUpdate函数，m_ViewportSize已经是新窗口尺寸，而specification中存储的是旧窗口尺寸。

这时触发Resize函数，随后帧缓冲m_Framebuffer更新，相应的帧缓冲m_Framebuffer中存储的specification也会更新为新窗口尺寸。

下一次窗口大小改变时，也是类似的操作。

逻辑：

需要注意的是，这里的m_Viewport值是在Onupdate函数执行后更新的，也就是说，图像的更新逻辑为：当前绘制时先判断逻辑，然后执行绘制。检测窗口尺寸变化的代码确实在绘制函数OnImGuiRender中，不过没有直接绘制被更新的帧，而是将新窗口尺寸保留在全局变量m_ViewportSize中，在下一次绘制开启前先在Onupdate更新窗体逻辑，然后在绘制函数中更新实际窗口尺寸。（简而言之，就是：当前帧检测到变化，但不更新，在下一帧开始时，发送变化值并执行更新）

------------ECS(实体系统）---------

》》》》76,77主要讲了EnTT的设计理念，使用方法以及使用案例，不是很难，我尽可能的做一些笔记以理解，同时上传77集的示例。

》》》》ECS 的概念：

实体组件系统（ECS）是一种设计模式，常用于游戏开发和其他需要高性能和灵活性的应用程序中。它将对象分解为“实体”、“组件”和“系统”三个主要部分。

实体是唯一的标识符，组件是数据容器，而系统是处理组件数据的逻辑模块。

》》实体，组件，系统之间的关系：

1.实体 (Entity)

定义：实体是系统中唯一的标识符，通常是一个简单的ID（比如unsigned int）。它本身不包含任何数据或逻辑。

作用：实体作为其他数据（即组件）和逻辑（即系统）的载体，用来标识和操作这些数据或逻辑。

2. 组件 (Component)

定义：组件是包含数据的结构体或类，但不包含逻辑。每种组件代表一种特定的数据类型，例如位置、速度、健康值等。

作用：组件用于存储实体的状态信息。每个实体可以拥有一个或多个组件，从而描述它的各种属性。

3. 系统 (System)

定义：系统包含处理特定类型组件数据的逻辑。系统会遍历所有具有所需组件的实体，执行相应的操作。

作用：系统负责更新和处理组件数据，实现游戏逻辑或其他功能。每个系统通常专注于一个特定的任务，如物理模拟、渲染或AI决策等。

》》关系和使用方式

关系：

实体与组件：

实体是组件的容器，通过附加不同类型的组件来描述实体的属性和行为。实体本身没有实际的数据，只是一个标识符。

组件与系统：

系统会查询所有拥有特定组件集合的实体，并对这些实体的组件数据进行处理。例如，物理系统可能会查找所有拥有位置和速度组件的实体，并更新它们的位置数据。

使用方式：

创建实体：实例化一个新的实体并为其分配唯一标识符。

添加组件：为实体附加一个或多个组件。每个组件存储实体的特定数据。

定义系统：实现系统逻辑，这些系统会在每一帧或特定的事件触发时运行。

更新：在每一帧或游戏循环中，系统会遍历实体并更新组件数据，实现游戏逻辑。

示例

假设你在开发一个简单的游戏，其中有角色实体（Player）和敌人实体（Enemy）。

实体：

playerEntity 和 enemyEntity。

组件：

PositionComponent：存储实体的位置数据（x, y）。

VelocityComponent：存储实体的速度数据（vx, vy）。

HealthComponent：存储实体的健康值。

系统：

MovementSystem：遍历所有具有 PositionComponent 和 VelocityComponent 的实体，并根据速度更新位置。

HealthSystem：遍历所有具有 HealthComponent 的实体，处理伤害、恢复等健康相关的逻辑。

》》ECS可以看做是一种数据结构吗，有什么优点？

与其看做是数据结构，不如称之为是一种设计模式。

优点：

性能：ECS通过将数据（组件）分开存储，提高了缓存效率、减少内存碎片，从而提高性能。

灵活性：ECS使得添加、删除和修改组件变得容易，而且系统将数据和行为分离的方式也使得数据和逻辑的耦合度降低，这有助于维护和扩展系统。使系统更加灵活和可扩展。

》》》》下载头文件 ：（https://github.com/skypjack/entt/tree/master/single_include/entt ）

这个库只需要加载头文件，因为entt是一个模板库，不需要链接。

》》》》entt::registry 的原理与机制

概念：

entt 的 entt::registry 是一个高度优化的数据结构，用于高效地管理实体及其组件。

结构：

• 存放实体的结构

实体ID：每个实体都有一个唯一的ID，这个ID用于标识实体，可以在内部数据结构中索引和检索。

实体状态管理：entt::registry 维护一个实体池（entity pool）来跟踪实体的创建和销毁。通常是通过位图或其他类似的数据结构来管理实体。

• 管理组件的结构

组件存储：entt::registry 为每种组件类型维护一个独立的存储结构，通常是一个类似于数组或向量的容器。每个组件的存储容器按所属于的 实体ID进行索引，从而实现快速访问。

组件映射：为了支持快速的组件查询和操作，entt::registry 使用组件映射（component map）来跟踪哪些实体拥有特定的组件。

这种映射通常基于组件的签名（signature）来实现，签名是实体拥有的组件的集合。

组件更新：entt::registry 允许高效的组件添加、删除和更新。组件的存储和管理通常采取增量更新的方式，以提高性能。

存储结构图示：

假设我们有两个实体（ID=1 和 ID=2），以及两个组件（位置和速度）。

实体管理：entt::registry 维护一个实体池，跟踪所有有效的实体ID（比如，1 和 2）。

+-------------------+
|    实体池         |
+-------------------+
|  位图               |
|  [1] [2] [ ] [ ]    |      // 实体ID 1 和 2 是有效的
+-------------------+

位置组件：用一个数组或向量存储位置数据，比如 { {100, 200}, {300, 400} }，其中 {100, 200} 是玩家的位置，{300, 400} 是敌人的位置。

速度组件：用另一个数组或向量存储速度数据，比如 { {10, 0}, {5, -2} }，其中 {10, 0} 是玩家的速度，{5, -2} 是敌人的速度。

+-------------------+
| 位置组件存储|
+-------------------+
|  {100, 200}       |     // 实体ID=1 的位置
|  {300, 400}       |     // 实体ID=2 的位置
+-------------------+

+-------------------+
|速度组件存储 |
+-------------------+
|  {10, 0}            |     // 实体ID=1 的速度
|  {5, -2}             |     // 实体ID=2 的速度
+-------------------+

位置映射：entt::registry 使用一个哈希表将实体ID映射到位置数据。例如，ID=1 映射到 {100, 200}，ID=2 映射到 {300, 400}。

速度映射：类似地，ID=1 映射到 {10, 0}，ID=2 映射到 {5, -2}。

+-----------------------------+
| 组件映射（哈希表）   |
+-----------------------------+
|  位置：                        |
|  ID=1 -> {100, 200}     |
|  ID=2 -> {300, 400}     |
|                                     |
|  速度：                        |
|  ID=1 -> {10, 0}           |
|  ID=2 -> {5, -2}            |
+-----------------------------+

》》entt::registry的查询与更新：

#include <entt/entt.hpp>

#include <iostream>

 

// 定义组件

struct Position {

    float x, y;

};

 

struct Velocity {

    float vx, vy;

};

 

int main() {

    // 创建一个注册表

    entt::registry registry;

 

    // 使用 registry 创建实体并返回句柄

    auto entity = registry.create();

 

    // 为实体添加组件

    registry.emplace<Position>(entity, 10.0f, 20.0f);

    registry.emplace<Velocity>(entity, 1.0f, 2.0f);

 

    // 查询组件

    if (auto* pos = registry.try_get<Position>(entity)) {

        std::cout << "Position: (" << pos->x << ", " << pos->y << ")\n";

    } else {

        std::cout << "Entity has no Position component.\n";

    }

 

    if (auto* vel = registry.try_get<Velocity>(entity)) {

        std::cout << "Velocity: (" << vel->vx << ", " << vel->vy << ")\n";

    } else {

        std::cout << "Entity has no Velocity component.\n";

    }

 

    // 更新组件

    if (auto* pos = registry.try_get<Position>(entity)) {

        pos->x += 5.0f;  // 增加 x 坐标

        pos->y -= 3.0f;  // 减少 y 坐标

    }

 

    if (auto* vel = registry.try_get<Velocity>(entity)) {

        vel->vx *= 2.0f; // 增加 x 速度

        vel->vy *= 0.5f; // 减少 y 速度

    }

 

    return 0;

}

 

 

》》》》新版 Entt 的 entt::registry 好像没有 has 这个成员函数.

 

 

 

》》》》结构化绑定:

auto group = m_Registry.group<TransformComponent, MeshComponent>();

for (auto entity : group)

{

    auto& [transform, mesh] = group.get<TransformComponent, MeshComponent>(entity);

}

这就是就是所谓的结构化绑定, 可以查看 Cherno C++ 系列的视频。

 

BiliBili  【75】【Cherno C++】【中字】C++的结构化绑定_哔哩哔哩_bilibili

Youtube：STRUCTURED BINDINGS in C++

Structured binding: 结构化绑定

        auto 表示变量的类型将由编译器自动推导。

        [var1, var2, ...] 是结构化绑定的变量列表，用于接收解构后的值。

        expression 是一个可以解构的对象，通常是一个 std::tuple、std::pair 或自定义类型。

》》》》On_Construct 函数的意义：

on_construct 是用于注册回调函数，当某个组件类型的组件被添加到实体时，会触发这些回调。它允许你在组件创建时执行特定的操作。

connect<&OnTransformConstruct>(): 将 OnTransformConstruct 函数连接到这个信号。每当 TransformComponent 被添加到实体时，OnTransformConstruct 就会被调用。

----Entities And Components-----------

@Cherno

》》》》感觉没啥要记的

auto group = m_Registry.group<TransformComponent>(entt::get<SpriteComponent>);

m_Registry.group<TransformComponent>：定义了一个组，其中的实体必须具有TransformComponent组件。

entt::get<SpriteComponent>：这是一个额外的条件，表示要包括SpriteComponent组件。

这样，group中的实体不仅必须有TransformComponent，还必须有SpriteComponent。

---------------Entity class-------------

》》》》强指针与弱指针的区别

内存管理:

例如：

在观察者模式的设计中，弱指针可以在观察对象时不干预对象生命周期。也就是说 std::weak_ptr 可以通过避免持有对象的强引用来实现有效的内存管理。

》》》》registry.has( ) 函数被重命名了 现在叫 all_of

You can find it with : https://github.com/skypjack/entt/issues/690

》》》》关于 operator bool() const

这是一个类型转换运算符（type conversion operator）, 其作用是允许类 Entity 对象在需要布尔值的上下文中（如条件语句）被隐式地转换为 bool 类型。

例如：

operator bool() const { return m_EntityHandle != 0; }

 

在这里，m_EntityHandle 是一个表示实体的句柄（handle）。

如果 m_EntityHandle 为 0 (null 或 空)，则m_EntityHandle != 0 返回 false ，可以认为 Entity 对象无效（可能表示它已经被销毁或未初始化）。

否则，若 m_EntityHandle 不为空， 则m_EntityHandle != 0 结果为 true, 可以认为它是有效的。

----------------Camera system------------

》》》》Cherno的意思好像是：在游戏编辑时，使用一种摄像机。但在游戏运行时，使用另外一种摄像机。当然这两种摄像机有别。

我的理解是，游戏在编辑的时候，需要编辑者全面/自由的观察游戏设计样貌，所以摄像机相对复杂一点，因为它要有能力在局部空间/世界空间中位移。

而游戏运行时，大部分时间需要以一个固定的视角游玩，所以摄像机不用太复杂。

》》》》primary 的作用

Primary 用于确定当前摄像机是否为主摄像机。也就是说当你使用此摄像机的时候，这个摄像机会被标记为主摄像机（当下正在使用的摄像机）。

根据这个标识，我们可以正确的对当下所观察的事物进行处理。

》》》》Group 和 View 的区别：

参考：（ http://t.csdnimg.cn/TZiz5 ）

不同之处：

1. 基本概念

view：

概念：用于访问具有特定组件的实体。你可以创建一个视图来遍历所有包含某种或多种组件的实体。

特点：视图是相对轻量级的，并且对组件的访问是直接的。

  视图通常是以某种组件的组合为基础进行过滤的。

group：

概念：是一个更复杂的数据结构，允许你对实体进行更多的分类和管理。

特点：group 不仅可以过滤组件，还可以根据实体的组件组合创建逻辑组。

  group 可以指定需要的组件和额外的条件，以便管理和操作那些具有特定组件组合的实体。

2. 用法和功能

view：

用法：用于遍历符合组件条件的实体。

特点：访问速度较快，因为它不涉及复杂的分组逻辑，只是简单地提供对符合条件的实体的访问。

例子：
auto view = m_Registry.view<TransformComponent>();
for (auto entity : view) {
    auto& transform = view.get<TransformComponent>(entity);
    // 对实体进行操作
}

group：

用法：用于将实体分组到一个更复杂的集合中，考虑了多个组件及其组合。

特点：group提供了更高层次的管理功能，可以在创建时定义更复杂的过滤条件和数据访问逻辑。

例子：

auto group = m_Registry.group<TransformComponent>(entt::get<SpriteComponent>);
for (auto entity : group) {
    auto& transform = group.get<TransformComponent>(entity);
    auto& sprite = group.get<SpriteComponent>(entity);
    // 对实体进行操作
}

 

3. 性能和优化

view：

view主要依赖于组件的数据结构和缓存，通常较为高效，适合用于简单的组件过滤和遍历操作。

group：

由于其包含了更多的逻辑和条件，它可能在创建时需要额外的计算和管理开销。

但在需要处理更复杂的组件组合和分类时，group可以提供更好的性能优化。

总结：

使用view时，你是在基于组件的简单过滤进行操作，适合轻量级的遍历和访问。

使用group时，你可以进行更复杂的组件组合和条件过滤，更适合需要进行复杂数据管理和分类的场景。

这取决于你的具体需求和性能要求。

》》》》为什么这一集之后，键盘上的 wasd 对摄像机控制失效了。

因为之前绘制的时候，通过 BeginScene( OrthographicCamera camera ) 传入的是一个 OrthographicCamera，而且我们在更新的时候 CameraController 操控的也是 OrthographicCamera （每一次响应wasd，都在通过 UpdateMatrix( ) 更新 OrthographicCamera）。

但是在此次绘制的实体中，通过 BeginScene( Camera camera ) 我们传入的都是新类型 Camera，并且在 CameraController 的更新函数中没有对 Camera 类型摄像机进行更新的函数，这就导致在仅绘制 Camera 类型摄像机时，WASD 不起作用。

》》》》为什么Cherno在代码中总是获取位移矩阵的第四列（Transform[3]），以此对物体进行操纵呢？

因为OpenGL中的位移矩阵是列主序的，所以位移向量存储在矩阵的第4列（代码中表示为 0,1,2,3 这 4 个标号中的第 4 个：也就是 3）

参考：（ 变换 - LearnOpenGL CN (learnopengl-cn.github.io) ）

》》》》一个提示：

Camera 中的投影矩阵被用为 BeginScene 的一个参数，所以要确保运行之前已经为 CameraComponent 的成员 Camera 添加了数据。

》》》》一个理解：

这一集需要我们重载 Renderer2D::BeginScene()

Cherno 是这样做的：

我是这样做的

其实差不多，我在填入参数时就将 transform 位移矩阵转换成了 view 观察矩阵.

》》接下来看看重载 BeginScene() 这个函数目的：

• 在先前的 Renderer2D::BeginScene() 中，我们传入的是 OrthographicCamera:

这么做的用意是，可以直接通过 OrthographicCamera 对象的成员函数获取视图投影矩阵 ViewProjectionMatrix，然后将其上传为统一变量，以便计算与呈现渲染结果。

• 但是在游戏运行时，我们只想进行简单的计算，并使用简单的 Camera类型（仅仅包含投影矩阵： ProjectionMatrix），这时候想要绘制一个图形，在使用 Renderer2D::BeginScene() 时，就需要进行重载，将 Camera 类型对象作为参数的一员。

所以我们还需要传入一个位移矩阵 transform 在 Renderer2D::BeginScene() 临时的计算一下视图投影矩阵 ViewProjectionMatrix，然后将其上传为统一变量。

• 值得一提的是，这个视图矩阵 viewMatrix 就是由位移矩阵 transform 进行转置运算得来的，这一点在之前的 OrthographicCamera.cpp 中也可见端倪：

》》》》纠正两个Cherno的错误：

1.视图的命名是不是使用错了？

2.BeginScene() 的参数是不是填错了？

》》》》又发现一个问题：绘制的图像在位移之后，其初始位置的图像却一直在绘制，没有清除。

后来我发现原因出在这里：（注释掉之后运行情况正常）

由于我为这两个摄像机实体都添加了 sprite 组件，所以在绘制图形的时候，额外绘制了当前摄像机比例下的两个图形。但不可否认的是，新添加的两个图像由于 CPU 运行顺序，导致两个新图在绘制时都是覆盖在旧图之上的。

如果解除1的注释，但不解除2的注释，效果是这样的。（初始位置多绘制一个图像）

如果解除2的注释，但不解除1的注释，效果是这样的。（总有一个紫色的新图像覆盖在旧的蓝图像之上）

为何会是这两句代码导致错误呢，其中的逻辑是什么？

想不出来，我现在想睡觉。

----Scene Camera (fixed aspect ratio)------

》》》》在C++中，整数除法和浮点数除法有什么区别吗

整数除法：操作数都是整数（int, long, short等），结果也是整数。

浮点数除法：操作数至少有一个是浮点数（float, double, long double），结果是浮点数。

》》》》什么类 可以访问 其他类中 protected 类型的成员变量？

• 派生类可以访问基类（父类）中的 protected 成员。

< 派生类（子类）不能直接访问基类（父类）的 private 成员 >

• 友元类和友元函数可以访问类的 protected 成员。
• 类内部的成员函数可以访问该类的 protected 成员。

》》》》关于子类与父类构造函数的关系。

前提：子类在没有显示地调用父类的构造函数时，编译器依旧会尝试隐式调用父类的默认构造函数。如果父类没有定义默认构造函数，那么编译器就会产生错误。

原因：

• 子类与父类构造函数的结构：

子类的构造函数会首先调用父类的构造函数，以确保父类部分被正确初始化。子类构造函数可以通过初始化列表显式指定调用哪个父类构造函数。

• 初始化顺序：父类的构造函数先于子类的构造函数执行

即使子类的构造函数中没有显式调用父类构造函数，父类的构造函数也会被自动调用。

所以如果父类没有默认构造函数，子类构造函数就必须提供一个有效的父类构造函数调用。

》》》》Button & Bottom：button是按钮，bottom是底部。

》》》》为什么在正交矩阵的计算中，对于 bottom 和 top 这两个参数不用乘以纵横比 AspectRatio?

因为 m_OrthographicSize 已经算是定义了视口的高度。所以在确定的高度之下，只需要对宽度（从 Left 到 Right）进行比例换算即可得到正确的视觉效果。

如果只对高度（从 Bottom 到 Top ）乘以纵横比 AspectRatio，但不对宽度进行计算，结果应该是相似的，只不过会变扁一点。

》》》》一个提醒

错误缘由：

这个错误是由于你尝试用不兼容的方式初始化 Nut::CameraComponent 对象。

在 Entt 库的代码中，它期望某种特定的初始化方式初始化对象，但你的代码使用了不匹配的方式。

排除错误：

这里就需要检查 Nut::CameraComponent 的构造函数或 Entt 库的文档。

纠正错误：

由于更换了 CameraComponent 中的成员 Camera ( Nut::Camera -> SceneCamera )，我们需要删除 AddComponent 的参数  glm::ortho(…)

（    

• 因为子类 SceneCamera 的所有构造都不需要填入参数， 而且父类的默认构造函数也不需要填入参数，

所以在此处为 CameraCompoonent 的成员 SceneCamera Camera 初始化的时候不需要填入数据。

• 而且在默认情况下，我们还为父类的成员：投影矩阵 ProjectionMatrix 添加了一个默认值 glm::mat4(1.0f）,以防没有填入参数对其带来未定义的错误。

随后我们在 Camera 的子类 SceneCamera 中更新了投影矩阵，投影矩阵主要在 SceneCamera 中定义。（ 投影矩阵由 glm::ortho( ) 中填入的参数决定并定义。）

 ）。

》》》》另一个提示：

由于我们去除了为摄像机组件 CameraComponent 填入的正交矩阵 glm::ortho(…), 所以现在两个摄像机实体 m_CameraEntity 和 m_SecondCamera 在空间中看起来是一样的（大小、比例…）。

（ “GameEngine6”页上的一个图片【 来自：》》》》一个提醒 】 ）

这是因为我们的投影矩阵在之前由摄像机组件 CameraComponent 填入的正交矩阵 glm::ortho(…)决定（本来填入的 glm::ortho(…) 直接为组件中的成员 Nut::Camera Camera 进行初始化，现在组件中的成员改为了 Nut::SceneCamera Camera，后者不需要填入矩阵参数），而现在由父类 SceneCamera 中的函数 UpdateProjection( ) 决定。

（ “GameEngine6”页上的图片 【 来自：》》》》一个提醒 】 ） 

一开始，组件成员为 Nut::Camera Camera 时，填入的正交矩阵 glm::ortho 直接被父类 Camera 的投影矩阵 m_ProjectionMatrix 所用；现在组件成员改为 Nut::SceneCamera Camera 之后，不用填入正交矩阵 glm::ortho，但是这样也散失了灵活性，因为现在子类 SceneCamera 中从父类 Camera 继承的 m_ProjectionMatrix 被固定的数据计算出来，而且上传为统一变量。

 

在 UpdateProjection( ) 函数中，所有的数据由私有成员计算得来，这些成员在类对象初始化时就已经定义了，而且每一个对象的默认值都一样：

父类 Camera 或子类 SceneCamera 所计算并更新的投影矩阵 m_ProjectionMatrix 在这里被获取并上传至统一变量。

                                  ↓

----Native Scripting （本机脚本）-----

》》》》十分抱歉因为前两天出去玩，后面又有事情耽搁，一直没更新。现在我试着恢复到工作状态中来。

》》》》什么是脚本？

概念：

在编程中，脚本（Script）通常指的是一种用于自动化任务的程序代码。

脚本语言通常是解释性语言，意味着它们不需要编译成机器代码，可以直接由解释器逐行执行。

常用于：

自动化任务，系统管理，网页开发，数据分析，测试等目的。

常见脚本语言：

常见的脚本语言包括Python、JavaScript、Bash、Perl和Ruby。

》》》》本机脚本和普通的脚本有什么不同？

使用场景

总结

普通脚本提供了更高层次的抽象和易用性，而本机脚本则提供了更低层次的控制和优化能力。

》》》》函数指针：

Check it with:

BiliBili：  【58】【Cherno C++】【中字】C++的函数指针_哔哩哔哩_bilibili

YouTube： Function Pointers in C++

》》》》std::function

概念：

std::function 是 C++ 标准库中的一个可调用对象封装器，定义在 <functional> 头文件中。

它可以存储和调用任意类型的可调用对象，包括函数指针、Lambda 表达式、函数对象（即重载了 operator() 的类），甚至是绑定了参数的函数。

使用：

》》》》Lambda 表达式

Lambda 表达式在 C++ 中是定义匿名函数的简洁方式。

Lambda 表达式的组成部分

捕获列表 [capture] 决定了 Lambda 表达式如何捕获外部变量。你可以通过不同的方式来捕获这些变量：

You Can Check it with:

BiliBili：  【59】【Cherno C++】【中字】C++的lambda_哔哩哔哩_bilibili

YouTube： Lambdas in C++

》》》》关于代码的一些理解

》》Instance 的作用？

因为我们计划通过脚本组件中的OnCreateFunction、OnDestroyFunction、OnUpdateFunction 来获取脚本类中自定义的 3 个函数。所以为了OnCreateFunction、OnDestroyFunction、OnUpdateFunction 能够获取到指定脚本类中的函数，我们需要在调用函数时获取到合适的脚本类对象，然后在OnCreateFunction、OnDestroyFunction、OnUpdateFunction 中调用该对象的成员函数。

》》为什么不能将脚本类中的函数 Create、Update、destroy 直接作为脚本组件的成员呢，而非要使用三个函数调用脚本类中的这三个函数？

个人理解：
1. 首先，如果是在脚本组件中定义了三个成员函数，分别用于传入脚本类成员函数，这样在初始化的时候调用起来就很麻烦，想象一下一个组件就要多调用好几次用于传入的函数。

2.既然我们创建了一个脚本类，就可以直接通过类名来传递类中的成员函数（这个类中只有公用的成员函数，是一个工具类）。不过我们在 Bind 函数中一次性调用脚本类的成员函数，只调用一次Bind 便可以自动处理脚本类中的所有函数。

》》为什么 Instance 需要是指针类型？

首先，我们需要接受一个脚本类句柄（也就是一个脚本类对象）来设置脚本组件中的函数，所以我们需要一个 ScriptableEntity 对象。可是这个对象 Instance 为什么需要是指针类型呢？

1.因为我们初始化的时候将其指定为 nullptr（空指针）， Instance 不是指针类型的话这样的定义就是错误的。

2.我们使用 new、delete 进行生命周期的管理，这要求 Instance 是指针变量。

》》向下转换的概念及用例

向下转换：指的是将父类的指针或引用转换为子类的指针或引用。

这样做可以方便的操作子类的成员函数。比如此处，T 是 ScriptableEntity 的子类，当 ScriptableEntity* 类型的变量 instance 被传入的时候，instance->只能调用 ScriptableEntity 的成员函数 GetComponent( ) ，如果将 ScriptableEntity* 类型的变量 instance 向下转换为子类 T* 类型的变量，instance-> 就能调用 T 类的成员函数 OnCreate( )。

》》注意：

((T*)instance）和 (T*)instance 是有区别的：

1. ((T*)instance)->OnCreate() ： 将 instance 强制转换为 T* 类型，然后通过 -> 运算符调用 T 类型的 OnCreate() 成员函数。

2. (T*)instance->OnCreate()：受运算符优先级影响，这行代码首先对 instance 使用 -> 运算符，然后将结果转换为 T* 类型，这并不能调用到 T 类型的成员函数。

》》为什么有的函数需要 [&] 捕获外部变量，有的函数则是 [ ] 不捕获外部变量？

对于 Instantiate 和 DestroyInstance ，他们需要访问 Lambda 表达式作用域之外的 Instance 成员变量，所以使用 [&] 捕获 Lambda 外部变量（通常是 this 指针），并将其作为引用。

对于 OnCreate … ，这三个函数只需要使用传递给他们的参数，没有访问或修改外部变量，因此捕获列表可以为空。

》》》》enTT 中的 view 有一个成员函数 each，这个函数是什么，有什么用，怎么使用？

概述：在 enTT 中， view 用于返回具有特定组件的所有 实体，而 each 函数可以为 view 获取的所有实体执行用户指定的操作。这个操作通常是通过回调函数（比如 lambda 表达式）来实现的。

功能：

each 函数会遍历视图中的所有实体和它们的组件，并对每个实体及其组件执行指定的操作。这个操作是通过传入的回调函数实现的。

参数：

each 函数接受一个回调函数作为参数。回调函数通常是一个 lambda 表达式，表达式中指定两个参数：实体 ID 和对应的组件引用。

ADDED NEW: ( I haven't try that yet) 2024-9-10 21:43

》》》》位移矩阵的[3][0], [3][1], [3][2] 是 x,y,z

---------Native Scripting ( with virtual function) -------

》》》》What is the V-Table?

概念：

在 C++ 中，虚函数表（V-table）是支持多态性的一个机制。当类中包含虚函数时，编译器会为该类生成一个虚函数表。

结构：

虚函数表是一个指针数组，每个元素指向某个类中虚函数的具体实现。

工作原理：

示例：

如果两个不同的子类都继承了相同的父类，并对父类中的虚函数进行了不同的定义，这时虚函数表就为不同子类的变量调用相应的虚函数，以防程序运行错误。

》》》》代码理解：为什么移动主相机的时候，幕后的相机也做了相同的位移？（请查看注释以便理解）

为了实现每个实体使用一样的脚本规范，但各自移动的效果，我选择这样的方式：从回调函数中顺便获取 CameraComponent ，然后通过 primary 作为限制条件进行更新。

》》》》这一次提交中

 1.    我将脚本类的定义放在其他文件中，然后在EditorLayer.cpp中包含其头文件，这样更加整齐。

 2.1  这个脚本类（子类/派生类）的定义我就放在ScriptableEntity（父类/基类）的代码下面，这样更加简洁。

 2.2  我将脚本类的声明和定义设置在两个文件中，分离开来。

 3.    我现在将脚本组件的更新操作放在Scene.cpp新建的OnScript函数中，而不是放在Scene.cpp的OnUpdate函数中，这样便于理解。

》》我在描述(description）中这样总结：

> Scene.cpp&Scene.h: Separate NativeScript's update from Scene::OnUpdate( ), now it was in new function--->Scene::OnScript( ).

> Scene.cpp: Update functions calling ways.  

                      I also added a condition to make every entity moving individually, check it in view.each().

> Component.h: Changed args in std::funciton ,delete std::function which OnCreateFunction/OnDestroyFunction/OnUpdateFucntion used. 

                          And because of this changes, we also need to change Scene::OnScript( ) so that it can running correctly.

> EditorLayer.cpp: Removed the defination of ScriptCameraController and define it in external file ( Now in ScriptableEntity.h & ScriptableEntity.cpp), looks better. 

                             And we use new script update function:OnScript( ).

> ScriptableEntity.h: Declaring ScriptableEntity class and ScriptCameraController class.

> ScriptableEntity.cpp: Defining ScriptableEntity class and ScriptCameraController class.

译文：

> Scene.cpp&Scene.h：将 NativeScript 的更新与 Scene::OnUpdate( ) 分开，现在它位于新函数--->Scene::OnScript( ) 中。

> Scene.cpp：更新函数调用方式。

                      我还添加了一个条件，使每个实体单独移动，在 view.each() 中检查它。

> Component.h：更改了 std::funciton 中的参数，删除了 OnCreateFunction/OnDestroyFunction/OnUpdateFucntion 使用的 std::function。

                            并且由于这些变化，我们还需要更改 Scene::OnScript( ) 以便它能够正确运行。

> EditorLayer.cpp：删除了 ScriptCameraController 的定义并将其定义在外部文件中（现在在 ScriptableEntity.h 和 ScriptableEntity.cpp 中），看起来更好。

                               并且我们使用了新的脚本更新函数：OnScript( )。

>  ScriptableEntity.h：声明 ScriptableEntity 类和 ScriptCameraController 类。

> ScriptableEntity.cpp：定义ScriptableEntity类和ScriptCameraController类。

-------Scene Hierarchy panel-----------

》》》》关于 Trello board：我用其记录了待办的事务，一般是一些维护。
 

接下来的七八集会比较硬核，比较枯燥（虽然没有这么夸张）。大部分时间在处理 ImGui，我会进行细致的学习。

最近很久没有更新，一部分原因是时间安排，一部分原因是我喜欢先看一部分视频然后再去实现代码，也许我会快节奏的上传代码，也许不会，但我尽量理解所有逻辑。

》》》》Scene Hierarchy：场景的层次结构

》》》》enTT basic_registry::each() 现在还能使用吗？

问题：

为了获取当前注册表中所有实体，我对 entt::registry 调用 each() 成员函数，但实现代码的过程中，我发现 entt::registry 已经没有 each() 成员函数，这让我倍感疑惑。

思考与解释：

在仔细查找与考证之后，我猜想是enTT更新了entt.hpp文件，或者将basic_registry::each()放在其他文件中去了。总之entt.hpp中已经找不到basic_registry::each()的定义。

考证：

Cherno 4 年前使用的 entt.hpp 中，我找到：

可是在2024-6-11日更新的entt.hpp中，没有basic_registry作用域下的each()函数，只有basic_view、basic_group等作用域下的each()函数

所以我不得已改变之前的实现方法。

解决方案1：

由于我们在 CreateEntity() 函数中对每一个实体都默认添加了 TagComponent，所以我通过 view() 获取所有包含 TagComponent 的实体（既全部实体），然后通过 each() 函数遍历这些实体。效果与之前相当。

值得一提的是：

m_Context->m_Registry.view<>(); 这样的代码在语法上应该是正确的，但在实际使用中不允许空模板参数，我不是很明白为什么。

解决方案2：(正解）

其实YouTube下的评论还是很有帮助的

》》帖子/文档

查看论坛： （c++ - How can I access all entities in an entt::registry? - Stack Overflow ）为啥昨天就没看到这个帖子呢？

》》》》下载doxygen: https://www.doxygen.nl/

• 先前版本的doxygen文档：

不知道怎么的我翻阅到entt先前的文档，然后查阅了先前的设计。找到了这个阴魂不散的each

不过这好像是entt.hpp之前版本的数据，所以each()的使用方法参考性不大。于是我决定下载一个doxygen看看能不能识别一下现如今最新的entt.hpp.

下载网址： https://www.doxygen.nl/  （可以查看笔记“概念与操作”中的：这里有细致步骤 》》》》doxygen 下载doxygen: https://www.doxygen.nl/ ）

• 最新版本的 enTT 构架：

进入浏览器，按照指示选项卡打开，查看

在所有class中，我们找到basic_registry,并打开。

在这里，你可以查找类型、成员函数等等。

可以看到，最新版本的 entt 中，entt::basic_registry 并没有 each() 函数

》》》》ImGui::TreeNodeEx() 函数

概念：

ImGui::TreeNodeEx 用于在 ImGui 的 UI 中创建一个树节点，这个节点可以显示为展开或折叠状态，并且可以包含子节点。这个函数也具有一些额外的功能，允许你设置节点的样式、图标、标志等。

函数签名

bool ImGui::TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags = 0);
bool ImGui::TreeNodeEx(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* label);

参数说明

函数返回值：

ImGui::TreeNodeEx 的返回值表示该节点是否被展开。具体来说：

常用的 ImGuiTreeNodeFlags 标志

》》为什么 Flags 的定义是 1<<0 的形式 ？为什么设置 Flags 的时候需要将上述 Flag 进行或( '|' )运算？

1<<0 表示 1 这个二进制数字左移 0 个单位，1 << 1 指 1 左移 1 个单位，1 << 2 同理。所有Flag 被定义成二进制（0000, 0001, 0010,0100,1000 … 直到1000 0000 0000 0000)。

这时如果对其中几个 Flag 进行或运算，得到的结果正好可以包含所选取的 Flag 数据。（Eg: 或运算 (OR)： 001 | 101 ----> 101 ）

》》》》Flags 中的三元运算符是为了计算什么结果，为了达到什么效果？

前提：在后续的代码中，我们通过代码得知使用者是否用鼠标单击确定了某一个实体，如果该实体被选中，m_SelectionContext就会被更新为选中的实体。

解释：

在实体未被选中前，entity有值，但m_SelectionContext为空，所以 Flags 中的 ImGuiTreeNodeFlags_Selected 不会相应。如果实体被选中，则三元运算符成立， ImGuiTreeNodeFlags_Selected 相应，效果是高亮指定节点。

》》》》树节点的ID为什么需要这样转换？

• (uint64_t)entity：

将 uint32_t 类型的 entity 转换为 uint64_t 类型。这样做的目的是将 entity 转换为一个较大的整数类型，避免在某些平台上直接将 uint32_t 转为 void* 时可能出现的问题。

（例如，64 位系统上的 void* 大小通常是 64 位，而 32 位系统上的 void* 大小是 32 位。为了确保在所有平台上转换的一致性，将 uint32_t 转换为 uint64_t 可以避免由于直接将 32 位值强制转换为 64 位指针可能出现的数据丢失或对齐问题。）

• (void*)(uint64_t)entity：

将 uint64_t 类型的 entity 转换为 void*。这是因为 ImGui 的 TreeNodeEx 函数要求节点 ID 是 void* 类型的。

》》》》在运算符 != 的设计中，return !(*this == other);是什么意思？为什么？

1. return !(*this == other); 这句代码的意思是什么？

2.为什么在定义中使用 *this 而不是 this？

而我们的运算符重载是作用在 Nut::Entity 上的。

》》》》Where？ Here! （我在哪里用过这个运算符重载来着？）

》》》》为什么在初始化 entity 的时候，填入的参数需要是Ref<Scene>::get() ?

分析：

Entity类在初始化的时候需要填入uint32_t类型的ID 和 Scene*类型的场景指针，但是 m_Context 现在是 Ref<Scene>，这是一个智能指针 std::shared_ptr, 而不是Scene* 这种裸指针。

解决方案：

也就是说Ref<Scene>现在是不可用的指针类型，所以我们需要获取指向 scene 类型对象的原始指针：Scene*，这就需要使用 std::_Ptr_base<Nut::Scene>::get() 函数。

定义：

》》》》一个想法：我觉得没必要让现有的两个摄像机独立移动。

因为在游戏引擎的实际使用中（例如Unity)，你在世界空间（world camera）下对所有物体进行的调整，在其他摄像机视角下都应该是同步的。

Eg.你在世界空间中调整了游戏角色 'Cheryes' 的初始位置，那么在游戏运行时，你使用的运行时摄像机所看到的，也应该是游戏角色 'Cheryes' 被调整后的位置。

》》》》注意：需要确保在绘制 TreeNode 之后调用 ImGui::IsItemClicked()，否则导致绘制错误（当鼠标单击一个节点时，该节点之下的节点也会高亮响应）

WRONG

RIGHT

AND… ImGui::IsItemClicked() 是个函数

绘制错误原因：

当你调用 ImGui::IsItemClicked() 时，它检查的是当前帧中是否有用户点击事件发生在上一个绘制的项上。

如果你在绘制 TreeNode 之前调用 IsItemClicked()，它会检测点击事件，但是此时 TreeNode 还没有实际绘制出来。因此，这个函数可能会错误地报告点击状态，因为它基于之前的状态，而不是你当前正在绘制的节点。

结论（解决方案）：

所以确保在绘制 TreeNode 之后调用 ImGui::IsItemClicked()，这样你可以确保点击状态是基于实际绘制的节点。

----------Properties Panel--------------

》》》》ImGui::InputText( )

函数释义：

ImGui::InputText 是 ImGui 的一个函数，用于显示一个文本输入框。

函数签名：

ImGui::InputText("Tag", buffer, sizeof(buffer));

函数参数：

"Tag" 是输入框的标签，用于在界面上标识输入框。

buffer 是一个字符数组（或类似的缓冲区），用于临时存储用户在输入框中输入的文本。

sizeof(buffer) 是缓冲区的大小，确保输入文本不会超过这个大小。

函数返回值:

ImGui::InputText 函数会返回一个布尔值（bool）。

如果用户在输入框中更改了内容，返回值为 true；如果用户没有更改内容或者输入框没有被操作，返回值为 false。

所以我们使用条件判断是否被更改，若被更改，则对 tag 进行数据更新。

if ( ImGui::InputText("Tag", buffer, sizeof(buffer) ) )

{

      tag = std::string(buffer);

}

》》》》(void*)typeid(TransformComponent).hash_code() 的作用

• typeid 运算符

• std::type_info

• typeid().hash_code() 的作用

• 关系和使用

》》什么是元数据？

概念：元数据（Metadata）是指关于数据的数据。它提供了关于某一数据集的结构、内容、格式、来源和上下文等信息。元数据通常用来帮助用户理解和管理数据，方便数据的搜索、组织和使用。

》》》》ImGui::IsMouseDown( ) 的定义？

参数的定义：注意查看注释。

》》IsMouseDown 和 IsMouseClicked 的区别

IsMouseDown() 的效果是敲击一次鼠标，便一直执行某事件直至条件改变。

而IsMouseClicked()的效果是敲击一次鼠标，则某事件运行只一次，随后停止等待下一次鼠标的敲击（即事件只发生在函数触发的那一帧）。

》》》》strcpy 和 strcpy_s 的区别

》》》》待改进：

当你在Scene Hierarchy 窗口中单击鼠标左键时，有两种情况：

但是当单击节点所处行时，本应高亮的节点行在更新过程中取消了高亮，即节点所处行中，有部分范围被认为是空白，而不认为该范围属于节点。

》》值得一提：

Clip-Camera 在此时，ImGui::DragFloat 对图像的位移不起作用，因为在 Scene.cpp 中 Scene::OnUpdate() 只对主相机进行渲染，而Clip-Camera是第二相机（Primary 为 false）,所以数据上的更改不会体现出来，看起来像是图像没有移动一样。

-------Camera component UI---------

》》》》一些函数的概念：

》》》》使用提示：（视频中Cherno并没有遇到这种问题，可能是我的疏漏）

两个摄像机只有一个可以被标识为主相机，而我们对当前的主相机进行操作，此时需要注意：使用perspective （透视投影）的摄像机类型时，为了呈现出正确结果（或者说在合适的视角下才能观察到透视中的深度变换），我们需要进行一些操作。

无论你是先对物体进行位移，还是先对摄像机实体进行透视的转换，你都需要在第一次切换摄像机之后拉伸一下屏幕中的视口，然后调整摄像机实体的 z 轴。

导致这个问题的原因是没有刷新视口。(不过依旧要调整一下矩阵的 z 轴才能看到正确结果）

具体原因是这样的，我们知道在 EditorLayer 中，只有在“Viewport”窗口被调整大小的时候，才会调用 OnViewportResize( ) 函数来更新视口中的渲染结果。

但是在我们对投影矩阵进行切换的时候，"viewport" 窗口的大小并没有变化，这导致此时并不会对视口中的渲染结果进行更新。

所以我们需要在 combo box 切换矩阵类型的时候，对视口进行更新，尽管此时没有调整 "viewport" 窗口的大小。

》》为了解决这个问题，我们需要在 Hierarchy Panel 中获取到正确的 "Viewport" 窗口大小，然后根据大小进行视口的更新。

我便在 EditorLayer 中创建了一个单例，然后在 Hierarchy Panel 中通过这个单例使用 EditorLayer 的成员函数。

你可能会问我为什么这么做？

这样做的原因是，我们使用窗口 Viewport 并在其中使用 ImGui::Image() 来渲染帧缓冲中的结果，那么如果要对视口（对渲染结果）进行刷新， 我们就需要获取到 Viewport 窗口的 Size。

如果不在 ImGui::Begin("viewport") 和 ImGui::End() 之间使用获取大小的函数：ImGui::GetContentRegionAvail()， 反而在其他窗口的范围内使用ImGui::GetContentRegionAvail() ,就会导致获取的大小来自其他窗口，这是错误的。

所以我需要从 EditorLayer 中拿到正确的 ViewportSize，然后在 HierarchyPanel 中对当下的场景 m_Context 使用 OnViewportResize() 函数，这样便能在调换矩阵类型的时候，对渲染结果进行更新。

》》》》一些设计上的闲聊：（关于 Combo box 的高亮/焦点显示）

我总觉得 ImGui::SetItemDefaultFocus() 有点多余，因为我认为 ImGui::SetItemDefaultFocus() 和高亮显示一个选项的效果差不多，这恰好和 ImGui::Seletable() 的第二个参数重复。

但是 SetItemDefaultFocus() 实际上是一个用于设置当前项为默认焦点的函数，焦点和高亮是有区别的。（当你打开 Combo Box，不使用鼠标选择选项，而是用键盘上下方向键选择选项，你就会发现不同）

Eg.焦点1

Eg.焦点2

Eg.高亮1

Eg.高亮2

》》设计闲聊（关于单例的 Get() 函数）

》Instance 是一个指针类型的变量，那么在 static EditorLayer& Get(){ return *s_Instance; } 中， '*s_Instance' 和 'EditorLayer&'中的 '*','&' 是什么意思？有什么作用？

• *s_Instance

前提: s_Instance 是一个指向 EditorLayer 类型的指针。

解释: 使用 * 操作符对 s_Instance 进行解引用，意味着我们获取的是指针所指向的对象。如果 s_Instance 是一个有效的指针，那么 *s_Instance 将返回一个 EditorLayer 类型的对象的引用。

• EditorLayer&

EditorLayer& 是一个引用类型，表示函数返回一个引用类型的变量。而且返回引用可以避免复制对象，并且允许调用者直接操作原始对象。

》》》》什么是透视矩阵中的FOV？什么是 Vertical FOV?什么是 Horizontal FOV?

You Can Check The Image With   https://images.app.goo.gl/ZfQ9JsY8txMRdbL78

定义：

在许多3D应用和游戏中，FOV 常用于表示相机的整体视野，但在一些上下文中，尤其是需要精确控制的情况下，会特别指出 Vertical FOV 和 Horizontal FOV。

• Vertical FOV：	专指相机在垂直方向上的视场角，影响场景在上下方向的可视范围。
  Horizontal FOV：	专指相机在水平方向上的视场角，影响场景左右方向的可视范围。

计算：

不过垂直视场角和水平视场角是可以相互转换计算的：比如

常见的垂直视场角值

改变 FOV 的影响

• 更大 FOV：	效果：可以看到更多的场景，适合广角镜头效果。 缺点：可能导致物体在视野边缘变形（视角畸变）。
  更小 FOV：	效果：视野范围变窄，适合强调特定对象或细节。 缺点：提供更逼真的透视效果，但会使场景看起来更拥挤。

--------Drawing component UI----------

》》》》关于图像混合出错的情况（大约在原视频14分钟）

在代码中，RedSquare 是后绘制的实体。这导致 Alpha 值设置的透明度只有 Blue Square 能够使用出来

问题理解：

关于混合的相关知识，可以查看：（ 混合 - LearnOpenGL CN）

--------Transform Component UI------

》》》》这一集的难点大多涉及到 ImGui 函数的使用和 ImGui 函数的设计逻辑，So let's check that out.

》》》》我有一个疑问，为什么这里需要将 Rotation 处理三次？

Glm::rotate() 函数这是因为我们现在需要处理图像绕三个轴旋转的情况，而不是像之前一样只处理绕Z轴旋转的情况了。

之前的：

现在的：

》》》》一些函数：

 

 

》》》》关于 ImGui::DragFloat("##X", &values.x); 中的 ##X

什么是 ImGui 中的 ## ？

1. 控件标识符的意义

在 ImGui 中，每个控件（例如按钮、滑块等）需要一个唯一的标识符。这个标识符能够帮助 ImGui 跟踪每个控件的状态、位置和其他属性。

如果没有唯一标识符，ImGui 将无法正确管理多个控件的状态，尤其是在同一窗口中动态生成多个相似控件时。

举个例子：

如果多个控件使用相同的视觉标签（如 "Button"），ImGui 将只会创建一个控件，而不是多个。这意味着只有最后一个控件的状态会被保留，前面的控件将被覆盖。

通过使用 ##，即使视觉标签相同，只要标识符不同，ImGui 就会将它们视为独立的控件。

2. ## 的原理

将视觉标签与内部标识符分离：

使用 ## 用来分隔控件的显示标签和其标识符。例如，"Button##UniqueID" 中，"Button" 是用户在界面上看到的文本，而 UniqueID 是 ImGui 用来跟踪该控件的内部标识符。

3. 实际示例

ImGui::Button("Button##1");
ImGui::Button("Button##2");

在这个例子中：

第一个按钮的显示文本是 "Button"，但它的唯一标识符是 "Button##1"。

第二个按钮的显示文本也是 "Button"，但它的唯一标识符是 "Button##2"。

4. ## 可以单独使用吗,比如 ##X ? 此时控件上显示什么？

##X 可以单独使用。在这种情况下，控件上不会显示任何文本，因为 ## 前面没有标签。控件的标识符是 X

》》》》关于按钮尺寸 ButtonSize 的设计：

float lineHeight = GImGui->Font->FontSize + GImGui->Style.FramePadding.y * 2.0f;
ImVec2 buttonSize = { lineHeight + 3.0f, lineHeight };

 

代码解析

计算 lineHeight：（行高）

计算 buttonSize：（按钮大小）

buttonSize.x （按钮宽度）设置为 lineHeight + 3.0f，这里的 3.0f 是额外增加的宽度，视觉效果更好，一定的区域大小也方便使用者点击。

buttonSize.y （按钮高度）设置为 lineHeight。

》》》》GImGui 是什么？

GImGui 在 ImGui 中是一个全局变量，类型为一个指向 ImGui 上下文的指针。GImGui 通常用于访问 ImGui 的状态和功能，它允许你在自定义的代码中直接访问 ImGui 的内部数据和功能。

（ In imgui.cpp)

（Part of ImGuiContext in imgui_internal.cpp)

》》》》标准化颜色选择器：

https://rgbcolorpicker.com/  is very good.

》》》》度数转化的设计：

前两步就是把数据进行单位上的转换，然后交给一个临时变量，通过使用 DragFloat 控制临时变量（以度数为单位的角度）实现手动调整数据的交互操作。此时虽然在控件上我们调整的是度数制的角度，但是我们可以获取到弧度制之下角度的数值变化。

第三步是重点：将调整过后的角度（度数制）转换到弧度制上，然后重新传递给位移组件（现在应该称之为变换组件）中的旋转成员变量 Rotation，如此一来我们成功的调整了角度。调整旋转角度之后的图像将会在 OnUpdate() 函数调用之后呈现出渲染结果。

---- Adding/Removing Entity UI & Adding/Removing Component UI-----

》》》》Check-List

》》》》我突然意识到，摄像机和物体的移动逻辑应该是相反的（虽然我不知道这是否需要实现）

（比如按下 A 键，对于物体来说是向右移，但对于摄像机来说是左移。对于同一个物体来说，移动物体和移动摄像机的逻辑应该是相反的）

Eg.

Camera类中:

我们为Camera类型的摄像机mainCamera传入了求逆（inverse）之后的矩阵

OrthographicCamera 中：

OrthographicCamera类中 Update() 函数也进行了求逆操作：使用逆矩阵为正交相机类型的摄像机更新内置的视图矩阵。

》》》》ImGui 函数：

用法示例：

示例1：

// 创建一个按钮

if (ImGui::Button("Right Click Me"))

{

    // 按钮被点击时可能会处理某些操作

}

 

// 按钮检测右键点击，然后开始打开上下文菜单（Context Menu)

if (ImGui::BeginPopupContextItem("MyContextMenu"))

{

    if (ImGui::MenuItem("Option 1"))

    {

        // 处理选项1

    }

    if (ImGui::MenuItem("Option 2"))

    {

        // 处理选项2

    }

    ImGui::EndPopup();

}

示例2：(引出一些疑问：）

// 创建一个按钮

if (ImGui::Button("Add Component"))

    // 按钮检测鼠标点击，然后打开弹出菜单（Popup Menu）

    ImGui::OpenPopup("AddComponent");

// 如果OpenPopup() 允许打开窗口

if (ImGui::BeginPopup("AddComponent"))

{

    if (ImGui::MenuItem("Camera"))

    {

        // 处理选项1

        ImGui::CloseCurrentPopup();

    }

    if (ImGui::MenuItem("Sprite Renderer"))

    {

        // 处理选项2

        ImGui::CloseCurrentPopup();

    }

    ImGui::EndPopup();

}

》》》OpenPopup( )有什么用？和BeginPopup()有什么关系？

》》》BeginPopupContextItem() 和 BeginPopup() 打开菜单的逻辑有什么不同？

为什么 BeginPopupContextItem() 可以直接在目标控件之后调用，而 BeginPopup() 还需要额外使用 OpenPopup() 判断控件是否允许打开菜单？BeginPopupContextItem() 不需要 OpenPopup() 这个函数吗？

触发机制：

• BeginPopup():

需要程序员在代码中定义何时打开弹出菜单，通常结合其他控件的逻辑（例如按钮点击之后，使用 OpenPopup()  允许菜单打开）。

• BeginPopupContextItem():

不需要程序员在代码中定义何时打开弹出菜单，函数会自动处理右键点击事件，适合用在按钮、文本等控件上，但无需按钮添加额外的事件处理逻辑（只要在控件之后使用 BeginPopupContextItem( ) 即可 ）。

总结：

所以说，BeginPopupContextItem() 打开菜单的逻辑是自动的。BeginPopupContextItem() 不需要在前面显式调用 ImGui::OpenPopup("MyPopup")，因为它会自动在用户右键点击时打开对应的弹出菜单。

而 BeginPopup() 打开菜单的逻辑是手动的，BeginPopup() 需要在之前显式调用 OpenPopup()，控件触发之后得到打开菜单的许可，为按钮添加上打开菜单的逻辑。

》》》CloseCurrentPopup() 和EndPopup() 分别是什么函数？有什么作用？有什么不同，为什么要分别调用？

《《《   拓展：（Popup Menu 和 Context Menu ）Popup Menu 和 Context Menu 是两种常见的用户界面元素、

》》》》发现一个问题：（关于代码为什么没有中断）

前提：在 DrawEntityNode() 函数中，我们会在删除实体之后将 m_SelectionContext 同步清空。

原因：这是因为如果在某种情况下触发事件，使得 DrawEntityNode() 删除了 entity，DrawComponents() 函数中使用的 m_SelecationContext 会因为访问已经被销毁的内存而导致中断错误。

（DrawEntityNode() 中，我们使 m_SelectionContext = entity;  如果删除了 entity，那么 m_SelectionContext 会因为访问被销毁的内存而报错，因为我们在 DrawComponents() 中使用了错误的 m_SelectionContext ）

调用顺序如下：

可是在我的代码中，就算我没有在 DrawEntityNode() 中清空m_Selecation，也不会导致报错中断：

我猜这可能是因为 DrawTreeNode() 函数中使用的是复制传递，而不是引用传递。这导致 DrawTreeNode() 尽管删除了 entity，但 m_SelectionContext 中的值依然可以保持有效，在随后的使用中 m_SelectionContext 可以一直保持可用的数值，所以不会中断报错。

可是我这里的代码和 Cherno 没有什么差别，为什么 Cherno 可以正常的触发断点而我不可以呢？ 希望能够发现错误或者原因之所在（只可能是代码遗漏/一些仓库或规范的更新所导致的）。

》》》》ImGui::BeginPopupContextWindow( ) 函数。

》》》》代码中的问题/设计（BeginPopupContextWindow() 的参数、使用上的 bug）

问题一：函数使用问题解决

 

那么这个参数实现的是什么效果呢？

        则会得到以下的结果：

如上述所示，如果不进行特别要求（禁止窗口进行覆盖操作 -> ImGuiPopupFlags_NoOpenOverItems），那么程序在运行时将会出现一个错误：无论右键单击树节点/窗口空白处，都只会触发 PopupContextWindow 设置的弹出菜单，这其中的原因正是没有进行额外的设置。

除非我们通过参数禁止弹出菜单将在窗口内部的任何项上被右键点击所触发，即：如果有其他弹出窗口已经打开，新的弹出窗口将不会显示。

 

问题二：鼠标单击树节点右侧空白时，触发的是 ContextWindow 而非（亟待解决）

这可能与树节点的判定范围有一定关系。

》》》》绘制时出现的问题：（按钮被窗口覆盖了一部分）

尽管我计算了合适的按钮的大小，并使用计算出来的按钮宽高长度绘制按钮。但是为何设置按钮位置的时候，我明明使用窗口宽度减去了按钮宽度，按钮依旧被窗口覆盖了一部分？

原因：

解决方案：

-------- Make Editor look good -------

》》》》My different

因为我在处理 CameraController 的时候使用了 SceneHierarchyPanel 的非静态成员变量 m_Context ，所以我需要更改一下捕获方式。

》》》》关于 ImGuiTreeNodeFlags_Framed & ImGuiTreeNodeFlags_FramePadding 的定义

• 默认情况：

• ImGuiTreeNodeFlags_Framed

作用: 这个标志使树节点具有一个框架（frame）样式。这意味着树节点会有一个边框，看起来像是一个独立的可点击区域，通常用于视觉上将节点与背景区分开。

使用场景: 如果你想要节点在视觉上更突出，或者希望它们看起来像按钮，可以使用这个标志。

• ImGuiTreeNodeFlags_FramePadding

作用: 这个标志会在树节点的内容周围添加内边距（padding）。这会增加节点内容与其边框之间的空间，使得节点的内容看起来不那么拥挤。

使用场景: 当你希望树节点中的文本或其他内容（如图标）与边框保持一定距离，从而提高可读性和美观时，可以使用这个标志。

原文地址：https://blog.csdn.net/m0_74242407/article/details/142743514

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！