古月月仔的博客

【课堂笔记】可计算理论导论：从零开始理解计算的边界

古月月仔 — Mon, 20 Apr 2026 00:00:00 +0800

可计算理论导论：从零开始理解计算的边界

前言：为什么我们需要可计算理论？

在开始接触可计算理论之前，你可能会问一个很自然的问题：我已经会写代码了，为什么还要学这些抽象的理论？

让我们用一个简单的例子来回答这个问题。

想象一下，你写了一个程序来处理数据：

python

def process_data(data):
 # 做一些复杂的处理
 while True:
 result = some_computation(data)
 if should_stop(result):
 return result

这个程序有一个 while True 循环。如果 should_stop 永远返回 False，程序就会永远运行下去——我们称之为 死循环 或 无限循环。

现在，一个很自然的问题出现了：

有没有一个万能工具，能够自动检测任何程序是否会陷入死循环？

你可能会想：“这不就是编译器或静态分析工具要做的事情吗？” 但可计算理论给出的答案是：

不存在这样的万能工具。

这就是可计算理论要告诉我们的第一个重要事实：计算机的能力是有根本边界的。

什么是可计算理论？

可计算理论（Computability Theory）是计算机科学的理论基石之一，它试图回答以下根本性问题：

什么是 “可计算” 的？ —— 能够用计算机解决的问题有什么特征？
计算机能解决什么问题？ —— 哪些问题存在算法？
计算机解决不了什么问题？ —— 哪些问题永远不存在算法？

这些问题听起来很抽象，但它们关系到：

程序的可靠性：我们能否证明程序正确？
密码学的安全性：密码学的安全性依赖于某些问题的难解性
人工智能的边界：AI 能否解决所有问题？
算法设计的方向：哪些问题值得投入精力去优化

教材与学习方法

本文基于 MIT Michael Sipser 教授的经典教材《Introduction to the Theory of Computation》（《计算理论导引》第三版）。

学习建议：

不要被符号吓到：数学符号只是表达方式的简化，理解背后的直观含义更重要

动手画图：自动机的状态转移图、语法树等，动手画一画会帮助你理解

联系编程实践：每个理论概念都可以对应到实际的编程场景

循序渐进：从最简单的有限自动机开始，逐步过渡到图灵机

一、可计算理论的三个分支

计算理论通常分为三个主要领域，它们从不同角度研究计算：

【LLM应用开发实践】Agent 实战落地经验与技术思考

古月月仔 — Sun, 19 Apr 2026 00:00:00 +0800

Agent 实战落地经验与技术思考

前言

在当前 AI Agent 技术快速发展的背景下，很多开发者都在探索如何构建高效可靠的 Agent 应用。本文整理了一场来自一线开发者的技术分享，聚焦于 Agent 实践中的真实经验、技术思考与设计哲学，希望能为正在探索 Agent 开发的同学提供参考。

一、重新思考 Agent 框架的价值

1.1 框架层的价值正在降低

在大模型发展初期，各类 Agent 框架（如 LangChain、LangGraph）曾备受关注。这些框架试图在应用和大模型之间构建一层抽象层，主要价值是方便切换不同模型厂商。

然而实践表明，这种抽象层的实际价值已经很低：

模型切换成本并不低：不同模型在相同 prompt 下表现差异显著，切换模型往往需要重新优化 prompt 和 tool 设计
兼容层已普及：各大模型厂商基本都兼容 OpenAI 或其他标准 API 格式
Agent 本质简单：Agent 就是一个大 while 循环——观察状态、思考下一步、执行工具或回答，循环往复

1.2 真正的价值在哪里？

Agent 开发真正的价值在于 一线交互过程中积累的 Know-how：

模型在什么场景下表现更好？
哪些 prompt 写法能获得更好的效果？
上下文如何构建才能发挥模型最大潜力？

这些经验是框架无法提供的，只能在真实场景中通过大量测试、观察、调优获得。像Manus这样的应用之所以能超越模型厂商的官方 Agent 实现，正是因为他们在一线积累了大量特定领域的 insights。

关键洞察：应用厂商并不一定会被模型厂商吞噬。垂类场景的深度理解是难以被替代的护城河。

框架 vs 一线 Know-how 对比

【论文阅读】Reflective Context Learning: Studying the Optimization Primitives of Context Space

古月月仔 — Sun, 19 Apr 2026 00:00:00 +0800

摘要：本文是对Contextual AI团队2026年4月最新预印本论文《Reflective Context Learning》的深度解读。该论文首次提出Context Learning与传统参数空间优化在数学本质上同构的核心论点，统一了prompt工程、上下文学习、工具设计等分散领域的研究视角，系统性分析了上下文空间优化面临的高方差、信用分配困难、灾难性遗忘等经典病理，并在此基础上提出了包含五大核心优化原语的RCL（Reflective Context Learning）框架，为Agent无需参数更新即可持续自演进提供了理论基础与实践指导。

【LLM应用开发原理】从提示词工程、上下文工程到Harness工程的设计哲学

古月月仔 — Wed, 15 Apr 2026 00:00:00 +0800

引言

大模型驱动的智能体（Agent）技术发展至今，已经走过了三个清晰的工程化阶段：从最初「怎么写好提示词」的单点技巧探索，到「怎么高效管理上下文」的模块体系构建，再到今天「怎么部署生产级Agent」的完整工程体系。这三个阶段的演进不是技术的随机迭代，而是遵循着清晰的设计哲学脉络，本质是软件工程理念在AI时代的自然延伸。

Agent工程化三阶段演进时间线

一、提示词工程（Prompt Engineering）：人机交互接口的第一次对齐

设计哲学：把自然语言变成新的编程语言

提示词工程是Agent技术的第一个工程化阶段，它要解决的核心问题是消除自然语言的歧义性，实现人类意图与大模型能力的精准对齐。

在大模型刚出现的阶段，开发者很快发现：同样的问题用不同的表述方式问大模型，得到的结果可能天差地别。这背后的本质是大模型的能力是建立在海量文本数据的统计规律之上，它对自然语言的理解和人类的认知存在天然的偏差。提示词工程的出现，就是为了构建一套「翻译规则」，把人类的自然语言需求翻译成大模型能够精准理解的输入格式。

核心方法论的演进

从最基础的指令明确化，到角色设定、思维链（Chain-of-Thought）引导、Few-shot示例注入、输出格式约束，提示词工程的所有方法论本质上都是在做同一件事：给大模型足够的上下文约束，减少它的输出分布空间，让结果落在预期的范围内。

提示词工程核心方法论架构图

这一阶段的标志性成果包括：

OpenAI官方发布的《Prompt Engineering Guide》，系统化梳理了提示词设计的最佳实践
Google DeepMind提出的思维链（CoT）技术，大幅提升了大模型的复杂推理能力
各种提示词框架的出现，把零散的技巧变成可复用的模板

提示词工程的历史贡献在于它第一次证明了：不需要微调大模型参数，只通过优化输入就能显著提升大模型的输出质量，这为后续的工程化探索打开了全新的思路。

二、上下文工程（Context Engineering）：模型记忆能力的工程化突破

设计哲学：让大模型从「闭卷考试」变成「开卷考试」

提示词工程很快遇到了它的能力天花板：

上下文窗口长度限制，无法注入大量的领域知识
知识更新滞后，大模型的训练数据是静态的，无法获取实时信息
幻觉问题难以避免，大模型会编造不存在的信息
知识复用成本高，每次交互都需要重复注入相同的背景信息

上下文工程（核心是RAG技术体系）的出现就是为了系统性解决这些问题，它的设计哲学非常朴素：既然大模型的「内部记忆」有限且不可修改，那就给它外接一个「外部知识库」，让它可以动态检索需要的信息来回答问题。

【Vibe-Coding】前后端基础知识扫盲-1

古月月仔 — Mon, 13 Apr 2026 00:00:00 +0800

Tip

最近疯狂迷恋Vibe Coding, 一闲下来就在和AI交流，发现一个问题，就是虽然AI能基于需求快速构建一个产品，但是由于我没有体系的学过WEB产品的开发知识，导致我想要指定AI对某一具体细节内容进行修改，只能描述当前的问题是什么，想要达到效果是什么。

这种模式一方面导致产品对我来说几乎是一个黑盒，快速开发到及格没问题，但是很难达到我理想的效果，而且这种编码方式有时候也不是很可控，出现问题只能靠AI，AI会为了改一个简单的问题而去动一些全局的架构文件，以至于牵一发而动全身。

还有就是一些具体的前端问题，样式微调对AI来说还是有点困难，还需要手动定位调整，鉴于此我决定来一次WEB产品的地毯式快速入门，以帮助我能更好的定位问题和构建产品，由于我本身有一些编程基础，所以具体的语法可以不是很关注，主要学某个东西是什么、为什么这样做，现代WEB产品构建有没有更高级模块化的方案了。

想象一下，你正在用淘宝购物、在微信上聊天、或者在B站看视频。这些看似简单的操作，背后其实有一个庞大而精密的系统在运转。当你点击"购买"按钮时，数据就像快递包裹一样，在你的手机、服务器、数据库之间来回传递。

Vibe-Coding工作流

第一章：网页是如何工作的？

1.1 从输入网址到看到页面，发生了什么？

让我们从一个最熟悉的场景开始：你在浏览器地址栏输入 www.taobao.com，然后按下回车。接下来的几毫秒里，到底发生了什么？

让我用一个"餐厅吃饭"的比喻来帮你理解：

text





你的操作：在浏览器输入 www.taobao.com
 ↓
第一步：浏览器问"服务员"（DNS）
 "www.taobao.com 这个餐厅的地址在哪？"
 ↓
 DNS 回答："哦，那家店啊，地址是 110.75.115.70"
 ↓
第二步：浏览器"开车"到那个地址
 "你好，我想来份淘宝首页！"
 ↓
第三步：餐厅"后厨"（服务器）开始准备
 - 看看你要什么菜（数据）
 - 去"仓库"（数据库）拿食材
 - 把菜"炒"好（处理数据）
 - 装盘（组装成网页）
 ↓
第四步：服务员把菜端过来
 ↓
第五步：你开始"吃"（浏览器渲染）
 - 先看菜的样子（HTML结构）
 - 再看摆盘好不好看（CSS样式）
 - 尝尝味道（JavaScript交互）
 ↓
你看到的：淘宝首页！

这个比喻是不是好懂多了？接下来，让我们把这个比喻里的每个角色，翻译成程序员的语言。

【LLM应用开发原理】Agent记忆与检索

古月月仔 — Tue, 10 Mar 2026 00:00:00 +0800

【LLM应用开发原理】Function Calling底层原理与MCP

古月月仔 — Mon, 09 Mar 2026 00:00:00 +0800

从"只能回答"到"能调用工具"：LLM能力的演进

背景与演进

在传统的 LLM 交互中，模型只能通过自然语言与用户对话。无论用户问什么问题，LLM 都只能基于其训练数据生成文本回答——它无法真正"做"任何事情，比如查询实时天气、读取数据库、发送邮件或执行代码。

这就好比一个非常博学但行动力为零的学者：他知道一切知识，但当你让他"帮我查一下明天的航班"时，他只能告诉你"我很抱歉，我无法访问实时数据"。

Function Calling 的出现，改变了这一局面。它让 LLM 从"只能回答问题"的被动角色，变成了"能指挥工具干活"的主动指挥官。

核心比喻：

传统 LLM：像一台只有屏幕的电视机——只能被动显示内容

Function Calling：给这台电视接上了遥控器——可以控制外部设备

MCP：为所有遥控器制定了统一的标准协议

延伸阅读：

OpenAI Function Calling Documentation - Function Calling官方文档

Anthropic Tool Use Guide - Claude工具调用指南

Function Calling底层原理

现代大模型（如 GPT-4、Claude、Qwen-7B-Chat 等）之所以能够精准调用工具，是因为在训练阶段进行了特殊的有监督微调，使用精心构造的数据集让模型建立了"任务意图→工具选择→参数提取"的概率关联。

这一过程让模型学会：当用户意图匹配某个工具时，不再输出自然语言，而是输出特定格式的结构化数据（通常是 JSON），方便代理层解析并执行相应的服务调用。

从技术角度看，Function Calling 的实现涉及三个层面：

层面	核心机制	解决的问题
训练层面	有监督微调（SFT）	让模型"学会"识别何时需要调用工具
推理层面	约束解码（Constrained Decoding）	保证输出 JSON 的语法正确性
协议层面	标准循环交互	实现意图→执行→→结果的完整闭环

Function Calling 三层技术架构

【LLM应用开发原理】Agent Skill原理与基础

古月月仔 — Mon, 09 Mar 2026 00:00:00 +1200

Skill在Agent架构中的全景位置

从工具到技能：Agent能力的进化

在Agent开发的早期阶段，我们通过**工具调用（Tool Calling）**让模型具备了访问外部世界的能力。这一模式最早由OpenAI在2023年3月的GPT-4 API中正式引入，随后成为业界标准。但随着任务复杂度的提升，单纯的工具集合逐渐暴露出局限性。

维度	工具（Tool）	技能（Skill）
粒度	单一动作（如"搜索"）	组合流程（如"撰写研报"）
逻辑	无状态，单次调用	有状态，多步协调
复用	通用性强，场景普适	领域特定，针对性强
依赖	独立执行	可依赖其他技能/工具
抽象层级	底层原语	高层能力

从工具到技能的进化

Skill的设计起源

1. 软件工程的模块化思想

Skill的设计灵感源于软件工程中久经考验的**模块化编程（Modular Programming）**思想，这一思想可追溯到Dijkstra在1968年发表的经典论文《A Discipline of Programming 》¹。正如Parnas在1972年《On the Criteria to Be Used in Decomposing Systems into Modules 》²中所阐述的，模块化的核心在于"信息隐藏"（Information Hiding）——将复杂的实现细节封装在模块内部，只暴露必要的接口。

【LLM应用开发原理】Agent经典开发范式

古月月仔 — Fri, 06 Mar 2026 00:00:00 +0800

动手学Agent

推荐一个Datawhale开源项目，体系学习，动手实现一个简单Agent架构：HelloAgent

具体的编码实现项目中非常详细，本博文中我只尝试做一个设计思想整理。

延伸阅读：

LangChain: Getting Started with Agents - 主流Agent框架的实现细节

AutoGPT: Autonomous GPT-4 Agent - 首个自主Agent的探索

BabyAGI: Task-driven Autonomous Agent - 任务驱动的自主Agent实现

Agent经典范式

1. ReAct范式（Reasoning and Acting）

最基础、应用最广的范式，是目前绝大多数 Agent 的基石。

它模仿人类解决问题的直觉：先思考（Thought），再行动（Action），最后观察结果（Observation）。

核心思想解析

ReAct的精髓在于将"推理"（Reasoning）和"行动"（Acting）融合在同一循环中。这与传统程序设计的"分析-执行"分离模式截然不同。

想象一下人类解决数学应用题的过程：

阅读题目（理解问题）
思考需要什么条件（Thought）
列出已知和未知的量（分析）
应用公式计算（Action）
验证结果是否合理（Observation）
如果不合理，调整思路重新计算（循环）

ReAct范式正是将这种人类自然的解决问题方式形式化，让LLM能够像人类一样"边想边做"。

逻辑链路

传统LLM是一问一答。ReAct引入了一个循环（Loop）

$$用户输入 \xrightarrow{思考} 行为 \xrightarrow{观察} 再次思考 \dots 直到得出答案$$

ReAct循环流程

【LLM应用开发原理】我怎样理解Agent

古月月仔 — Thu, 05 Mar 2026 00:00:00 +0800

寒假开学以来，一直在学习一些Agent相关的技术文档和媒体视频，从概念设计思想到手搓了几个Demo，最近在尝试拆解一些热门框架的源码，这段时间的学习让我对Agent的看法大为改观，沉迷于每日头脑风暴，有些想法不吐不快，做此纪录。

怎样理解Agent

Chat类AI产品

自 2023 年 ChatGPT 引爆全球以来，我几乎每天都在与各类 Chat 产品交互。在那段时期，我对大模型的认知还停留在一个极简的逻辑上——“模型即产品”。我理所当然地认为，大模型就是一个能与我无障碍交流的聊天窗口。

随后，前年开始，Agent(智能体)的概念被自媒体反复咀嚼与炒作：从早期的"工作流颠覆世界”，到后来层出不穷、月更不辍的新名词，每一波浪潮都宣称要重塑人类社会。这种浮躁的空气让我对 Agent 这个词产生了某种程度的”PTSD(创伤后应激障碍)”，导致我迟迟没有沉下心去剖析它的底层机理。

但在这一段时间系统性的学习后，我大致认清了Agent的产品形态。现在，我可以非常肯定地给出一个核心结论：Agent 绝非炒作概念，它是以大模型为核心驱动(类似CPU)的下一代操作系统。 我们此前以及现在所使用的所有顶级 AI 产品，剥开它们的对话外壳，其本质都是一套复杂而精密的 Agent 系统。

复杂Agent案例

Transformer的无状态性

提到大模型与 Agent 的进化，绕不开 AI 时代真正的分水岭：Transformer 架构。

【LLM技术】Transformer架构宗述 | 古月月仔的博客

【年度总结】致我的2025：一些事实与感受

古月月仔 — Mon, 26 Jan 2026 00:00:00 +0800

致我的2025：一些事实与感受

听到Eason在《四季》里唱：“最后已事过境迁长街风景已变” ，虽然语境情感不同，却突然增加好多情感流动和共鸣。

又至一年腊八，感慨过去这一年，自己也历尽了四季轮回。如今回首，2025年的每一季风霜雨雪，都在有形与无形中塑造延续着我。自己对关于爱、失去、成长、身份与存在这些人生命题有了一些新的感受。

蛇年打铁花留念

春

保研后的第一个长假，我同时在做好几件事：为之后的科研做点准备，保持学习习惯，还有一份实习。拿到第一笔自己赚的、不算少的钱时，感觉很好，计划着给奶奶买点什么。但她没等到。事情发生在寒假末尾，很突然。

之后的一段时间都处于一种当时不知道如何描述的难过中。现在回想，在这种难过里，有一部分是因为想起高中时一位好友，同样的猝不及防，以至我时常怀疑只是一场梦。还有一部分，是清明回家，我发现关于她的痕迹比我想象中少很多，我之前疏于记录，更难以找到合照，家里人也在平常避免提起奶奶，好像这样就能避开伤心。我无法批评这种的行为的对错，因为发现自己也会无意识地避免去想高中的那位好友，避免去想奶奶。我害怕面对，也全然学不会如何面对死亡，只是忽地想到：在不经意间，我自己也变成了遗忘的同谋。

找到的一张合照

夏

毕业前最后的夏天，我刻意让自己慢下来，像一位收藏家一样细细感受每一份情感，时间突然多出来了，做了两件事：

一是和朋友们好好告别。和宠爱我的老师、实验室同袍、舍友、开黑小团体吃了很多次饭，谈天说地，暑假也和几个朋友约着去了彼此的城市，或者又自己一人去了新的城市，作为一场城市生命的短暂访客。广州早茶的烟火气，苏州的园林曲径，这些画面和毕业的感伤混在一起，成了很复杂的记忆。

二是我开始有意识地去“记录”感受。记住别人对我的好，也记住我对他人的不舍。我把自己的毕业季，当作一场盛大的、需要全身心投入的仪式来体验。好像又有突然明白：真正的告别，不是在那一天，而是在那之后无数个回想起“最后一次”的瞬间。

红浪漫成员毕业留念

【C++】组合、继承和多态

古月月仔 — Mon, 05 Jan 2026 00:00:00 +0800

组合（Composition）、继承（Inheritance）和多态（Polymorphism）是C++中面向对象编程（OOP）的三大支柱。

之前只在大学课本上学到一点皮毛，在此做复习和深入挖掘。

组合 (Composition)物理嵌套与高效复用

组合描述的是一种“有一个 (Has-a)”的关系。在 C++ 中，当我们将一个类的对象作为另一个类的数据成员时，就形成了组合。

从内存布局的角度来看，组合体现为物理上的直接嵌套：成员对象的所有数据成员被完整地包含在宿主对象的内存空间内。这意味着，如果你在栈上创建一个宿主对象，其组合的所有成员也都在栈上；同理，若宿主在堆上，成员也在堆上。

这种布局方式带来了极高的执行效率，因为数据在内存中是连续存放的，极大提高了 CPU 的缓存命中率。

在初始化逻辑上，C++ 遵循严格的顺序：成员对象先构造，宿主对象后构造；析构时则完全相反。设计上，C++ 社区推崇“优先使用组合而非继承”，因为组合是一种“黑盒复用”，宿主类只需关心成员类的公共接口，而不需要了解其内部实现，这大大降低了代码间的耦合度。

cpp

class Engine { /* 引擎数据 */ };

class Car {
private:
 Engine engine; // Car 组合了 Engine
};

如果你在栈上创建一个 Car 对象，那么 Engine 的数据会直接包含在 Car 的内存块内部。

设计原则：优先使用组合，而不是继承。组合耦合度低，灵活性高。

生命周期：成员对象（Engine）随宿主对象（Car）的创建而创建，随其销毁而销毁。

继承 (Inheritance)：结构延伸与逻辑分类

继承建立的是一种“是一个 (Is-a)”的关系，允许你基于已有的类创建新类，从而复用代码。它允许子类继承父类的属性和行为。

cpp





class Animal {
public:
 int age;
 void eat() { std::cout << "Eating..."; }
};

class Cat : public Animal { // Cat 继承自 Animal
public:
 void meow() { std::cout << "Meow!"; }
};

派生类（Cat）的内存结构是：父类的数据成员 + 派生类特有的数据成员。

核心逻辑：

可见性：public 继承表示父类的公有成员在子类中依然公有。
构造顺序：先调用父类构造函数，再调用子类构造函数。析构顺序则相反。

在内存层面，继承表现为结构的延伸：子类对象的内存块头部通常包含了一个完整的父类对象副本，随后才是子类特有的数据成员。这种“头部对齐”的特性使得父类指针能够安全地指向子类对象的起始地址。

继承被称为“白盒复用”，因为子类往往能够看到父类的 protected 成员，这虽然增强了灵活性，但也导致了较高的耦合——父类的任何微小改动都可能波及整个继承链。

【C++】作用域与内存管理

古月月仔 — Fri, 02 Jan 2026 00:00:00 +0800

生命周期与作用域的区别

作用域（Scope）是空间/代码维度的概念：指你的变量名在代码的哪个范围内“可见”（编译器能认出这个名字）。

生命周期（Lifetime）是时间/内存维度的概念：指变量在程序运行过程中，从“分配内存”到“释放内存”的这段物理时间。

对于栈对象，两者几乎是绑定的，栈对象的作用域决定了其生命周期；作用域结束的地方，就是生命周期终结的地方。

对于堆对象，其作用域和生命周期则是分离的；一般来说堆对象的的名字（指针）有作用域，但对象本身没有。

Object的生命周期

在 C++ 中，对象的生命周期是指从对象被创建到被销毁的整个过程。

CPP中的内存布局主要分为五个区域，其中最核心的是栈内存和堆内存。

区域	存储内容	生命周期
栈 (Stack)	局部变量、函数参数、返回地址。	自动管理，进入作用域创建，离开销毁。
堆 (Heap)	通过 `new` 分配的对象。	手动管理，直到 `delete` 或程序结束。
全局/静态存储区	全局变量、`static` 变量。	程序启动时分配，程序结束时释放。
常量存储区	字符串常量（如 `"Hello"`）。	整个程序运行期间。
代码区 (Text)	程序的机器指令（二进制代码）。	只读，整个程序运行期间。

栈 (Stack) 与栈对象

什么是栈？

栈是一块连续的内存区域。它的运作模式是 LIFO (Last In, First Out，后进先出)。类似于你在往弹夹里压子弹，最后压进去的子弹，最先被打出来。

什么是栈对象 (Stack Objects)？

通常指值类型 (Value Types) 或 基本数据类型。一般包含：局部变量（如 int a = 10）、函数参数、函数返回地址等。

栈对象的生命周期非常短。当一个函数（方法）开始执行时，系统会在栈上“压入”一个栈帧 (Stack Frame)，里面装着这个函数需要的所有局部变量。当函数执行结束（return），这个栈帧直接被“弹出”，所有数据瞬间销毁。

栈对象不需要担心内存泄漏，速度极快，CPU 甚至有专门的指令来处理栈指针。

Note

在 C++ 或 Swift (Struct) 中，复杂的对象也可以完全存在栈上。但在 Java 或 C# 中，通常只有基本类型（int, boolean）和对象的引用在栈上。

【C++】LearnCppDate

古月月仔 — Thu, 01 Jan 2026 00:00:00 +0800

前言

最近在学习的时候发现自己陷入了一个瓶颈，就是发现自己过去主要的学习方式–看视频，大脑有点脱敏，且频频走神。看视频时常产生一种“我在进步”的错觉，但实际写代码时会大脑一片空白。

之前看过的一本书《1000hours》里曾经提到一种理论，和我现在的情况很像，就是如果在学习一项技能，或者学习一个新事物时，如果仅仅是投入时间和金钱，但是没有投入最重要的注意力，则其效率会变的非常低下。

自己思考了一下发现自己现在日常生活中最专注的情况主要是：读书、和AI深度交流、完全沉浸式的娱乐；基于自己的专注能力，打算亲身实践一下新的学习方法，即啃高信息密度的书/文档、遇到不懂的问题问AI，遇到需要动图辅助理解的知识点再去找视频讲解，最后对每日啃过的内容进行一个思维整理输出，写为笔记方便复习，希望新的学习方法能改善我当前的学习困境。

本篇笔记的内容也主要集中于我在啃这个网站Learn C++ – Skill up with our free tutorials 文档内容的每日总结输出，和中间过程与AI探讨的一些小Tips和理解。

Day01

Programs and programming languages

计算机硬件的局限性与“二进制”语言

计算机的核心由 CPU（中央处理器） 和 内存（RAM） 组成。尽管 CPU 拥有强大的计算能力，但它本质上是非常“笨”的，只能识别电信号的通（1）与断（0）。这意味着，计算机原生唯一能理解的语言就是机器语言（Machine Language）。程序员在早期必须通过冗长的 0 和 1 序列来下达指令，这不仅极其违反人类直觉、容易出错，而且由于不同厂家的 CPU 指令集各异，一份代码无法在不同的电脑上通用，这种“不可移植性”严重限制了软件的发展。

低级语言的改良：汇编语言的过渡

为了缓解机器语言带来的痛苦，汇编语言（Assembly Language） 应运而生。它引入了“助记符”的概念，用简单的英文单词（如 ADD、MOV）代替了晦涩的二进制码。虽然这让代码变得稍微可读了一些，但它依然属于低级语言。汇编语言与底层硬件是一一对应的，程序员仍需关注寄存器和内存地址等硬件细节。此外，它依然需要一个名为“汇编器”的工具将其翻译回机器码，且跨平台运行的问题依然没有得到根本解决。

高级语言的革命：效率与跨平台的飞跃

为了让编程真正回归逻辑本身，高级语言（High-level Languages）（如 C++、C、Python）成为了现代开发的主流。高级语言最大的突破在于它允许程序员使用接近自然语言和数学逻辑的方式编写代码。更重要的是，它通过**编译器（Compiler）**实现了代码的“可移植性”：程序员只需编写一套逻辑，编译器就能根据不同的目标机器，将其翻译成对应的机器码。这种抽象不仅让代码更易维护，还让复杂软件的协作开发成为了可能。

Note

跨平台是高级语言与硬件脱钩后的必然产物。它将程序员从繁琐的硬件指令中解放出来，专注于逻辑表达。尽管 C++ 需要为不同平台重新编译（源码级跨平台），而 Java/Python 通过虚拟机实现（字节码级跨平台），但它们的本质逻辑是一致的：即通过一层“翻译中介”，屏蔽底层硬件差异。作为开发者，应当区分“语言特性”与“系统特性”，优先使用标准库以确保代码的可移植性。

翻译的双轨制：编译器Compiler与解释器Interpreter

在高级语言进化的过程中，为了平衡“运行效率”与“开发便捷性”，分化出了两种核心的翻译策略。编译器路线（以 C/C++ 为代表）采取的是“离线翻译”模式，在程序运行前将整篇代码一次性转化为机器码。这就像翻译一本完整的书，虽然编译过程耗时，但产出的程序执行速度极快，且能在运行前通过严格的语法体检排除隐患。而解释器路线（以 Python/LISP 为代表）则采取“同声传译”模式，在程序运行时逐行翻译并执行。这种方式虽然牺牲了部分运行性能，但换来了极高的调试效率和灵活性，允许程序员即写即看结果。

如下为两种代码翻译方法的示意图：

a simplified representation of the compiling process

【Games101】动画基础

古月月仔 — Fri, 19 Dec 2025 00:00:00 +0800

动画通过连续图像产生运动感，其发展从手绘到数字时代。关键帧动画是基础技术，通过定义关键姿态并由计算机插值生成中间帧，数学本质是参数空间的插值过程。

动画概念

动画概述与历史

动画的本质是“赋予生命”，通俗来说就是通过随时间变化的场景模型，输出一系列连续图像，利用人眼的视觉暂留产生运动感，基于对人眼感知的能力，动画的帧数一般为以下的标准：

帧率标准：电影通常为 24 fps，一般视频为 30 fps，而虚拟现实（VR）则需要高达 90 fps 来保证流畅度。

image-20251219213410718

一些重要动画的发展史：

早期尝试：公元前 3200 年伊朗的陶器彩绘被认为是最早的动画原型；1831 年出现了诡盘（Phenakistoscope）。
电影诞生：1878 年埃德沃德·迈布里奇拍摄的《萨莉·加德纳》是第一部电影，最初用于科学研究。
手绘巅峰：1937 年迪士尼推出了首部长篇手绘动画《白雪公主与七个小矮人》。
数字时代：1963 年 Ivan Sutherland 的 Sketchpad 开启了数字计算机生成动画的先河；1995 年《玩具总动员》成为首部全 CG 长篇电影。

关键帧动画 (Keyframe Animation)

这是最传统也是最基础的动画技术。关键帧动画的核心在于将动画序列分解为由核心动作组成的“关键点” 。

image-20251219213455017

【Games101】颜色与感知(Color and Perception)

古月月仔 — Thu, 18 Dec 2025 00:00:00 +0800

颜色是光线与感光系统互动的结果。人眼通过三种视锥细胞将连续光谱转换为三个神经信号，这解释了为何三原色能模拟色彩，并产生了同色异谱现象。

光谱分布 (SPD)

在理解计算机如何模拟颜色之前，必须澄清一个根本的物理事实：颜色并非物体固有的属性，而是光线与特定感光系统（如人眼、相机传感器）相互作用的产物。一个物体之所以呈现红色，并非因为它“是”红色，而是因为它吸收了可见光中除红光波段外的其他光线，并将红光反射到了我们的眼睛中。

光谱

可见光谱 (Visible Spectrum)：决定我们看到何种颜色的关键，是光的可见光谱。这是电磁波谱中波长介于 400纳米（紫光）到 700纳米（红光） 之间的一段。波长低于400nm的紫外线、高于700nm的红外线，人眼都无法直接感知。因此，在绝大多数游戏、影视渲染等视觉应用中，我们仅需模拟和计算这一狭小波长范围内的光线行为，这极大地简化了问题。

光谱功率分布 (SPD)：为了精确描述一束光的颜色构成，我们使用光谱功率分布（Spectral Power Distribution, SPD） 这一核心物理量。SPD 描述了光在每个波长（λ）上携带的能量（或功率）。

它可以看作是一个函数：横坐标是波长 λ，纵坐标是该波长上的辐射能量。一束纯净的单色激光的 SPD 是一个尖锐的尖峰，而日常的太阳光或白炽灯光则是在整个可见光谱上都有广泛分布。SPD 是定义一种光最基础、最完整的物理方式。

不同光线的SPD

Tip

SPD 就像是光的“成分配方表”。日光的配方比较均匀，而白炽灯的配方里“长波（红色）”比例更高。

光线还具有线性性质：不同光线的能量（其 SPD）是线性可叠加的。

【Games101】相机与透镜

古月月仔 — Tue, 16 Dec 2025 00:00:00 +0800

成像包含合成与捕捉两个环节。针孔相机虽能实现清晰成像，但进光量不足；引入透镜可提升亮度，却带来了景深与视场角等物理权衡，揭示了亮度与清晰度的内在矛盾。

我们在之前的课程里（光栅化、光线追踪）一直在忙着计算“光线是怎么传播的”。但这只是故事的一半。

Synthesis (合成)：我们在之前的课程里做的光栅化、光线追踪，是在计算场景中光线的传播。

Capture (捕捉)：这节课讲的是，如何用一个虚拟的“设备”（相机）把这些光线记录下来变成图像。

$$ \mathrm{Imaging} = \mathrm{Synthesis} + \mathrm{Capture} $$

针孔与透镜

小孔成像示意

最原始的相机是针孔相机 (Pinhole Camera)。它很简单，却道出了成像的本质。利用小孔成像原理，强制让光线“各行其道”。因为孔极小，物体上一点发出的光，只能通过这唯一的孔打在传感器的一个点上。其优点在于：无限景深。无论远近，所有物体都是清晰的（没有虚焦概念）。

小孔成像需要在暗室中曝光几个小时

致命缺陷：太暗了。因为孔太小，进光量微乎其微。要想拍出亮的照片，曝光时间得按小时算。

Tip

**如果把孔弄大点呢？**结果是光线会乱。物体上一点发出的光会打在传感器的一片区域上，图像就糊了（Blur）。

为了解决“暗”的问题，我们需要把孔弄大（光圈）。但为了解决孔大导致的“糊”的问题，我们引入了透镜。透镜能把从物体上同一点发出、射向不同方向的光线，重新汇聚到传感器上的同一个点。代价则是焦距 (Focus) 的产生。

透镜只能让特定距离的物体完美汇聚。
比这个距离远或近的物体，汇聚点就不在传感器上了，结果就是模糊 (Defocus Blur)。

Note

【C++】封装与常用关键字

古月月仔 — Mon, 15 Dec 2025 12:00:00 +0800

基本概念

封装的概念

封装（Encapsulation） 是面向对象编程（OOP）的三大特性之一，简单来说，封装就是将**数据（属性）和操作数据的函数（行为）**绑定在一起，形成一个名为“类（Class）”的单位，并对外部隐藏内部实现的细节。

封装的核心思想是**“对外提供接口，对内隐藏实现”**。它的好处包括：

安全性（数据隐藏）： 防止外部代码随意修改对象内部的关键数据，避免程序进入非法状态。
易维护性： 如果内部逻辑需要修改，只要外部接口（函数名、参数）不变，调用者的代码就不需要改动。
模块化： 代码结构更清晰，每个类负责自己的逻辑。

访问修饰符

C++ 通过三个关键字来控制成员的访问权限。它们是实现封装的关键工具：

关键字	访问权限说明
`public`	公有：类内部和类外部都可以直接访问。通常用于存放成员函数。
`private`	私有：（默认）只有类内部的函数可以访问，外部无法直接访问。通常用于存放成员变量。
`protected`	保护：类内部及派生类（子类）可以访问，但类外部无法直接访问。

this 指针：是一个指向当前对象实例的指针。常用于在成员函数中区分“成员变量”和“同名参数”。

class 的成员默认是 private，而 struct 的成员默认是 public。通常建议用 class 实现复杂的逻辑封装。

friend（友元）：如果你希望某个外部函数或类能访问当前类的 private 成员，可以用 friend 声明。它会打破封装，所以要谨慎使用。

Note

friend：破坏封装还是增强封装？

friend 允许特定的类或函数访问私有成员。

视角一：它破坏了封装，因为它打开了后门。

视角二（更深层）：它增强了封装。通过将紧密耦合的工具类设为友元，可以避免为了让外部访问而被迫将成员声明为 public，从而将权限精确控制在最小范围内。

const：在封装中，常用于修饰不修改成员变量的函数（如 getBalance() const），这被称为常成员函数，能提高代码的安全性和可读性。

Example

来一个银行账户的栗子：我们不希望别人直接修改我们的余额（balance），而是必须通过存款或取款函数来操作。

cpp





#include <iostream>
#include <string>

class BankAccount {
private:
 // 私有成员：外部无法直接访问
 double balance;
 std::string ownerName;

public:
 // 构造函数：初始化数据
 BankAccount(std::string name, double initialBalance) {
 ownerName = name;
 if (initialBalance >= 0) {
 balance = initialBalance;
 } else {
 balance = 0;
 }
 }

 // 公有成员函数：提供受控的访问接口（Getter）
 double getBalance() const {
 return balance;
 }

 // 公有成员函数：存款（Setter/Action）
 void deposit(double amount) {
 if (amount > 0) {
 balance += amount;
 std::cout << "存入: " << amount << " 元" << std::endl;
 }
 }

 // 公有成员函数：取款
 void withdraw(double amount) {
 if (amount > 0 && amount <= balance) {
 balance -= amount;
 std::cout << "取出: " << amount << " 元" << std::endl;
 } else {
 std::cout << "余额不足或金额非法！" << std::endl;
 }
 }
};

int main() {
 BankAccount myAccount("张三", 1000.0);

 // myAccount.balance = 1000000; // 错误！编译会报错，因为 balance 是 private 的

 myAccount.deposit(500); // 正确：通过公有接口操作
 myAccount.withdraw(200); // 正确：通过公有接口操作

 std::cout << "当前余额: " << myAccount.getBalance() << " 元" << std::endl;

 return 0;
}

进阶部分

访问控制的边界与编译时检查

在 C++ 中，封装不仅仅是“隐藏变量”，它是一种编译器层面的协议。

【Games101】高级光线传播与复杂外观建模

古月月仔 — Mon, 15 Dec 2025 00:00:00 +0800

高级光线传播技术旨在提升复杂光照下的渲染效率与质量。文章对比了无偏与有偏方法，并详细分析了双向路径追踪和梅特罗波利斯光线传播两种策略的原理、适用场景及优缺点。

Tip

这节课可以当作一个小综述，大致了解就好。

Tip

前的课程我们学习了路径追踪（Path Tracing），它是现代渲染的“黄金标准”。但是，它并非万能。在面对“光路特别复杂”或者“材质特别复杂”的情况时，标准路径追踪会产生巨大的噪点，或者效率极低。这节课就是为了解决这两个难题：

高级光线传播：怎么在复杂光照下算得更准、更快？

高级外观建模：怎么渲染那些不是简单平面的物体（如头发、雾气、皮肤）？

高级光线传播 (Advanced Light Transport)

这部分的核心在于解决标准 Path Tracing 收敛慢、噪点多的问题。

无偏与有偏 (Unbiased vs. Biased)

在深入算法之前，我们需要先建立一个评价标准：

无偏 (Unbiased)定义为：蒙特卡洛估计的期望值始终等于真实值。其特点为：样本少时会有噪点（Noise），但只要样本够多，结果一定是对的。之前学过的Path Tracing就是一个无偏的方法。

有偏 (Biased)定义为：估计值的期望与真实值有系统性偏差。其特点为：样本少时，结果通常是模糊 (Blurry) 的，而不是噪点。一致性 (Consistent)：这是有偏方法中好的那一类。如果样本数趋向于无穷大时，误差能收敛到0，就叫“一致”。

Tip

通俗理解：无偏 = 画面有噪点但准确；有偏 = 画面平滑但可能模糊（看起来像把噪点抹平了）。

解决“光路难找”的几种高级策略

当光源被遮挡，或者光线需要经过多次反弹才能进入眼睛时（例如：光线打到墙上，墙漫反射到玻璃球，玻璃球折射聚焦到地板，我们看地板上的亮斑），标准 Path Tracing 很难随机“碰”到这种路径。

双向路径追踪 (BDPT - Bidirectional Path Tracing)

双向路径追踪示意

【Games101】材质与外观

古月月仔 — Thu, 11 Dec 2025 00:00:00 +0800

在计算机图形学中，材料的视觉外观由其与光线的相互作用决定，这通过双向反射分布函数（BRDF）数学模型精确描述。BRDF必须遵循非负性、线性、可逆性和能量守恒等物理定律，以确保渲染的真实性。

在计算机图形学中，我们如何定义和区分不同的材料？

例如，一个3D咖啡杯模型，通过赋予不同的表面属性，它可以呈现出陶瓷、金属或塑料的质感。

image-20251215205054966

答案是：材料的视觉外观完全由其与光线的相互作用方式决定。这种相互作用在图形学中通过一个称为BRDF（双向反射分布函数） 的数学模型来精确描述。因此，一个核心等式被确立：Material == BRDF。这意味着，改变一个物体的材质，本质上就是改变它的BRDF。

BRDF 的物理性质

BRDF（双向反射分布函数）作为一个描述材质物理属性的函数，必须遵循以下几条核心的物理定律。这些性质保证了渲染结果在物理上的真实性和可信度。

非负性 (Non-negativity)

这是最基本的性质。因为 BRDF 描述的是光能量的分布比例，而光能量不可能是负数，所以 BRDF 函数的值必须永远大于等于零。

公式： $$ f_{r}(\omega_{i}\rightarrow\omega_{r})\ge0 $$

线性 (Linearity)

材质对光照的反应是线性的。这意味着，如果你有两个光源照亮物体，物体反射的总光线等于这两个光源分别照射时反射光线的总和。

image-20251215213822499

物理意义：这一性质允许我们将场景中所有光源的影响（通过积分）累加起来，计算出最终的出射辐射亮度（Radiance）。
公式：
$$ L_{r}(p,\omega_{r})=\int_{H^{2}}f_{r}(p,\omega_{i}\rightarrow\omega_{r})L_{i}(p,\omega_{i})\cos\theta_{i}d\omega_{i} $$
这个积分公式体现了所有入射光 $L_i$ 对出射光 $L_r$ 的线性贡献。

【Games101】光线追踪与蒙特卡洛路径追踪

古月月仔 — Tue, 09 Dec 2025 00:00:00 +0800

蒙特卡洛积分利用随机采样近似计算复杂积分，其理论基础是概率论。文章介绍了离散与连续随机变量、概率密度函数、期望值以及随机变量函数的概念，并阐述了这些知识在图形学渲染问题中的应用。

Tip

在图形学中，我们经常遇到无法算出解析解的积分（比如上一节课的渲染方程，需要对半球面上所有光线积分）。

解决思路：既然算不准，那我就随机取样。比如我想知道一个广场上所有人的平均身高，我不需要真的去量几万个人的身高（求积分），我只需要随机抓 100 个人量一下（采样），算个平均值（期望），就能大概估算出结果。这就是概率论在渲染中的核心作用。

蒙特卡洛积分是一种基于随机采样的方法，而概率论是它的理论基石。

概率论基础

随机变量 (Random Variables)

定义：随机变量 $X$ 是一个变量，它的值是不确定的，代表了一个随机过程的潜在结果。

例子：掷骰子。$X$ 可能取的值是 $\{1, 2, 3, 4, 5, 6\}$ 。

离散情况 (Discrete Case) —— 以“掷骰子”为例

如果 $X$ 是离散的，它取第 $i$ 个值 $x_i$ 的可能性记为 $p_i$ 。这里的$p_i$有两个硬性条件：

非负性：$p_i \ge 0$（概率不能是负数）。
归一化：$\sum_{i=1}^{n} p_i = 1$（所有可能性的概率加起来必须等于 1，也就是必然会发生某件事）。

则对于掷骰子来说，每个面朝上的概率是相等的，即 $p_i = 1/6$

期望 (Expected Value)

期望可以理解为平均值。如果你不断地从分布中抽取样本，最终得到的平均结果就是期望。

$$ E[X] = \sum_{i=1}^{n} x_i p_i $$

即：（结果1 $\times$ 概率1）+（结果2 $\times$ 概率2）…

则在例子掷骰子中会发生这种情况：虽然骰子只有整数点数，但其期望是：

$$ E[X] = 1 \cdot \frac{1}{6} + 2 \cdot \frac{1}{6} + \dots + 6 \cdot \frac{1}{6} = 3.5 $$

虽然你永远掷不出 3.5 这个点数，但“3.5”代表了掷很多次后的平均结果。

【Games101】辐射度量学与全局光照

古月月仔 — Sun, 07 Dec 2025 00:00:00 +0800

辐射度量学为计算机图形学提供物理正确的光照计算基础，通过定义辐射能量、通量、立体角和辐射强度等物理量，使渲染结果从“看起来像”转变为“物理正确”，是通往路径追踪等高级渲染技术的基石。

先导

“光到底是什么？”

这是为了回答一个你在写 Blinn-Phong 模型代码时可能产生的终极疑问：“我的光照强度设为 10，但这个 10 到底是什么单位？是 10 个灯泡？还是 10 个太阳？”

如果没有这套物理系统，Whitted-style 光线追踪的结果永远只是“看起来像”，而不是“物理正确” 。

为什么要学辐射度量学 (Radiometry)？

辐射度量学是一套精确测量电磁辐射（包括光）空间属性的系统。它引入了一系列物理量（如辐射通量、强度、辐照度、辐射亮度），让我们能够以物理正确的方式进行光照计算。

在此之前的渲染器就像是在画画，颜色深浅全凭感觉调参数（比如 float intensity = 10.0）。学完这部分后，你的渲染器将变成一台照相机。每一个像素的颜色值，都对应着真实物理世界中打到底片上的能量数值。这是通往路径追踪 (Path Tracing) 的必经之路。

基础概念

能量与通量

**辐射能量 (Radiant Energy, $Q$)**定义为：电磁辐射的能量。其单位是焦耳 (Joule, $J$) 。

Tip

说人话：就像水池里蓄的总水量。但在图形学中我们很少直接用它，因为光通常是持续不断的。

**辐射通量 / 功率 (Radiant Flux / Power, $\Phi$)**定义为：单位时间内发射、反射、传输或接收的能量。其公式表达为：

$$ \Phi \equiv \frac{dQ}{dt} $$

其单位为：瓦特 (Watt, $W$) 或流明 (Lumen, $lm$)

Note

上述两个概念可以通俗理解为：光子流。想象光是水流。能量 ($Q$) 是这一盆水有多少。通量 ($\Phi$) 是水龙头的流速。单位时间流出来的光子越多，这盏灯就越“亮”。比如一个 60W 的灯泡，这个“瓦数”描述的就是它的 Flux（虽然电功率和光功率有转换效率问题，但概念类似）。

立体角 (Solid Angle，$\Omega$)

平面角与立体角

【算法刷题】排序算法总结

古月月仔 — Sat, 06 Dec 2025 00:00:00 +0800

本文整理了冒泡排序和选择排序的算法笔记。冒泡排序通过相邻元素交换实现排序，时间复杂度O(n²)，稳定且原地排序。选择排序通过选择最小元素放置到已排序末尾完成排序。

Tip

近来准备重拾刷题的习惯，为就业早做准备，刚好把之前学过的算法笔记顺带整理一下，理一遍思路，夯实基础。

基础算法 (Basic Algorithms)

冒泡排序 (Bubble Sort)

动图

核心思想：重复交换相邻的逆序元素，使最大/小值如气泡般“浮”到顶端。
时间复杂度：O(n²) (平均 & 最坏)
关键特性：稳定、原地排序、最简单但效率最低。

来道例题：5334. 冒泡排序 - AcWing题库

cpp





//示例代码
void Bubble_Sort(int arr[], int len)
{
 for(int i = 0; i < len - 1; i++)
 {
 // 每一轮将最大的元素“冒泡”到末尾
 for(int j = 0; j < len - 1 - i; j++)
 {
 if(arr[j] > arr[j + 1])
 {
 swap(arr[j], arr[j + 1]);
 }
 }
 }
 return;
}

Note

个人认为在冒泡排序中最重要的点是，要理解其核心操作是两两对比

每次比较相邻的两个元素

如果顺序错误就交换，让较大的元素“冒泡”上浮

每一次得到一个相对最大(小)值移动到队尾，然后在下一次循环时就不必考虑该值，从而逐步缩小范围。

每轮结束后，当前最大元素一定“沉”到最后

下一轮只需比较前面 n-1 个元素，再下一轮比较 n-2 个…

这正是代码中 j < n-1-i的原因

选择排序 (Selection Sort)

img

【Games101】光线追踪基础Ray-Tracing

古月月仔 — Thu, 04 Dec 2025 00:00:00 +0800

阴影贴图是光栅化渲染中生成阴影的主流技术。其核心思想是：一个点被照亮需同时被相机和光源可见。算法分为两步：首先从光源视角渲染生成记录最近距离的深度图；然后在相机视角渲染时，将每个点投影回光源视角，对比其实际距离与深度图记录值，以判断该点处于光照还是阴影中。

要讲述光线追踪，首先需要先引入之前的光栅化中的一个内容–阴影贴图

先导

阴影贴图 (Shadow Mapping)

为什么需要 Shadow Mapping？

在光栅化渲染中，我们通常是一个三角形一个三角形地画，很难直接知道“谁挡住了谁”从而产生阴影。为了解决这个问题，我们引入了 Shadow Mapping。

定位：这是目前最主流的阴影生成技术，从早期的《玩具总动员》到《塞尔达传说：荒野之息》、《超级马里奥：奥德赛》等现代游戏都在使用。
本质：它是一种图像空间 (Image-space) 的算法。这意味着它依赖生成的图像（深度图）来计算，而不需要一直纠缠于复杂的场景几何数据。

image-20251204170440998

Shadow Mapping 的核心思想非常朴素，只有一句话：

如果一个点不在阴影里，那么它必须能同时被“摄像机”和“光源”看到。

如果不被阴影覆盖（也就是被照亮），说明那个点既能被你的眼睛（相机）看见，也能被头顶的太阳（光源）直接照射到。如果那个点被太阳“看不见”（中间有障碍物挡住了），那它就在阴影里。

图片7

算法流程：经典的“两步走” (2-Pass)

Shadow Mapping 之所以叫 Mapping，就是因为它需要生成一张图（Map）。整个过程分为两次渲染：

【博客魔改】Butterfly 主题配置 Giscus 评论系统

古月月仔 — Wed, 03 Dec 2025 00:00:00 +0800

本文介绍了为Hexo博客的Butterfly主题配置Giscus评论系统的详细步骤。Giscus是一个基于GitHub Discussions的免费评论工具，无需自建服务器。配置过程主要包括：创建公开的GitHub仓库并启用Discussions功能，安装Giscus应用，最后在配置页面生成并获取必要的代码片段。

Tip

最近把很多老博客整理搬运到hexo上面的时候，突然发现自己的博客还没有配置评论系统，刚好前两天刷到一个Giscus官方教程，个人用了也觉得确实是很好用，索性搬来配置到博客上去了，顺带水篇博客记录一下，方便后续主题修改后重新配置。

Giscus简介

Giscus 是一个基于 GitHub Discussions 的评论系统，完全免费、无需服务器、数据存储在 GitHub 仓库中。本指南详细介绍如何为 Hexo Butterfly 主题配置 Giscus。

Giscus 使用 GitHub Discussions 作为数据库存储博客下面的评论。

Giscus 插件加载时，会使用 GitHub Discussions 搜索 API 根据选定的映射方式（如 URL、pathname、等）来查找与当前页面关联的 discussion。如果找不到匹配的 discussion，giscus bot 就会在第一次有人留下评论或回应时自动创建一个 discussion。

如果要评论，访客必须按 GitHub OAuth 流程授权 giscus app 代表他发帖。或者访客也可以直接在 GitHub Discussion 里评论，作者可以在 GitHub 上管理评论。

Giscus配置

第一步：创建 GitHub 仓库

登录 GitHub，点击右上角 +→ New repository
填写仓库信息：Repository name: 例如 blog-commentsVisibility: 必须选择 Public（公开）
点击 Create repository

第二步：启用 Discussions 功能

进入仓库页面 → 点击 Settings选项卡
左侧菜单选择 General
向下滚动到 Features区域
勾选 Discussions 复选框
点击 Save changes

image-20251203140248796

【博客魔改】Hexo添加 Github alerts 支持

古月月仔 — Wed, 03 Dec 2025 00:00:00 +0800

Tip

一直很喜欢 Github 上的 Alerts 书写格式，非常简洁快捷，比hexo各类主题带的外挂标签方便很多，然后发现现在用的 hexo 主题并不支持解析该格式的语法。

给个示例：

markdown

> [!NOTE]
> 这是一个注意事项提示框。这种提示框通常用于展示一般性的提示信息。

通过简单的引用加调用预设语法既可以写出好看的外挂标签的效果：

Note

这是一个注意事项提示框。这种提示框通常用于展示一般性的提示信息。

参考Hexo 美化：添加 Github alerts 支持 | Dogxi 的狗窝的博客做了一点魔改，在此记录一下，方便自己后续潜移修改。

配置步骤

1. 更换 Markdown 渲染器

Hexo 默认的 marked渲染器不支持此语法，需要更换为 markdown-it：

bash

# 卸载默认渲染器
npm uninstall hexo-renderer-marked --save

# 安装 markdown-it 渲染器
npm install hexo-renderer-markdown-it --save

2. 创建解析脚本

在 Hexo 根目录创建脚本文件：scripts/github-alerts.js

javascript





// GitHub Alerts 解析脚本
hexo.extend.filter.register('markdown-it:renderer', function (md) {
 md.core.ruler.after('block', 'github-alert', function (state) {
 const tokens = state.tokens
 for (let i = 0; i < tokens.length; i++) {
 if (tokens[i].type === 'blockquote_open') {
 // 找到 blockquote 的内容
 let j = i + 1
 // 只处理第一个段落
 if (
 tokens[j] &&
 tokens[j].type === 'paragraph_open' &&
 tokens[j + 1] &&
 tokens[j + 1].type === 'inline'
 ) {
 let content = tokens[j + 1].content.trim()
 // 兼容 [!NOTE]、[!NOTE]<br>、[!NOTE]\n
 const match = content.match(
 /^\[!(NOTE|WARNING|TIP|IMPORTANT|CAUTION|INFO|SUCCESS|ERROR)\][\s:：-]*(.*)$/i,
 )
 if (match) {
 const alertType = match[1].toLowerCase()
 let restContent = match[2].trim()

 // 给 blockquote_open 加 class
 let className = tokens[i].attrGet('class') || ''
 className += (className ? ' ' : '') + `alert alert-${alertType}`
 tokens[i].attrSet('class', className)

 if (restContent) {
 // [!NOTE] 和内容在同一行
 tokens[j + 1].content = restContent
 } else {
 // [!NOTE] 单独一行，移除该段
 tokens.splice(j, 3)
 }
 }
 }
 }
 }
 })
})

3. 创建样式文件

在 source/css/github-alerts.css创建样式文件：

【C++】复数类与字符串类

古月月仔 — Tue, 02 Dec 2025 00:00:00 +0800

本文以Complex类为例，介绍了C++程序的基本结构，包括头文件与实现文件的分离、防御性声明、命名空间的使用，以及inline函数的定义方式与注意事项。

C++ programs 代码的基本形式(以Complex class为例)

头文件与类声明

在写C++项目时,一般将类声明和实现分为两部分存储,即.h和.cpp文件中..cpp文件中要包含#inlcude他的声明头文件

Warning

在.cpp文件中,自己的头文件一般用引号,而引用标准库文件则用尖括号:
c++
#include<iostream.h>
#inlcude'complex.h'

头文件的防御性声明

在大型项目中,一个写好的类声明文件可能会被引用到程序的各个部分,而有一种规范安全的写法可以解决程序四处引用导致类重复声明的问题

示例:

cpp

#ifndef _COMPLEX_
#define _COMPLEX_
...
#endif

namespace命名空间

namesapce主要的用途是免去每个函数之前都加一个类名,举个栗子:

cpp





//使用命名空间
#include<iostram>
using namespace std;
int main()
{
 cin<<...;
 cout<<...;
 return 0;
}
//使用更加具体的命名空间
#include<iostram>
using namespace std::cout;
int main()
{
 std::cin<<...;
 cout<<...;
 return 0;
}
//不使用命名空间
#include<iostram>

int main()
{
 std::cin<<...;
 std::cout<<...;
 return 0;
}

inline方式书写类

对于某一个C++类,我们可以将其声明和定义直接写在一起(就是像C语音中一串写下来一样),示例:

c++





class complex
{
public:
 complex(double r=0,double i=0)
 : re(r),im(i)
 {
 ....
 }
 complex& operator +=(const complex&);
 double real() const{return re;}
 double imag() const{retrun im;}
private:
 double re,im;
 friend complex&_doapl(complex*,const complex&);
};

像如上内容中,在类定义中直接将函数具体实现写在{...}中就是inline写法

【ComfyUI】批量生成自动化

古月月仔 — Mon, 01 Dec 2025 00:00:00 +0800

作者针对YOLO项目数据不足的问题，利用ComfyUI进行数据增强。由于官方批量功能不适用，他通过导出工作流API并编写Python脚本，实现了本地批量图片的自动化处理，高效生成训练所需的一对一对应图像数据。

之前玩一个yolo项目的时候碰上了数据不足训练结果很差的问题，刚好现在AI生图这么发达，而自己之前有摸索过一点使用ComfyUI生图的工作流，索性开始用ComfyUI开始造数据。ComfyUI本身是支持多批次生成功能的。设置次数后可以反复运行该工作流，但是官方提供的这个更多是面向同一提示词、不同随机种子抽卡情况的。

image-20251201204323062

我造数据需要的工况则是：

N张图片经过工作流处理生成N张图片,每对图片一一对应

显然和官方提供的方法不太匹配，中间也找了几篇博客，有的是提供了批量加载图片节点，配合工作流的一个循环（LoopStart和LoopEnd）去实现的，个人尝试了一下发现其限制很大，每次限制加载100张，而且循环的逻辑很难用，还会出现重复加载的问题，只能算是面向非程序人员的解决方案了。

Load Images For Loop文章图片

还有些方法就是使用第三方的平台或者插件等调用API，该方法的解决问题是很不错的。这里留一个链接方便以后查找快速开始 - EasyAI在线文档。但是感觉我就很简单一个需求，完全没必要用这么复杂的东西，索性自己配合GPT整理了一个脚本，用于本地的Image2Image的工作流批量运行.

ComfyUI导出工作流为API

要注意在保存导出为API之前，工作流中的预览图片节点要尽量去除，节省算力，同时要保证该工作流是确实可用的，可以运行出图的。

image-20251201210839690

【论文阅读】ViewDiff：基于文生图模型的3D一致图像生成技术

古月月仔 — Tue, 04 Nov 2025 00:00:00 +0800

CVPR 2024论文ViewDiff提出了一种新方法，利用预训练的文生图扩散模型生成高质量且多视角一致的3D图像，旨在克服现有方法在真实感和视角一致性上的不足。

大家好，我今天要分享的内容是ViewDiff 基于文生图模型的3D一致图像生成技术，是CVPR2024的一篇论文。

论文原址：https://lukashoel.github.io/ViewDiff/

image-20251104112946823

背景

近年来生成式人工智能(artificial intelligence generated content, AIGC)重新定义了视觉内容的生成、制作和编辑过程, 特别是自从扩散模型LDM（Latent Diffusion Model）和DiT (Diffusion Transformer)架构发布以来，由这两个架构所衍生的Stable Diffusion社区生态带来了AIGC领域的一片繁荣。

最近国内常提起的豆包修图和Nannobanana也是基于上述的DIT框架。

image-20251104112253545

【AIGC】生图模型概念&模块宗述

古月月仔 — Wed, 22 Oct 2025 00:00:00 +0800

文章概述了生成式AI在视觉内容领域的演进，从早期算法到VAE和GAN，再到当前主流的扩散模型，分析了其核心思想与特点，并指出AIGC正向更高分辨率、更丰富内容和更可控的方向发展。

随着人工智能以空前的速度不断发展, 生成式人工智能(artificial intelligence generated content, AIGC)重新定义了视觉内容的生成、制作和编辑过程, 彻底改变了我们感知和创造视觉内容的方式.

早期算法通常使用图像匹配或人工设计的生成规则合成简单的纹理或结构; 随后, 深度学习时代提出变分自编码(variational auto-encoder, VAE)和生成对抗网络(generative adversarial net work, GAN), 它们能够学习如人像、室内场景等典型的图像分布; 当前,涌现出了大型的扩散模型来生成图像和更具挑战性的视频, 其生成的质量之高甚至是人也难以区分真假. 从传统算法到 VAE 和 GAN, 再到扩散模型, AIGC 正在向更高分辨率、更丰富内容和更可控的生成方向演变.

图像生成模型架构和图像生成数据集的发展概览

图像生成模型

目前主流的图像生成模型大致可以分为以下四类：

模型类型	代表模型	核心思想	特点
GAN（生成对抗网络）	StyleGAN、BigGAN、CycleGAN	生成器与判别器对抗训练	图像质量高，但训练不稳定，控制性差
VAE（变分自编码器）	VQ-VAE、DALL-E 1	编码为潜在变量再解码	稳定性好，但图像模糊，细节差
Diffusion（扩散模型）	Stable Diffusion、DALL-E 2/3、Imagen	去噪过程生成图像	图像质量高，控制性强，训练成本高
自回归模型	Parti、ImageGPT	像语言模型一样逐像素/块生成	可扩展性强，但生成速度慢

图像生成与编辑模型分类

【LLM应用开发】N8N搭建一个接入Notion的自动化工具

古月月仔 — Tue, 30 Sep 2025 00:00:00 +0800

本文提供Notion API上传小文件的官方文档和视频教程链接，帮助开发者将文件附加到数据库页面。

参考文献||技术文档||视频教程

https://www.youtube.com/watch?v=MwudPf0dz5k

https://developers.notion.com/docs/uploading-small-files#example-attach-a-file-property-to-a-page-in-a-database

【LLM应用开发原理】Transformer架构宗述

古月月仔 — Tue, 30 Sep 2025 00:00:00 +0800

NLP 技术从传统统计方法演进至神经网络，Word Embeddings、RNN/LSTM 等模型逐步发展。Transformer 凭借自注意力机制实现突破，成为里程碑，并催生了 BERT、GPT 等变革性模型。

博文背景

之前在学习大模型相关技术的时候，看了很多篇对 Transfomer 解释的博客，但是感觉总是理解不透彻，不久之后就忘掉了，打算自己整理输出一下，以便更好的理解。

Transformer 的来源

2017 年，Google 团队在论文《Attention Is All You Need》中提出 Transformer，它完全摒弃递归结构，引入 自注意力机制（Self-Attention），实现了全局上下文感知与并行计算的平衡，成为 NLP 乃至深度学习领域的里程碑。Transformer 是 NLP 技术的一次革命性突破。与 RNN 和 LSTM 不同，Transformer 摒弃了序列数据的顺序处理方式，转而采用 自注意力机制（Self-Attention），使得每个单词都能够直接与其它所有单词进行交互，从而提高了计算效率，并能捕捉更复杂的依赖关系。

Trasnformer架构

BERT

BERT（Bidirectional Encoder Representations from Transformers）是基于 Transformer 的预训练模型，通过在大规模文本上进行双向预训练，BERT 能够更好地理解文本的上下文信息。BERT 的出现彻底改变了 NLP 模型的训练方法，许多 NLP 任务通过 迁移学习，即先在大规模语料上预训练，再在具体任务上微调，取得了显著的效果提升。

GPT

GPT（Generative Pre-trained Transformer)系列是由 OpenAI 提出的基于 Transformer 架构的生成模型。与 BERT 的“编码器”结构不同，GPT 采用了“解码器”结构，专注于生成任务，如文本生成、翻译、问答等。

【LLM应用开发原理】RAG是什么详解

古月月仔 — Sat, 13 Sep 2025 00:00:00 +0800

RAG（检索增强生成）通过构建知识库和智能检索机制，为AI模型精准提供外部信息，解决大模型知识过时和幻觉问题。它避免了昂贵的模型重训练，克服了直接输入长文本的低效性，是实现高效、准确AI应用的关键技术。

RAG基本概念

一个简单的RAG案例

许多纯小白对于大模型和RAG可能并没有一个具体的概念，现以下面的的简单案例介绍以下：

image-20250914114138671

想象一下，你开了一家网店，生意越来越火，客服消息回不过来了。你听说现在AI很厉害，于是买了一个基于“Deepseek”大模型的AI客服机器人。

第一天上线，你就发现了问题：

顾客问：“你们最新款的iPhone 16什么时候预售？”

AI客服答得头头是道，但内容却是基于去年的iPhone 14。因为它的大脑（Deepseek）训练数据只更新到2023年底，它根本不知道2024年发布的iPhone 16！

顾客问：“你们店独家定制的那款‘星空杯’用什么材料？能进微波炉吗？”

AI客服开始胡编乱造，因为它的大脑里完全没有你家私域产品的任何信息。

这时候，你该怎么办？

方案一：给AI大脑“重新上学”？——成本太高！

最直接的想法是：我把自家所有的产品手册、最新政策都整理成教材，让这个AI大脑（Deepseek）重新学习一遍，不就行了？

但这相当于送它去读一次“考研冲刺班”，代价极其高昂：

烧钱：训练一次大模型，需要大量的顶级显卡和算力，费用可能是几十万甚至上百万。
费时：训练过程漫长，等你训练好了，可能最新的促销活动又变了。
不通用：难道每个店家都要为了自己的产品，单独训练一个“专属大脑”吗？这太不现实了。

结论：让模型重新学习，此路不通。

方案二：把说明书当“小抄”递给AI——聪明但有限！

我们又想出一个巧妙的办法：我不改变AI的大脑，每次它回答问题的时候，我都把厚厚的产品说明书像“小抄”一样塞给它看，让它照着抄总行吧？

这个方法叫 “提示词工程” ，确实有用！但马上遇到了新麻烦：

“小抄”太长了：你的产品库有成百上千件商品，说明书加起来有几十万字。AI的“短期记忆”（上下文窗口）是有限的，一次看不完这么厚的“小抄”。
“抄”得太慢：每次都要处理海量文本，AI反应会变得非常慢，顾客等不及就走了。
“抄”串行：信息太多太杂，AI可能会看花眼，把A产品的功能安到B产品上，开始胡说八道（术语叫“幻觉”）。

结论：直接塞“小抄”，效率低，效果差。

终极方案：给AI配一个“超级秘书”（RAG）

既然“小抄”太长，那我们能不能做一个智能摘要，每次只把“小抄”里最相关的那一页精准地抽出来递给AI呢？

当然可以！这套完美的解决方案，就叫做 RAG（检索增强生成）。

你可以把它想象成给AI配了一个无所不知的“超级秘书”。这个秘书有两大本领：

1. 预处理：把厚书拆成单页（知识库切片）

首先，秘书会把你们店厚厚的所有产品说明书、客服话术、最新活动文件（我们称之为 “知识库”），全部拆解。

她不会粗暴地一撕两半，而是有逻辑地拆：按章节、按段落、按产品型号，拆成一个个大小适中、意思完整的小片段（Chunk）。
比如，关于“iPhone 16”的配置、价格、预售政策，会被整理成不同的卡片页。
这一步解决了“小抄太长”的基础问题。

2. 智能检索：建立超级索引（向量化检索）

接着，秘书会做一个谁也做不到的绝活：她给每一页“知识卡片”都生成一个独一无二的“数学指纹”（向量），并把这些指纹和卡片一起存进一个超级快的“智能档案柜”（向量数据库）里。

这个“数学指纹”的神奇之处在于：意思相近的内容，指纹也相似。
当顾客提问：**“iPhone 16预售政策是什么？”**秘书会瞬间分析这个问题，生成一个问题的“指纹”。然后她转身在“智能档案柜”里进行指纹匹配，一秒内就从几十万张卡片中，精准地找出那几张关于“iPhone 16预售政策”的卡片。这个过程，就相当于从一本厚厚的书中，瞬间精准地翻到了你最需要的那一页。 这就是对海量知识的“智能压缩”和“精准切片”。

3. 协同工作：秘书递纸条，AI来回答

【Games101】几何表达与绘制

古月月仔 — Sat, 05 Jul 2025 00:00:00 +0800

几何是计算机图形学中三维建模与渲染的基础，应用于物体建模、几何变换和碰撞检测等领域。其表示方法主要分为隐式表示（如代数曲面、水平集和距离函数）和显式表示，用于描述不同复杂度的形状。

几何概念

Tip

个人感觉本章前面的内容有点空洞和理论，建议直接快速浏览，从几何处理部分看起。

几何的应用（Applications of Geometry）

在图形学中，几何不仅仅关乎抽象的数学对象，它是三维建模和渲染的基础。以下是几何学的几个应用领域：

物体建模：通过几何学，计算机可以表示任何形状，例如从简单的几何体（如球体、立方体等）到复杂的自由形状（如汽车、人物模型等）。

几何变换：在渲染和动画中，物体的形状需要根据不同的需要进行变换，例如平移、旋转、缩放等。这些变换都可以通过几何学的运算来实现。

碰撞检测：几何学还用于物理引擎中的碰撞检测，确保虚拟世界中的物体不会穿透或重叠。

一些几何学应用

几何表示（Representations of Geometry)

隐式表示（Implicit Representations）

隐式表示并不是直接通过列举点或多边形来描述物体的表面，而是通过某个数学方程或函数来定义物体的几何形状。隐式表示方法通过一个方程或函数来表示物体表面上的所有点。这些函数通常被用来定义物体的边界或表面。

代数曲面（Algebraic Surfaces）

代数曲面

代数曲面是通过代数方程来描述物体的形状。最简单的例子是球体，它可以通过方程 $x^2 + y^2 + z^2 = r^2$ 来表示。这种表示方法非常直观，适合表示对称性较好的几何形状，但对于复杂图形无能为力。

【Games101】纹理映射与着色

古月月仔 — Thu, 03 Jul 2025 00:00:00 +0800

纹理是计算机图形学中用于增强模型表面细节的二维图像或数据贴图。通过纹理映射技术，结合UV坐标系和重心坐标插值，可将纹理贴合到三维模型表面，提供颜色、法线等丰富信息，提升视觉真实感。

什么是 Texture？

纹理（Texture） 是计算机图形学中用于增强图像细节和真实感的图像或数据贴图。它本质上是一种二维（通常是图片）或多维数据，常用于为图形表面提供颜色、法线、反射、透明度等信息。结合我们上节课提到的 布林-冯反射模型（Blinn-Phong Reflectance Model），纹理可以在漫反射部分表现不同的模型颜色，通过将纹理映射到表面，提供更加丰富的视觉效果。

纹理作为图形表面上的“贴图”，通常是二维图像，但在某些情况下，也可以是多维数据，用来提供表面的额外信息，增强其细节。

在 布林-冯反射模型 中，纹理主要用于模拟漫反射光照效果（即表面反射的光线分布），使得物体表面看起来更加自然和复杂。例如，在一个物体表面的漫反射部分，纹理可以通过控制不同区域的颜色和明暗，进一步模拟表面材料的特性。

包含了多种反射的示例

纹理映射（Texture Mapping）

纹理映射是一种将二维纹理图像（通常为位图）“贴”到三维模型表面的方法，目的是在不增加几何体复杂度的前提下，为三维物体提供更细致的视觉效果。通过纹理映射，物体表面可以拥有丰富的颜色、图案、细节等信息，而不需要额外的多边形面片。

地球仪表面展开

如上图所示：3D物体的表面其实都是2D的，比如地球仪，将地球仪上的图撕下来，可以平铺成一张2D的图物体的表面，通过这种方式可以和一张图有一一对应的关系，这张图就叫纹理，将这张图平铺/裁剪/拉伸到任何物体表面，就叫纹理映射，纹理上的坐标系通常以UV来表示。

UV坐标系

UV 坐标系统：这是一种标准的坐标系统，用来描述如何将纹理与物体表面的几何形状进行对应。纹理坐标的值通常在 [0, 1] 范围内：

U 是纹理图像的水平方向坐标，类似于 x 轴；
V 是纹理图像的垂直方向坐标，类似于 y 轴。

每个顶点都被赋予一个 (U, V) 坐标，当渲染时，图形管线会根据这些坐标从纹理图像中提取颜色信息。屏幕上的采样点（x,y）可以用重心坐标算出在纹理中采样的uv，得到对应纹理。

【Games101】着色基础

古月月仔 — Tue, 01 Jul 2025 00:00:00 +0800

Shading是图形学中模拟光线与物体表面交互，计算颜色和明暗的技术。其核心包括局部着色模型，以及漫反射、镜面高光和环境光等基础光照现象的模拟，以实现逼真的视觉效果。

Shading是图形学中决定物体表面外观的关键技术，它模拟光线与物体表面的交互过程。

什么是Shading？

Shading是指计算物体表面颜色和明暗的过程，通过模拟光线与材质相互作用来产生逼真的视觉效果。

局部着色（Shading is Local）

光线与着色点

局部着色定义为：计算特定着色点处反射到相机的光线

其关键要素一般为：l 光线照射方向向量，n 着色点表面法向量，v 观察视角方向，以及一个关键的表面参数（比如颜色color，光泽度shininess）

基础光照现象

三种不同的Shading类型

如上图所示，**镜面高光（Specular highlights）**在杯口和把手转折处形成明亮的聚焦光斑，体现了光滑表面对光源的直接反射；**漫反射（Diffuse reflection）**在杯身侧面形成均匀的色彩渐变，如淡绿色杯子柔和的明暗过渡，反映了朗伯体表面的均匀散射特性；**环境光（Ambient lighting）**则使背光面（如棕色杯子底部）保持基础可见性，代表间接光照的简化模拟。

漫反射与兰伯特余弦定律（Lambert’s Cosine Law）

漫反射

【Games101】光栅化基础

古月月仔 — Sun, 29 Jun 2025 00:00:00 +0800

光栅化是将几何图元（如三角形）转换为屏幕像素的核心渲染过程，涉及视口变换等步骤，并依托于CRT、LCD、OLED等显示设备最终成像。

什么是光栅化？

光栅化是 将几何图元（如三角形、线段）转换为屏幕上的像素（或片元）的过程，是实时3D渲染的核心步骤。它通过计算图元覆盖的像素区域，并插值顶点属性（颜色、深度等），最终生成可供显示的2D图像。

光栅化转化为像素点

显示器模型

图形学中，屏幕就认为是一个装了像素的二维数组。如数组大小1920*1080，每个数组为一个像素点，像素是最小单位，每个像素由RBG的四维矩阵构成。

显示器简化模型

如上图所示像素的坐标以左下角为准，如图中蓝色像素坐标为（2，1）

像素的中心为（x+0.5,y+0.5）

视口变换

在进行了上节课的透视投影变换操作之后，所有物体都处在了[-1，1]³的立方体中，接下来就要把他画在屏幕上。

透视投影变换

【Games101】变换基础概念

古月月仔 — Fri, 27 Jun 2025 00:00:00 +0800

计算机图形学中的基本变换包括缩放、镜像、错切和旋转，每种变换都可通过特定的数学矩阵来描述物体在二维空间中的位置、大小和方向变化。

变换Transformation是计算机图形学中的基础概念，用于描述和操作物体在二维或三维空间中的位置、方向和大小。

变换概念

基本变换类型

缩放变换（Scale）

对称缩放

如图所示的坐标轴内物体缩放，其数学变换公式为: $$ \begin{aligned} x' &= s \cdot x \\ y' &= s \cdot y \end{aligned} $$ 矩阵格式表述为: $$ \begin{bmatrix} x’ \ y' \end{bmatrix}

\begin{bmatrix} s & 0 \ 0 & s \end{bmatrix} \begin{bmatrix} x \ y \end{bmatrix} $$ 而以此推广为非对称缩放变化:

【Games101】图形学概述与数学基础

古月月仔 — Tue, 24 Jun 2025 00:00:00 +0800

计算机图形学是研究计算机中图形表示、生成、处理和显示的交叉学科，其核心内容包括图形表示、生成、处理与显示，并与计算机视觉、图像处理等学科紧密关联。学习图形学需要掌握线性代数基础，如向量的点乘、叉乘及矩阵运算。

基本概念

CG与真实拍摄

计算机图形学是什么？

计算机图形学(Computer Graphics)是研究如何在计算机中表示、生成、处理和显示图形的学科。它结合了数学、物理学、计算机科学和艺术等多个领域的知识，致力于解决如何在计算机上创建和操作视觉内容的问题，其最直观的用途包括如下四个方面。

图形表示：研究如何在计算机中表示2D和3D图形对象
图形生成：如何从模型数据生成可视图像
图形处理：对已有图形进行变换、编辑和优化
图形显示：如何将生成的图形高效地显示在输出设备上

图形学(CG)与其他学科的关系

计算机视觉(CV)：图形学是"从模型到图像"，计算机视觉是"从图像到模型"
图像处理：图形学绘制（渲染）图像，图像处理修改已有图像
计算几何：提供图形学所需的几何算法
人机交互：图形学为HCI提供可视化界面

为什么要学图形学？

因为图形学很酷！

图形学很酷

线性代数基础

向量的点乘（Dot Product）

两个向量的点乘结果是一个标量

$$ \vec{a} \cdot \vec{b} = \|\vec{a}\| \|\vec{b}\| \cos\theta $$

几何意义：

【C++】C++中的设计模式

古月月仔 — Thu, 01 May 2025 00:00:00 +0800

设计模式是针对软件设计中反复出现问题的通用解决方案，其核心在于提升代码复用性，避免重复劳动。

什么是设计模式

引用**克里斯托弗·亚历山大（Christopher Alexander）**在1977年的著作《A Pattern Language: Towns, Buildings, Construction》中提出了关于设计模式的经典定义。

英文原版：

“Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.” — Christopher Alexander, A Pattern Language, 1977

中文翻译：

“每一个模式描述了一个在我们环境中反复出现的问题，并描述了该问题解决方案的核心。通过这种方式，你可以无数次地使用该解决方案，而无需以相同的方式重复两次。”

说人话就是:不需要重复造轮子

推荐一本历史性著作《设计模式:可复用面相对象软件的基础》

设计模式:可复用面相对象软件的基础

3D生成AI学习笔记（一）：范式革命与管线全景图

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第一部分：开篇明义——3D生成AI的范式革命与管线全景图

1.1 传统3D内容制作管线拆解：一座精确到小时的工时金字塔

传统3D管线工时 vs AI辅助压缩对比

要理解3D生成AI带来的冲击，必须先理解传统3D内容制作管线的深度与复杂度。下面以影视级/3A游戏角色为基准，逐环节拆解。

1.1.1 高模雕刻：数字粘土的几何密度极限

定义层：高模雕刻（High-Poly Sculpting）是在计算机中使用数字笔刷对虚拟几何体进行增减材料的操作，目标是创建包含极高表面细节的三维数字原型，细节精度需达到毛孔、皱纹、织物纤维级别。

原理层：为什么需要数百万乃至数千万个多边形？因为真实世界的表面细节具有分形特征——当你不断放大，新的细节持续涌现。传统多边形建模无法高效表达这种不规则表面，而雕刻模式基于**细分曲面（Subdivision Surface）**技术，允许艺术家在低精度基网（Base Mesh）上操作，由算法实时细分生成光滑表面。法线烘焙（Normal Baking）的哲学前提是：人眼对表面朝向的变化极其敏感，但对 silhouette 边缘的 polygon 阶梯不敏感（在一定距离外）。因此，我们可以将高模的微观表面法线信息编码到一张法线贴图（Normal Map）中，施加到低模表面，在渲染时欺骗光照计算，获得接近高模的视觉效果。

实例层：在 ZBrush 中的典型流程为：导入基础人形（约 5,000-10,000 面）→ 使用 Dynamesh 动态重建均匀拓扑（解决拉伸问题）→ 逐级增加细分级别（Subdivision Levels，通常 4-7 级，最终可达 500万-2,000万有效面）→ 使用 Standard/Clay Buildup/Trim Dynamic 笔刷塑造体积 → 使用 Dam Standard/Orb Cracks 笔刷雕刻皱纹与破损 → 使用 NoiseMaker 或 Surface Noise 添加微观皮肤毛孔。一个影视级角色高模的纯雕刻工时通常为 2-5 天，复杂生物（如带鳞片的龙）可达 2 周。关键概念是多边形流（Polygon Flow）——即使在 Dynamesh 阶段不关注拓扑，艺术家仍需在心里规划肌肉走向，因为雕刻的细节分布必须遵循解剖学张力线。

3D生成AI学习笔记（三）：核心生成模型范式

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第三部分：核心篇（上）——3D生成模型的核心范式

3.1 基于体素与栅格的生成

3D生成四大范式对比

3.1.1 3D-GAN：深度卷积在三维空间的首次成功

三维生成对抗网络的早期探索中，3D Generative Adversarial Network (3D-GAN) 由 Wu 等人于 CVPR 2016 提出，是首次将深度卷积架构成功扩展到三维体素空间的开创性工作。其前身可追溯至 Goodfellow 等人 2014 年的原始 GAN 框架以及 3DShapeNets (Wu et al., CVPR 2015) 对三维形状的卷积编码器探索；其后续影响则体现在后续大量基于体素的条件生成模型（如 3D-VAE-GAN、PrGAN）以及隐式场方法中对三维卷积特征的处理。

完整架构：

3D-GAN 的生成器 $G$ 采用 5 层三维转置卷积（3D Transposed Convolution），将低维潜码 $\mathbf{z} \in \mathbb{R}^{200}$（从标准正态分布采样）映射到 $64 \times 64 \times 64$ 的占据体素网格：

$$ \mathbf{z} \sim \mathcal{N}(0, I), \quad G(\mathbf{z}) = \mathbf{o} \in [0,1]^{64 \times 64 \times 64} $$

生成器的逐层变换为：

3D生成AI学习笔记（二）：先修知识体系

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第二部分：筑基篇——不可或缺的先修知识

“如果你不知道数据是如何表示的，你就不知道模型在学什么；如果你不知道模型在优化什么，你就不知道它为什么会失败。”

3D生成AI是一个极度跨学科的领域。它要求研究者同时具备3D计算机图形学的几何直觉和深度学习的优化理论。本章的目标不是泛泛而谈，而是为后续所有技术细节打下数学上严谨、工程上可落地的基础。我们会从最底层的表示方法出发，逐步建立起连接图形学与深度学习的完整知识图谱。

2.1 3D计算机图形学基础

2.1.1 五种核心表示方法（重点中的重点）

3D核心表示方法总览

在3D生成AI中，表示（Representation）就是一切。神经网络最终输出的不可能是"一个物体"的抽象概念，它必须选择一种数学结构来编码几何与外观。不同的表示决定了：模型的架构设计、损失函数的构造、训练难度的量级，以及最终生成结果的用途。

多边形网格（Polygon Mesh）

精确数学定义

一个多边形网格是一个三元组 $\mathcal{M} = (V, E, F)$，其中：

顶点集合 $V = \{v_1, v_2, \dots, v_N\} \subset \mathbb{R}^3$；
边集合 $E \subset V \times V$，其中每条边 $e_{ij} = (v_i, v_j)$；
面集合 $F$，每个面 $f \in F$ 是顶点的一个循环子集。在计算机图形学中，我们几乎总是使用三角网格，即每个面恰好包含3个顶点：$f = (v_i, v_j, v_k)$。

一个网格是**流形（Manifold）**的，当且仅当每个点 $p \in \mathcal{M}$ 存在一个邻域 $U_p$，使得 $U_p$ 同胚于（homeomorphic to） either $\mathbb{R}^2$（内部点）或 $\mathbb{R}^2_{\geq 0}$（边界点）。直观地说，流形网格在局部看起来必须像一张纸或半张纸——不允许存在"三张纸在一个边上交汇"（非流形边）或"多张纸在一个点交汇"（非流形顶点）的情况。

3D生成AI学习笔记（五）：评估与验证

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第五部分：验证与评估篇——如何衡量生成结果的好坏？

在三维生成模型的研究与发展中，评估（Evaluation）绝非简单的"打分数"环节，而是整个科学方法论体系的基石。与二维图像生成领域存在 Fréchet Inception Distance（FID）这类虽不完美却已被广泛接受的"通用货币"不同，三维生成至今尚未形成单一的主导性指标。这种碎片化现状源于三维数据本身的异质性——同样的生成结果可以以体素、点云、网格、隐式场或神经辐射场（NeRF）的形式存在；也源于评估维度的多元性——几何精度、视觉保真度、拓扑正确性、物理合规性、语义对齐度与感知质量往往此消彼长，难以被压缩为一个标量。

本部分将从主观实验设计、客观指标体系的数学本质、指标间的内在冲突，以及下游任务驱动的功能性验证四个维度，建立一套方法论层面严谨、可复现且难以被操纵的评估框架。我们的核心论点是：一个好的评估协议必须同时是多维的（覆盖几何、视觉、语义、物理）、多视角的（避免单一渲染视角的偏差）、统计上严谨的（报告显著性与效应量），并与下游任务锚定的（functional correctness）。

5.1 主观评估

主观评估是三维生成结果评价中不可被客观指标完全替代的核心环节。原因在于，三维内容的最终受众是人类，而人类视觉系统对几何瑕疵、光照不协调和语义违和的敏感度，往往无法被现有的逐点距离度量所捕捉。然而，主观评估若设计不当，极易引入巨大的系统偏差与噪声，导致结论不可信。

5.1.1 用户研究设计方法

AB测试（Pairwise Comparison）

在三维生成评估中，AB测试（成对比较）是最可靠的主观评估范式之一。其基本实验设计为：被试在每次试验中观察由两个不同模型生成的三维结果（以旋转渲染视频或交互式视图呈现），并在强制选择（forced choice）或分级量表上做出判断。

统计模型：Bradley-Terry 模型

设共有 $M$ 个待比较的模型（或方法），每个模型具有一个潜在的感知质量分数（latent score）$\theta_i \in \mathbb{R}$。Bradley-Terry 模型假设模型 $i$ 在成对比较中击败模型 $j$ 的概率为：

$$P(i \text{ beats } j) = \frac{e^{\theta_i}}{e^{\theta_i} + e^{\theta_j}}$$

该模型可视为 Logistic 模型在离散选择场景下的特例。给定 $N$ 次独立观测，其中 $w_{ij}$ 表示模型 $i$ 击败模型 $j$ 的次数，对数似然函数为：

$$\ell(\boldsymbol{\theta}) = \sum_{i为避免尺度不可识别性，通常施加约束 $\sum_{i=1}^M \theta_i = 0$ 或固定 $\theta_1 = 0$。通过最大似然估计（MLE）求解 $\hat{\boldsymbol{\theta}}$，可获得各模型的全局排序。Fisher 信息矩阵 $\mathbf{I}(\boldsymbol{\theta})$ 可用于估计参数的标准误，进而构造置信区间。

3D生成AI学习笔记（六）：实战与前沿趋势

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第六部分：实战与趋势篇——动手路径与未来展望

6.1 核心开源框架详解

3D生成AI生态系统全景

在3D生成AI领域，框架的选择直接决定了实验的迭代速度和调试的便利程度。与2D视觉领域PyTorch和TensorFlow的二分天下不同，3D生成AI目前仍处在"工具链快速演化"的阶段。选择框架时，需要区分两个维度：一是神经渲染框架（负责从3D表示生成2D图像并反向传播梯度），二是生成式3D框架（负责调用2D先验或3D先验来优化3D表示）。nerfstudio属于前者，threestudio属于后者，而Kaolin和PyTorch3D则是更底层的几何操作基础设施。

6.1.1 nerfstudio

nerfstudio架构

nerfstudio是社区目前最成熟、工程化程度最高的NeRF训练与渲染框架。它并非单一算法的复现，而是一个模块化的NeRF研究平台。其设计目标是将NeRFpipeline中的各个组件（数据加载、场表示、采样策略、体渲染、后处理）彻底解耦，使得研究者可以通过修改YAML配置文件或继承基类的方式快速组合出新方法。

架构概览与源码导航

nerfstudio的目录结构反映了其严格的分层设计：

text





nerfstudio/
├── models/ # 模型定义，继承自Model基类
│ ├── base_surface_model.py # 表面模型（NeuS, VolSDF风格）的抽象基类
│ ├── instant_ngp.py # Instant-NGP的完整复现
│ ├── nerfacto.py # 推荐的默认模型，集成多技术
│ └── mipnerf.py # mip-NeRF 360实现
├── fields/ # 神经场表示，负责将空间坐标映射到密度/颜色/语义
│ ├── base_field.py
│ ├── instant_ngp_field.py # 哈希编码+小MLP
│ └── nerfacto_field.py # 基于哈希编码的NeRF场
├── model_components/ # 可复用组件，避免重复造轮子
│ ├── renderers.py # 光线行进积分器
│ ├── loss.py # MSE, Charbonnier, distortion loss等
│ └── ray_samplers.py # 均匀采样、重要性采样、PDF采样
├── data/ # 数据IO与预处理
│ ├── dataparsers/ # COLMAP, blender, polycam, nuscenes等
│ └── datasets.py # 内存映射与缓存策略
├── pipelines/ # 训练管线
│ └── base_pipeline.py # 定义train/val步骤和优化器配置
└── engine/ # 训练引擎，基于PyTorch Lightning封装
 └── trainers.py

关键设计哲学：models与fields的分离。models负责"策略"（如proposal sampling、损失组合、参数调度），而fields只负责"表示"（给定坐标，输出属性）。这种分离使得你可以将Instant-NGP的哈希编码场（instant_ngp_field.py）与mip-NeRF的抗锯齿采样策略组合，而不需要重写整个训练循环。

3D生成AI学习笔记（四）：后处理与生产管线

古月月仔 — Sun, 27 Apr 2025 00:00:00 +0800

第四部分：核心篇（下）——从生成到可用资产：后处理、优化与管线

工程级扩展版

4.1 网格提取与优化

AI生成的三维表示（隐式场、点云、NeRF密度场）必须经过网格提取和优化才能转化为游戏引擎或影视管线中的可用资产。本节从算法原理出发，结合生产管线中的实际问题，给出可直接落地的技术方案。

4.1.1 Marching Cubes的完全算法详解

Marching Cubes原理

Marching Cubes（MC）是隐式曲面网格提取的事实标准算法。在AI生成管线中，它通常作用于神经隐式场（如NeRF的密度场、NeuS的SDF或Instant NGP的占用网格）的离散采样结果，将其转化为可渲染的三角网格。

问题设置与算法流程

给定隐式场 $f: \mathbb{R}^3 \rightarrow \mathbb{R}$，目标是提取零水平集 $S = \{ x \in \mathbb{R}^3 \mid f(x) = 0 \}$ 的三角网格近似。在实际工程中，$f$ 可能是神经网络的输出，也可能是经过后处理的符号距离场（SDF）。

完整算法步骤：

体素化空间：在感兴趣区域（AABB）内建立规则体素网格，分辨率通常为 $N \times N \times N$（如 $256^3$ 或 $512^3$）。分辨率的选择是面数与精度的直接权衡：$256^3$ 对人物角色可能足够，但机械硬表面细节需要 $512^3$ 甚至更高。
角点采样：对每个体素的8个角点计算场值 $v_i = f(p_i)$。若使用神经网络，此步骤需要 $O(N^3)$ 次前向传播，是主要瓶颈。工程上常使用稀疏采样或缓存策略（如Instant NGP的哈希网格直接解码）。

【深度学习】常见的激活函数

古月月仔 — Thu, 30 Jan 2025 00:00:00 +0800

激活函数为神经网络引入非线性，使其能够学习复杂模式。它分为饱和与非饱和两类，前者如Sigmoid和tanh，后者如ReLU。使用激活函数可避免网络退化为线性模型，并解决梯度消失等问题，从而增强模型的表达能力。

激活函数（Activation Function）,是一种添加到人工神经网络中的函数，旨在帮助网络学习数据中的复杂模式。

img

什么是激活函数

在神经元中，输入的input经过一系列加权求和后作用于另一个函数，这个函数就是这里的激活函数。类似于人类大脑中基于神经元的模型，激活函数最终决定了是否传递信号以及要发射给下一个神经元的内容。激活函数为神经网络引入了非线性元素，使得网络能够逼近复杂的非线性函数，从而解决更广泛的问题。

为什么要使用激活函数

如果不用激活函数，每一层输出都是上层输入的线性函数，无论神经网络有多少层，输出都是输入的线性组合，这种情况就是最原始的感知机（Perceptron）。使用激活函数能够给神经元引入非线性因素，使得神经网络可以任意逼近任何非线性函数，使深层神经网络表达能力更加强大，这样神经网络就可以应用到众多的非线性模型中。

激活函数的分类

基于激活函数的本质，可以将激活函数分为以下两大类：

image-20250425155707483

饱和激活函数：Sigmoid、tanh……
非饱和激活函数：ReLU、LeakyRelu、ELU、PReLU、RReLU….

什么是饱和？

image-20250425155722212

反之，不满足以上条件的函数则称为非饱和激活函数。 Sigmoid函数需要一个实值输入压缩至[0,1]的范围 tanh函数需要讲一个实值输入压缩至 [-1, 1]的范围相对于饱和激活函数，使用非饱和激活函数的优势在于两点：

【机器学习】梯度下降与损失函数

古月月仔 — Mon, 20 Jan 2025 00:00:00 +0800

梯度下降是一种通过计算目标函数梯度并沿其反方向迭代调整参数以寻找最小值的优化方法。它利用导数、偏导数和方向导数等概念，在机器学习中常用于最小化损失函数，但可能收敛于局部最优解而非全局最优。

梯度下降（Gradient Descent GD）简单来说就是一种寻找目标函数最小化的方法，它利用梯度信息，通过不断迭代调整参数来寻找合适的目标值。

什么是梯度？

Gradient-Descent（全世界最通俗易懂的梯度下降法详解-优化函数大法）

关于梯度的引入，可以分为四个概念：导数->偏导->方向导数->梯度导数：当函数定义域和取值都在实数域中时，导数可以表示函数曲线上的切线斜率。

经典的导数与微分示意图

偏导数：偏导其实就是多元函数一个多变量的函数的偏导数是它关于其中一个变量的导数，而保持其他变量恒定。因为曲面上的每一点都有无穷多条切线，描述这种函数的导数相当困难。偏导数就是选择其中一条切线，并求出它的斜率。几何意义是表示固定面上一点的切线斜率。多元函数降维时候的变化，比如[二元函数]固定y，只让x单独变化，从而看成是关于x的[一元函数]的变化来研究。

这里写图片描述

但是偏导数有一个缺点，就是只能表示多元函数沿[坐标轴]方向的变化率，但是很多时候要考虑多元函数沿任意方向的变化率，于是就有了方向导数。 方向导数：某个方向的导数，本质就是函数在A点上无数个切线的[斜率]的定义，每个切线都代表一个方向，每个方向都是有方向导数的。

【OpenPCDet】PointPillar算法思路

古月月仔 — Tue, 31 Dec 2024 00:00:00 +0800

PointPillar 是一种用于三维物体检测的深度学习模型，尤其适用于激光雷达点云数据的处理。它的设计思想相对简洁，并且在保持高效性的同时能获得较高的精度。论文地址代码地址

前言

本文要解析的模型叫做PointPillars ，是2019年出自工业界的一篇Paper。该模型最主要的特点是检测速度和精度的平衡。该模型的平均检测速度达到了62Hz，最快速度达到了105Hz，确实遥遥领先了其他的模型。这里我们引入CIA-SSD 模型中的精度-速度图，具体对比如下所示。

Image

截止CIA-SSD论文发表前，PointPillars的检测速度都是遥遥领先的，而且精度也不低。现有的一些研究喜欢将不规则、稀疏的点云数据按照以下两种方式进行处理，然后引入RPN层进行3D Bbox Proposal，这两种方法为：

一种是将点云数据划纳入一个个体素（Voxel）中，构成规则的、密集分布的体素集。常见的有VoxelNet和SECOND；
另一种从俯视角度将点云数据进行处理，获得一个个伪图片的数据。常见的模型有MV3D和AVOD。 PointPillar模型采用了一种不同于上述两种思路的点云建模方法。从模型的名称PointPillars可以看出，该方法将Point转化成一个个的Pillar（柱体），从而构成了伪图片的数据。然后对伪图片数据进行BBox Proposal就很简单了，作者采用了SSD的网络结构进行了Proposal。

数据处理

PointPillar的一大亮点是将点云划分为一个个的Pillar，从而构成了伪图片的数据。如何构成这个伪图片呢？作者在论文中是给出了这样的图，如下。

Image

具体实现步骤如下：

按照点云数据所在的X，Y轴（不考虑Z轴）将点云数据划分为一个个的网格，凡是落入到一个网格的点云数据被视为其处在一个pillar里，或者理解为它们构成了一个Pillar。
每个点云用一个 $ D=9$ 维的向量表示，分别为 $(x,y,z,r,x_c,y_c,z_c,x_p,y_p)$。其中 $(x,y,z,r)$ 为该点云的真实坐标信息（三维）和反射强度（注在openpcdet的代码实现中是10维，多了一个zp，也就是该点在z轴上与该点所处pillar的z轴中心的偏移量）. $(x_c,y_c,z_c)$ 为该点云所处Pillar中所有点的几何中心; $x_p$ , $y_p$ 为 $x-x_c$ , $y-y_c$ ,反应了点与几何中心的相对位置。
假设每个样本中有 $P$ 个非空的pillars，每个pillar中有 $N$ 个点云数据，那么这个样本就可以用一个 $(D,P,N)$ 张量表示。那么可能就有人问了，怎么保证每个pillar中有 $N$ 个点云数据呢？如果每个pillar中的点云数据数据超过 $N$ 个，那么我们就随机采样至 $N$ 个；如果每个pillar中的点云数据数据少于 $N$ 个，少于的部分我们就填充为0；这样就实现了点云数据的张量化，具体过程如下图所示

Image

实现张量化后，作者利用简化版本的PointNet对张量化的点云数据进行处理和特征提取。特征提取可以理解为对点云的维度进行处理，原来的点云维度为 $D=9$ ,处理后的维度为 $C$ ,那么我们就获得了一个 $(C,P,N)$ 的张量。接着，我们按照Pillar所在维度进行Max Pooling操作，即获得了 $(C,P)$ 维度的特征图。为了获得伪图片特征，作者将 $ P$ 转换为 $(H,W)$ ,即 $P->H*W$ .那么我们就获得了形如 $(C,H,W)$ 的伪图片了。具体过程如下：

Image

【OpenPCDet】关于spconv的一些问题解决方案

古月月仔 — Mon, 30 Dec 2024 00:00:00 +0800

最近在修改对OpenPCDet中一些算法做改进评估的时候碰到了一系列的和spconv模组相关的问题，找到了一些解决方法。本人的服务器环境：

操作系统版本：Ubuntu20.04 GPU：3090Ti CUDA版本:11.3 Pytorch：1.8.1 Python:3.8

问题1：

File “/home/OpenPCDet/pcdet/utils/spconv_utils.py”, line 4, in if float(spconv.version[2:]) >= 2.2: AttributeError: module ‘spconv’ has no attribute ‘version’ 原本以为是版本过低的问题，查资料发现是安装了多个spconv版本

python

pip uninstall spconv-cu113
pip uninstall spconv
pip install spconv-cu113

测试版本：

python

import spconv
print(spconv.__version__)

问题2：

AttributeError: module ‘spconv’ has no attribute ‘SparseModule’ 研究后发现是spconv版本更新导致，在spconv2的使用中，mport spconv 要改写成 import spconv.pytorch as spconv

问题3：

ImportError: generic_type: cannot initialize type “ExternalAllocator”: an object with that name is already defined 解决方法：降低版本

【OpenPCDet】模型的数据采样训练

古月月仔 — Fri, 20 Dec 2024 00:00:00 +0800

在OpenPCDet中，KITTI 数据集的 ImageSet 中已经包含了训练和测试数据的索引信息，这使得可以不必直接扫描点云数据文件来获取某个特定的数据集。通过修改 ImageSet 中的索引，就可以直接选择不同的数据帧来进行训练、测试或推理。

1. KITTI 数据集中的 ImageSet

imageset 文件夹包含了多个文本文件，其中每个文件列出了训练和测试数据的帧索引。这些文件通常以如下格式命名：

bash

data/
 ├── kitti/
 │ ├── ImageSets/
 │ │ ├── train.txt # 训练集的帧索引
 │ │ ├── val.txt # 验证集的帧索引
 │ │ └── test.txt # 测试集的帧索引

每个 txt 文件中列出了一系列的帧编号，例如：

python

000000
000001
000002
...

这些帧编号对应的是 velodyne 文件夹中的 .bin 点云数据文件.

2. 修改索引文件

此处我想要基于Kitti数据集进行采样，生成十个不同的用于训练的数据集可以直接原本的train.txt进行采样，将其保存为一个新的索引集在kitti文件路径下新建一个脚本文件

python





import random

# 读取原始的 train.txt 文件
with open('kitti/training/imageset/train.txt', 'r') as f:
 lines = f.readlines()

# 随机采样 10 组数据
num_samples = 1000 # 每组采样的帧数量
num_groups = 10 # 需要采样的组数

# 随机生成 10 组数据集
for i in range(1, num_groups + 1):
 # 随机选择 1000 个帧
 sampled_lines = random.sample(lines, num_samples)

 # 保存到不同的 train_sampledX.txt 文件中
 sampled_file_path = f'kitti/training/imageset/train_sampled{i}.txt'
 with open(sampled_file_path, 'w') as f:
 f.writelines(sampled_lines)

 print(f"Group {i} saved to {sampled_file_path}")

运行以上代码即可在原本的目录下生成一系列的采样数据集

image

【OpenPCDet】Uncertainty Estimation学习笔记（一）

古月月仔 — Sat, 30 Nov 2024 00:00:00 +0800

为什么要研究uncertainty？

训练好的[神经网络模型本质是一个拥有大量确定参数的函数，不管你给什么输入，它都能给你一个输出。这会导致两种我们不愿意看到的意外情况：

对明明错误的预测结果，模型输出的[置信度]却很高
对没有见过的输入(OoD，Out-of-ditribution)，比如给一个识别猫/狗的模型输入一张桌子图片，模型一定会输出：”这是猫“ or “这是狗”，而不是告诉我们 “它似乎不是猫，也不是狗”

所以，我们希望模型能输出 uncertainty，辅助使用模型的人进行更好地决策。比如上面的例子中，我们希望对错误分类的样本、OoD样本，模型能够给出一个较高的uncertainty。

uncertainy是什么？

参考NIPS2017年的论文 What Uncertainties Do We Need in Bayesian Deep Learning for Computer Vision? ，Gal阐述了两种uncertainty：Aleatoric uncertainty(i.e. data uncertainty) 和 Epistemic uncertainty(i.e. model uncertainty)，即随机不确定度(也称数据不确定度)，和认知不确定度(也称模型不确定度)。

Epistemic uncertainty可以通过增加数据解决，比如下图：只有一个data point的时候，符合要求的模型有很多种可能，uncertainty很高。当数据点增加，模型逐渐确定，uncertainty减小。

image

How？怎么计算不确定度

1.Epistemic uncertainty建模

image

Monte-Carlo 和 Ensemble 对一个随机分布，不确定性建模的方法有很多，标准差、方差、风险值（VaR）和熵都是合适的度量。在深度学习中，建模不确定度需要用到Bayesian DeepLearning。从Bayesian的角度，深度学习训练的本质是求一个posterior distribution $P(W|D)$ ，其中W是参数，D是数据。根据bayes theorem（贝叶斯定理），我们有 $P(W|D)=\frac{P(D|W)P(W)}{P(D)}$ 但是这个公式没法用，因为 $P(D)$ 理论上代表的是真实的数据分布，无法获取; $P(W)$ 在神经网络中也是不存在的，因为模型训练好以后，所有参数都是确定的数，而不是distribution，没法计算 $P(W)$ 。于是我们想到bayes theorem的另一个公式: $P(D)=\sum_i{P(D|W_i)P(W_i)}$

卷积神经网络(CNN)的原理

古月月仔 — Sun, 10 Nov 2024 00:00:00 +0800

卷积神经网络（CNN）的核心运算“卷积”是一种数学操作，通过翻转和滑动叠加来捕捉数据的局部与全局特征。这种机制使CNN在图像识别等计算机视觉任务中表现出色，能够有效处理图像中的平移不变性。

引言

卷积神经网络（Convolutional Neural Network，CNN）是一种在计算机视觉领域取得了巨大成功的深度学习模型。它们的设计灵感来自于生物学中的视觉系统，旨在模拟人类视觉处理的方式。在过去的几年中，CNN已经在图像识别、目标检测、图像生成和许多其他领域取得了显著的进展，成为了计算机视觉和深度学习研究的重要组成部分。

卷积是什么？

教科书上一般定义函数f,g的卷积f*g(n)如下：连续形式：

在这里插入图片描述

离散形式：

在这里插入图片描述

并且也解释了，先对g函数进行翻转，相当于在数轴上把g函数从右边褶到左边去，也就是卷积的“卷”的由来。然后再把g函数平移到n，在这个位置对两个函数的对应点相乘，然后相加，这个过程是卷积的“积”的过程。

对卷积的通俗理解

所谓两个函数的卷积，本质上就是先将一个函数翻转，然后进行滑动叠加 在连续情况下，叠加指的是对两个函数的乘积求积分，在离散情况下就是加权求和，为简单起见就统一称为叠加。整体看来是这么个过程：翻转——>滑动——>叠加——>滑动——>叠加——>滑动——>叠加 …. 多次滑动得到的一系列叠加值，构成了卷积函数。 卷积的“卷”，指的的函数的翻转，从 g(t) 变成 g(-t) 的这个过程； 卷积的“积”，指的是滑动积分/加权求和。

对卷积的意义的理解：

从“积”的过程可以看到，我们得到的叠加值，是个全局的概念。以信号分析为例，卷积的结果是不仅跟当前时刻输入信号的响应值有关，也跟过去所有时刻输入信号的响应都有关系，考虑了对过去的所有输入的效果的累积。在图像处理的中，卷积处理的结果，其实就是把每个像素周边的，甚至是整个图像的像素都考虑进来，对当前像素进行某种加权处理。所以说，“积”是全局概念，或者说是一种“混合”，把两个函数在时间或者空间上进行混合。

那为什么要进行“卷”？直接相乘不好吗？我的理解，进行“卷”（翻转）的目的其实是施加一种约束，它指定了在“积”的时候以什么为参照。在信号分析的场景，它指定了在哪个特定时间点的前后进行“积”，在空间分析的场景，它指定了在哪个位置的周边进行累积处理。

卷积神经网络

图像原理

在了解卷积神经网络前，我们先来看看图像的原理：图像在计算机中是一堆按顺序排列的数字，数值为0到255。0表示最暗，255表示最亮。如下图：

【OpenPCDet】详细部署与复现

古月月仔 — Fri, 25 Oct 2024 00:00:00 +0800

本文详细介绍了在Ubuntu 20.04系统上配置OpenPCDet 3D目标检测工具箱的完整流程，涵盖创建虚拟环境、安装PyTorch与spconv等关键依赖，并最终完成编译和数据导入。

OpenPCDet简介

OpenPCDet是一个用于3D目标检测的开源工具箱，它提供了多种数据集的加载器，支持多种模型，并且易于扩展。

本人使用硬件与环境

Linux操作系统（Ubuntu20.04） Python环境（Anaconda下独立创建） CPU: 11th Gen Intel® Core™ i9-11900K @ 3.50GHz × 16 GPU: NVIDIA GeForce RTX 3090 cuda：11.3

配置步骤

创建虚拟环境

shell

conda create -n pcdet python=3.8

激活进入虚拟环境

shell

conda activate pcdet

安装pytorch

查看cuda版本

shell

 nvcc -V

查看运行结果

在这里插入图片描述

【虚幻引擎】GameMode和GameSate

古月月仔 — Sun, 21 Apr 2024 00:00:00 +0800

GameMode是服务器端权威的游戏规则管理者，定义核心逻辑；GameState则负责在服务器与客户端间同步全局游戏状态，如比分和时间。

image-20250422211945454

在虚幻引擎（Unreal Engine）中，GameMode 和 GameState 都是多人游戏中的核心类，但它们的分工和用途有显著区别。以下是它们的对比和典型应用场景：

1. GameMode（游戏规则管理者）

职责

仅存在于服务器端（不会复制到客户端）。
定义游戏的核心规则：胜利条件、玩家生成逻辑、回合制规则等。
管理玩家登录/退出（通过Login/Logout等事件）。
生成并持有PlayerController、PlayerState等。

典型用途

cpp





// 示例：在GameMode中设置玩家生成逻辑
void AMyGameMode::PostLogin(APlayerController* NewPlayer) {
 Super::PostLogin(NewPlayer);
 // 生成玩家角色
 if (NewPlayer->GetPawn() == nullptr) {
 SpawnPlayerAtTransform(NewPlayer, SpawnTransform);
 }
}

关键特性

服务器权威：客户端无法修改GameMode的逻辑。
不复制：客户端无法直接访问GameMode。

2. GameState（游戏状态同步者）

职责

存在于服务器和客户端（自动复制到所有客户端）。
存储并同步游戏全局状态：比分、剩余时间、玩家列表等。
提供客户端可见的数据（如通过PlayerArray访问所有玩家的PlayerState）。

典型用途

cpp

// 示例：在GameState中同步比分
void AMyGameState::OnRep_TeamScores() {
 // 客户端更新UI显示比分
 UpdateScoreboardUI(TeamAScore, TeamBScore);
}

关键特性

数据同步：通过属性复制（Replicated）或RPC同步到客户端。
客户端可读：UI可以直接绑定GameState的数据（如剩余时间）。

核心区别对比

特性	GameMode	GameState
存在位置	仅服务器	服务器 + 客户端（复制）
用途	定义规则、逻辑控制	存储和同步全局状态
是否复制到客户端	❌ 否	✅ 是
客户端访问权限	无法直接访问	可读取数据（如显示比分）
生命周期	游戏开始时创建，结束时销毁	随游戏运行持续存在

协作流程示例

服务器：
- GameMode决定玩家生成规则（如出生点选择）。
- GameState更新并同步比分到所有客户端。
客户端：
- 通过GameState获取实时比分，更新UI。
- 无法修改规则（必须通过服务器GameMode）。

何时使用？

用GameMode：
- 需要权威控制游戏逻辑（如判断胜利条件）。
- 处理玩家登录/退出等敏感操作。
用GameState：
- 需要让所有客户端知道全局状态（如倒计时、玩家列表）。
- UI需要绑定的动态数据（如实时比分）。

通过这种分工，虚幻引擎实现了逻辑与状态的分离，确保多人游戏的同步性和安全性。

【虚幻引擎】虚幻5.1UUserWidget不再包含OnLevelRemovedFromWorld的问题

古月月仔 — Sat, 20 Apr 2024 00:00:00 +0000

在虚幻引擎5.1中，OnLevelRemovedFromWorld函数已被移除，导致编译错误。解决方案是重写NativeDestruct函数来实现相同的资源清理逻辑，从而成功编译。

在跟着Blaster课程项目写Menu插件的时候,在Menu.h中一直报以下错误无法编译,百思不得其解.

image-20250421115907081

严重性代码说明项目文件33行禁止显示状态详细信息错误C3668“UMenu::OnLevelRemovedFromWorld”: 包含重写说明符“override”的方法没有重写任何基类方法MenuSystem F:\UE\UEproject\MultiplayCourse\MenuSystem\Plugins\MultiplayerSessions\Source\MultiplayerSessions\Public\Menu.h23

image-20250421120505541

查阅资料后发现是虚幻5.1和5.0的版本问题: 虚幻5.1 UUserWidget不再包含OnLevelRemovedFromWorld.我们可以重载一个类似的函数用于达到相同的效果:

cpp

 virtual void NativeDestruct() override;

.cpp文件中实现:

cpp

void UMenu::NativeDestruct()
{
 MenuTearDown();
 Super::NativeDestruct();
}

NativeDestruct() 是 UUserWidget（用户控件）提供的一个 关键生命周期虚函数(析构函数)，用于 处理控件的销毁逻辑。

【MultiplayerCourse】创建多人联机插件

古月月仔 — Fri, 19 Apr 2024 00:00:00 +0000

本文记录了在Unreal Engine 5中配置Steam在线子系统的具体步骤，包括启用插件、修改项目依赖项以及编辑配置文件，以实现多人游戏功能。

此博客为学习油管DruidMech大佬的广域网多人射击游戏的笔记附上项目GitHub源码地址https://github.com/DruidMech/MultiplayerCourseMenuSystem

新建项目

首先使用引擎（5.0及以上）创建一个基于第三人称模板的.cpp项目，我这里将其命名为MenuSystem.

Subsystem插件配置

一、在编辑器-插件中打开Oline Subsystem Steam插件，然后重启项目。

image-20250419144230516

二、在项目的Build.cs下找到一个PublicDependencyModuleNames,把插件的配置项OnlineSubsystemSteam、OnlineSubsystem添加到其中然后编译

c#

PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "EnhancedInput" ,"OnlineSubsystemSteam","OnlineSubsystem"});

image-20250419145217432

三、在项目/config/DefaultEngine.ini中添加下面代码

text

[/Script/Engine.GameEngine]
 +NetDriverDefinitions=(DefName="GameNetDriver",DriverClassName="OnlineSubsystemSteam.SteamNetDriver",DriverClassNameFallback="OnlineSubsystemUtils.IpNetDriver")

 [OnlineSubsystem]
 DefaultPlatformService=Steam

 [OnlineSubsystemSteam]
 bEnabled=true
 SteamDevAppId=480

 ; If using Sessions
 ; bInitServerOnClient=true

 [/Script/OnlineSubsystemSteam.SteamNetDriver]
 NetConnectionClassName="OnlineSubsystemSteam.SteamNetConnection"

注意：

【虚幻引擎】委托(Delegates)与回调(Callbacks)

古月月仔 — Mon, 15 Apr 2024 00:00:00 +0800

虚幻引擎的委托机制是一种类型安全的事件通知系统，支持动态绑定和多播功能，适用于观察者模式和回调实现。主要包括单播、多播、动态委托及事件等类型，并提供基本使用示例。

Unreal Engine 中的 Delegates（委托）详解

Delegates（委托）是 Unreal Engine 中一种强大的事件通知机制，它允许开发者在不直接引用类的情况下调用成员函数。本质上，委托是一种类型安全的函数指针，特别适合用于实现观察者模式、事件系统和回调机制。

基本概念

核心特点

类型安全：编译时会检查函数签名匹配
动态绑定：可以在运行时绑定/解绑函数
多播能力：可以同时通知多个接收者（Multicast Delegates）
序列化支持：部分委托类型支持蓝图序列化

委托类型

Unreal Engine 提供了几种主要的委托类型：

1. 单播委托 (Singlecast Delegates)

cpp

DECLARE_DELEGATE(MyDelegate); // 无参数
DECLARE_DELEGATE_OneParam(MyParamDelegate, FString); // 单参数
DECLARE_DELEGATE_TwoParams(MyTwoParamDelegate, int32, bool); // 双参数

2. 多播委托 (Multicast Delegates)

cpp

DECLARE_MULTICAST_DELEGATE(MyMulticastDelegate);
DECLARE_MULTICAST_DELEGATE_OneParam(MyMulticastParamDelegate, float);

3. 动态委托 (Dynamic Delegates)

cpp

DECLARE_DYNAMIC_DELEGATE(FMyDynamicDelegate);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FMyDynamicMulticastDelegate);

4. 事件 (Events)

cpp

DECLARE_EVENT(MyOwnerClass, MyEvent);

使用示例

单播委托示例

cpp





// 声明一个带有一个参数(int32)的单播委托类型，命名为FScoreChangedDelegate
// 该委托用于在分数变化时通知订阅者
DECLARE_DELEGATE_OneParam(FScoreChangedDelegate, int32);

// 定义一个继承自AActor的类AMyActor
class AMyActor : public AActor
{
public:
 // 声明一个FScoreChangedDelegate类型的委托实例OnScoreChanged
 // 这个委托将用于在分数更新时通知所有绑定的函数
 FScoreChangedDelegate OnScoreChanged;

 // 更新分数的方法
 void UpdateScore(int32 NewScore)
 {
 // 执行委托，通知所有绑定的函数
 // ExecuteIfBound是安全执行方法，只有在有绑定时才会实际调用
 // 参数NewScore将传递给所有绑定的函数
 OnScoreChanged.ExecuteIfBound(NewScore);
 }
};

// 定义一个监听分数变化的类AMyListener
class AMyListener
{
public:
 // 绑定到分数变化委托的方法
 void BindToScoreChange(AMyActor* Actor)
 {
 // 使用BindUObject将当前对象(this)的HandleScoreChanged方法绑定到Actor的OnScoreChanged委托
 // BindUObject专门用于绑定UObject成员函数，会自动处理对象生命周期
 Actor->OnScoreChanged.BindUObject(this, &AMyListener::HandleScoreChanged);
 }

 // 处理分数变化的回调函数
 void HandleScoreChanged(int32 NewScore)
 {
 // 当分数变化时，记录日志显示新分数
 // %d将被NewScore的值替换
 UE_LOG(LogTemp, Warning, TEXT("Score changed to %d"), NewScore);
 }
};

执行流程

sequenceDiagram
participant 调用方 as 调用方(AMyActor)
participant 委托系统 as 委托系统(OnScoreChanged)
participant 监听方 as 监听方(AMyListener)
Note over 监听方: 初始化阶段
监听方->>委托系统: BindUObject(this, &AMyListener::HandleScoreChanged)
Note right of 委托系统: 存储绑定信息：<br/>- 目标对象(this)<br/>- 函数指针(HandleScoreChanged)
Note over 调用方: 执行阶段
调用方->>委托系统: ExecuteIfBound(NewScore)
委托系统->>监听方: 检查目标对象有效性
alt 对象有效
监听方-->>委托系统: 确认可调用
委托系统->>监听方: 调用HandleScoreChanged(NewScore)
监听方->>监听方: 执行日志输出 UE_LOG(...)
else 对象无效
委托系统--x 监听方: 跳过执行（自动清理绑定）
end

流程图有时候网页上无法基于代码绘制显示，再附一张截图

【虚幻引擎】UC++的宏定义语法

古月月仔 — Wed, 10 Apr 2024 00:00:00 +0800

Unreal Engine通过UCLASS、UPROPERTY和UFUNCTION等反射宏，将C++类、属性和函数暴露给引擎反射系统与蓝图编辑器，实现可视化编辑和脚本交互。GENERATED_BODY()宏必须置于类定义起始处。

Unreal Engine中宏定义语法的使用

示例代码：

cpp





// 类声明宏：使类被纳入Unreal反射系统
// - Blueprintable：允许在蓝图中创建该类的子类
// - meta=(DisplayName="My Object")：在编辑器中显示的自定义名称
UCLASS(Blueprintable, meta=(DisplayName="My Object"))
class UMyObject : public UObject // 必须继承UObject或其子类
{
 // 代码生成宏：必须出现在类体内第一个位置
 // - 展开后会包含类型信息、反射数据等引擎所需的内容
 GENERATED_BODY()

 // 属性声明宏：将成员变量暴露给反射系统
 // - EditAnywhere：可在编辑器的任意位置（如蓝图、细节面板）编辑此属性
 // - Category="Stats"：在编辑器中归入"Stats"分类组
 UPROPERTY(EditAnywhere, Category="Stats")
 float Health = 100.0f; // 带默认值的公开属性

 // 函数声明宏：将函数暴露给反射系统
 // - BlueprintCallable：允许蓝图调用此方法
 // - 可添加其他说明符如：
 // - Category="Gameplay"：函数分组
 // - meta=(ToolTip="Heal amount")：悬停提示文本
 UFUNCTION(BlueprintCallable)
 void Heal(float Amount); // 可被蓝图调用的方法
};

关键宏参数详解：

UCLASS 常用参数：

参数	作用
Blueprintable	允许基于此类创建蓝图
BlueprintType	允许在蓝图中作为变量类型使用
NotBlueprintable	明确禁止蓝图继承（默认）
meta=(DisplayName)	编辑器显示名称

UPROPERTY 常用参数：

参数	作用
VisibleAnywhere	属性可见但不可编辑
EditAnywhere	属性可任意编辑
EditDefaultsOnly	仅允许在类默认值中编辑
BlueprintReadOnly	蓝图只读访问
Category	属性分类（编辑器分组）
meta=(ClampMin=0)	元数据：限制最小值

UFUNCTION 常用参数：

参数	作用
BlueprintCallable	可从蓝图调用
BlueprintPure	纯函数（无副作用）
Category	函数分类
meta=(Deprecated)	标记为已弃用

特殊说明：

GENERATED_BODY() 必须：

【游戏设计】游戏开发中AI

古月月仔 — Sat, 06 Apr 2024 00:00:00 +0800

游戏AI旨在设计非玩家角色的智能行为，以增强体验、创造挑战和模拟世界。文章重点介绍了经典的状态机（FSM）方法，通过拆分行为为独立状态（如巡逻、攻击）并定义转换条件来实现简单AI，同时指出了状态增多时维护复杂的弊端。

文章的思路来源于Voidmatrix大神视频总结，以及一些本人开发BossAI的感悟所写。

附上大神原视频链接：【游戏开发秘籍】状态机？行为树？一个视频速通游戏开发中的AI！#06

游戏AI是什么

**游戏开发领域中，AI通常指的是对非玩家角色行为的设计与研究，让他们能够感知周围的环境，并且做出相应的动作表现。**例如和玩家交互聊天的NPC、按照特定规则巡逻的怪物或是直接与玩家进行对抗的人机等等，一个能与我们的游戏玩法相匹配，逻辑自洽的角色，除去策划上的工作，在开发技术上也是大有研究的。

游戏AI的核心目标

增强体验：通过智能的NPC行为、动态难度调整等提升游戏趣味性。
创造挑战：让敌人或对手具备合理的策略，避免过于简单或作弊。
模拟世界：构建逼真的生态系统（如《荒野之息》中的动物行为）。

状态机（FSM）

状态机

最经典最简单的AI实现技术便是状态机，我们可以把NPC的每一个具体的行动都拆分成一个独立的状态。

接下来我们只需要设计好状态间的挑战条件就可以了，譬如 NPC拥有巡逻、攻击、逃跑和治疗4个状态，默认的入口状态为巡逻，也就是在这个NPC在程序中被实例化添加到游戏世界中时，它便会巡视自己的领地。按照固定的路线徘徊，当玩家等敌对角色进入到他的视野范围后，状态机便会跳转到攻击的状态，在攻击状态下，他会持续逼近玩家的位置，并且试图对其造成伤害。而当在这个战斗过程中自身生命值低于一定数值时，NPC就会进入到逃跑状态，在逃离玩家一定范围后，他们也会停下来治疗自己，恢复生命值，然后继续进入到巡逻或是战斗的状态循环，整套逻辑，这样一个栩栩如生的NPC角色就诞生在了我们创造的游戏世界中了。

NPC状态机循环

而作为最经典的压实线状态机的实验代码，可以说是最简单的了。

以前面空洞武士项目教程中的代码为例，对于状态节点的设计，我们除去执行更新到 update接口外，通常还需要预留on inter和on X的接口，用来通知该状态的进入并进行初始化以及处理状态退出式的逻辑，譬如在攻击状态进入和退出时，我们需要设置NPC手持武器道具的可见性，并且更新其锁敌感知范围的逻辑，对于状态机本身等待提供 update的更新方法外，也还需要提供设置入口状态，切换状态和注册新状态的接口，为了更快捷的查找，在实际开发过程中，我们可以使用媒体书读或是哈希表来存储状态ID到具体状态对象的映射，那么在状态机更新的过程中，实际执行了当前选中的状态攻击方法，在设置入口状态或是切换不同的状态时，也只需要根据传入的ID，将当前状态指针指向不同的具体状态对象即可。

状态机的弊端

不过跟过空洞武士项目介绍的同学其实可能就已经意识到了这台机正如AI实现方法的弊端了，**不同的状态之间彼此穿插，如果我们要新增一个状态或是修改已有的状态跳转条件时，都需要考虑与现有状态的调整关系，当系统的状态数过多时，维护各个状态间的关系就会变得非常困难。**那么封装的思想这时就起作用了，我们能否把功能相似的具体状态封装成一个更大的抽象状态，我们只需要去关注不同抽象状态间的跳转，思路便会清晰很多。

过于复杂的状态机

【C++】特殊字符的意义和用法区分

古月月仔 — Fri, 05 Apr 2024 00:00:00 +0800

C++中四种运算符的核心区别：::用于访问命名空间、类或静态成员；->通过指针访问对象成员；.通过对象实例访问成员；*用于指针解引用。

在 C++ 中，::、-> 、. 和*是四种不同的运算符，分别用于不同的上下文场景。它们的详细解释和用法对比：

1. 作用域解析运算符 `::`

用途

访问 命名空间、类、结构体或枚举 的成员
调用 静态成员（变量或函数）
区分同名的全局变量和局部变量

示例

cpp





#include <iostream>

namespace MyNamespace {
 int value = 42;
}

class MyClass {
public:
 static int staticValue;
 static void staticMethod() {
 std::cout << "Static method called!" << std::endl;
 }
};

int MyClass::staticValue = 100; // 静态成员变量定义

int main() {
 // 访问命名空间成员
 std::cout << MyNamespace::value << std::endl; // 输出: 42

 // 访问类的静态成员
 std::cout << MyClass::staticValue << std::endl; // 输出: 100
 MyClass::staticMethod(); // 输出: Static method called!

 return 0;
}

关键点

:: 不依赖对象实例，直接通过类名或命名空间访问成员。
常用于 全局变量、静态成员、嵌套类 等场景。

2. 成员访问运算符 `->`

用途

通过指针访问对象的成员（变量或函数）
等价于 (*ptr).member（先解引用，再用 . 访问）

示例

cpp





#include <iostream>

class MyClass {
public:
 int value = 10;
 void print() {
 std::cout << "Value: " << value << std::endl;
 }
};

int main() {
 MyClass obj;
 MyClass* ptr = &obj; // 指向对象的指针

 // 通过指针访问成员
 ptr->value = 20; // 等价于 (*ptr).value = 20;
 ptr->print(); // 输出: Value: 20

 return 0;
}

关键点

-> 只能用于指针，不能用于普通对象。
在 智能指针（如 std::shared_ptr）和 迭代器 中也常用。

3. 成员访问运算符 `.`

用途

通过 对象实例（非指针）访问成员（变量或函数）
适用于 结构体、类、联合体 等

示例

cpp





#include <iostream>

class MyClass {
public:
 int value = 30;
 void print() {
 std::cout << "Value: " << value << std::endl;
 }
};

int main() {
 MyClass obj;

 // 通过对象访问成员
 obj.value = 40;
 obj.print(); // 输出: Value: 40

 return 0;
}

关键点

. 只能用于对象实例，不能用于指针。
在 结构体、类、联合体 中通用。

4. 解引用/指针运算符 `*`

用途

指针声明：表示变量是指针类型
解引用：获取指针指向的实际值
乘法运算：算术乘法（本文不讨论，因与其他运算符无关）

示例与详解

(1) 指针声明

cpp

int num = 42;
int* ptr = &num; // ptr 是一个指向 int 的指针

int* ptr 表示 ptr 存储的是内存地址，而非直接的值。

(2) 解引用（获取指针指向的值）

cpp

int num = 42;
int* ptr = &num;

std::cout << *ptr; // 输出: 42（通过 * 获取指针指向的实际值）
*ptr = 100; // 修改指针指向的值
std::cout << num; // 输出: 100

(3) 与 `->` 的关系

ptr->member 等价于 (*ptr).member：

【虚幻引擎】UC++与标准C++的区别

古月月仔 — Tue, 19 Mar 2024 00:00:00 +0800

1. 类声明与反射系统

1.1 类定义语法

Unreal C++

cpp

// 必须继承UObject且使用反射宏
UCLASS(Blueprintable, meta=(DisplayName="My Object"))
class UMyObject : public UObject {
 GENERATED_BODY() // 必须包含

 UPROPERTY(EditAnywhere, Category="Stats")
 float Health = 100.0f;

 UFUNCTION(BlueprintCallable)
 void Heal(float Amount);
};

标准 C++

cpp

class MyObject {
public:
 float Health = 100.0f;

 void Heal(float Amount) {
 Health += Amount;
 }
};

1.2 反射机制对比

特性	Unreal C++	标准 C++
运行时类型信息	通过UCLASS宏自动生成	仅支持有限RTTI
动态属性访问	UPROPERTY字段可通过名字字符串访问	需要手动实现反射系统
方法调用	UFUNCTION支持蓝图调用和RPC	只能静态调用

2. 内存管理模型

2.1 对象生命周期

Unreal C++

cpp

// 自动垃圾回收
UMyObject* Obj = NewObject<UMyObject>();
Obj->MarkPendingKill(); // 标记销毁

// 手动控制引用
Obj->AddToRoot(); // 防止被GC
Obj->RemoveFromRoot();

标准 C++

cpp

// 手动管理
MyObject* obj = new MyObject();
delete obj;

// 或使用智能指针
auto ptr = std::make_shared<MyObject>();

2.2 内存分配器对比

cpp

// Unreal自定义分配器
FMemory::Malloc(Size);
FMemory::Free(Ptr);

// 标准库分配器
void* p = std::malloc(size);
std::free(p);

3. 核心数据类型差异

3.1 字符串处理

Unreal C++

cpp

FString Str = TEXT("Hello"); // UTF-16
FText Text = NSLOCTEXT("NS", "Key", "Localized Text");

// 格式化
FString Format = FString::Printf(TEXT("%s:%d"), *Str, 42);

标准 C++

cpp

std::string str = "Hello"; // 依赖编码
std::string format = std::format("{}:{}", str, 42); // C++20

3.2 容器类对比

数组操作

cpp





// Unreal
TArray<int32> Arr;
Arr.Add(1);
Arr.Remove(0);

// 标准库
std::vector<int> vec;
vec.push_back(1);
vec.erase(vec.begin());

字典操作

cpp

// Unreal
TMap<FName, FString> Map;
Map.Add("Key", "Value");

// 标准库
std::unordered_map<std::string, std::string> map;
map.emplace("Key", "Value");

4. 多线程编程

4.1 任务系统

Unreal C++

cpp





// GameThread执行
AsyncTask(ENamedThreads::GameThread, [](){
 UE_LOG(LogTemp, Warning, TEXT("Main thread"));
});

// 并行任务
ParallelFor(10, [](int32 Index){
 // 并行执行
});

标准 C++

cpp

std::thread t([](){
 std::cout << "New thread" << std::endl;
});
t.join();

5. 编译系统差异

5.1 模块定义

Unreal模块

cpp

// MyModule.Build.cs
public class MyModule : ModuleRules {
 public MyModule(ReadOnlyTargetRules Target) {
 PublicDependencyModuleNames.AddRange(new string[] { "Core" });
 }
}

CMake示例

cmake

add_library(MyModule STATIC src.cpp)
target_link_libraries(MyModule PUBLIC Core)

6. 常用宏对比

6.1 常用Unreal宏

cpp

UE_LOG(LogTemp, Warning, TEXT("Message")); // 日志
check(ptr != nullptr); // 断言
ensureMsgf(bCondition, TEXT("Message")); // 带消息断言

6.2 标准C++等效

cpp

std::cout << "Message" << std::endl; // 日志
assert(ptr != nullptr); // 断言
if(!bCondition) throw std::runtime_error("Message"); // 异常

7. 最佳实践建议

在Unreal项目中：
- 始终使用UCLASS()/UFUNCTION()暴露需要反射的类
- 对UObject派生类不要使用智能指针
- 使用TArray代替std::vector以获得更好性能
在独立模块中：
- 可使用标准库容器和智能指针
- 通过纯接口类与Unreal代码交互
- 将标准C++代码封装在Private目录
通用规则：
- 避免在头文件中混合两种风格的代码
- 对性能关键路径使用Unreal优化容器
- 跨平台代码优先使用Unreal封装

【游戏设计】游戏开发中的跳跃设计

古月月仔 — Fri, 15 Mar 2024 00:00:00 +0800

游戏角色跳跃设计需平衡物理模拟与玩家体验，通过插值平滑跳跃高度、引入跳跃缓冲和跳跃宽限期来优化操作手感，并可根据游戏类型定制重力参数。

文章的思路来源于VoidmatrixUP的B站视频总结，以及一些本人游戏开发的感悟所写。

附上原视频链接：【游戏开发秘籍】二段跳？土狼跳？跳跃还有这么多骚操作！游戏角色跳跃功能实现 #01

游戏的跳跃设计往往决定了这个游戏的上手手感,对于开发者来说,好的游戏跳跃的设计(以及优化)基本要遵循以下原则:

物理模拟与心理预期的平衡
- 既需要遵循基础物理规律（如自由落体）满足玩家直觉，但也要适配游戏的合理放大能力（如2.5米跳跃高度）。
  
  黑神话悟空中的跳跃
跳跃高度控制的插值过度
- 当角色达到预设高度限制时强制速度归零（直接下落或平滑减速）,但是直接将角色的速度取为0会导致手感上很生硬(就好像撞到了空气墙),所以现代游戏设计一般会在高度限制上做一个速度插值平滑过渡（如接近上限时渐衰减）.
  
  空气墙与插值
跳跃缓冲（Jump Buffering）
- 存储提前输入的跳跃指令（如连续跳跃落地前几帧按键），在满足条件时自动触发。这点比较类似于游戏连招系统中的按键缓存.
  
  跳跃缓冲
跳跃宽限期（Coyote Time）

【OpenPCDet】模型预测结果解读

古月月仔 — Sat, 02 Mar 2024 00:00:00 +0800

OpenPCDet模型的推理结果以字典形式输出，包含检测目标的类别、位置、尺寸等关键信息。不同模型输出结构类似，但具体字段可能略有差异。

在这里插入图片描述

在 OpenPCDet 中，每个模型的推理结果通常是一个包含多个键值对的字典，其中包含与 3D 检测任务相关的信息。不同模型的输出结构可能略有不同，但一般来说，模型输出通常包含以下几个关键字段：以下给一段output/kitti_models/pointrcnn/default/eval/eval_with_train/epoch_80/val/result.pkl中选取某一帧的结果示例,提取为json文件便于阅读：

json





{
"pointrcnn": [
 {
 "name": [
 "Car",
 "Pedestrian",
 "Pedestrian",

 ],
 "truncated": [
 0.0,
 0.0,
 0.0,

 ],
 "occluded": [
 0.0,
 0.0,
 0.0,

 ],
 "alpha": [
 -4.0102105140686035,
 -1.6028798818588257,
 -4.731999397277832,

 ],
 "bbox": [
 [
 0.0,
 196.87057495117188,
 410.6382141113281,
 373.0
 ],
 [
 688.0215454101562,
 172.8148193359375,
 709.7300415039062,
 224.52003479003906
 ],
 [
 667.0341186523438,
 172.51962280273438,
 687.4990844726562,
 223.23146057128906
 ],

 ],
 "dimensions": [
 [
 4.10535192489624,
 1.4689395427703857,
 1.6220554113388062
 ],
 [
 0.9827990531921387,
 1.7112400531768799,
 0.6871805191040039
 ],
 [
 0.5967018008232117,
 1.6898497343063354,
 0.67041015625
 ],

 ],
 "location": [
 [
 -2.7540218830108643,
 1.6045180559158325,
 4.157565593719482
 ],
 [
 3.2612111568450928,
 1.4242191314697266,
 24.295761108398438
 ],
 [
 2.5298221111297607,
 1.3910222053527832,
 24.260332107543945
 ],

 ],
 "rotation_y": [
 -4.574054718017578,
 -1.476109504699707,
 -4.6344404220581055,

 ],
 "score": [
 0.9997606873512268,
 0.9978153705596924,
 0.9920910596847534,

 ],
 "boxes_lidar": [
 [
 4.406521797180176,
 2.786322832107544,
 -0.915142297744751,
 4.10535192489624,
 1.6220554113388062,
 1.4689395427703857,
 3.003258228302002
 ],
 [
 24.574119567871094,
 -3.132066488265991,
 -0.7385169863700867,
 0.9827990531921387,
 0.6871805191040039,
 1.7112400531768799,
 -0.09468691051006317
 ],
 [
 24.53524398803711,
 -2.4012603759765625,
 -0.7080038189888,
 0.5967018008232117,
 0.67041015625,
 1.6898497343063354,
 3.0636441707611084
 ],

 ],
 }
 ],
}

内容解读

name

含义：检测到的物体类别。示例：["Car", "Pedestrian", "Pedestrian", ...] 说明：

【虚幻引擎】设置UI自适应屏幕大小

古月月仔 — Thu, 30 Nov 2023 00:00:00 +0800

锚点是虚幻引擎UI布局的核心工具，通过将控件锚定在父物体或屏幕的特定点，确保界面在不同屏幕分辨率下能自适应缩放并保持稳定的相对位置关系。

在游戏中，如果想实现不同分辨率下，都可以支持当前的UI界面布局，都需要用到锚点功能。 ‌虚幻引擎中的UI锚点（Anchor）是指控件在屏幕或父物体上的固定点，用于确定控件的位置和布局。‌ 锚点的作用是确保UI元素在屏幕缩放或形变时保持相对位置不变。

在虚幻引擎中，锚点可以理解为将子物体“挂”在父物体上的点。当父物体的位置或大小发生变化时，子物体的位置会相应地调整，保持它们之间的相对关系不变。锚点的位置可以在屏幕的任意角落，通常用于自适应屏幕尺寸和保持布局的稳定性‌。具体来说，锚点有以下几种情况：

当锚点与父物体的某个顶点重合时，子物体在该点的位置不会改变，只有当父物体该点位置改变时，子物体才会跟着移动。
如果锚点不重合，子物体在父物体变形时会跟着缩放，保持与父物体各顶点的距离不变‌。

具体实现：

错误的UI锚点设置方法如下：

img

如上图为锚点设置不准确，导致缩放时出现屏幕空缺

img

将锚点修改为下图所示：

img

【虚幻引擎】VRiod的二次元角色导入

古月月仔 — Mon, 20 Nov 2023 00:00:00 +0800

本文介绍了将VRoid Studio创建的二次元角色模型导入虚幻引擎的完整流程。首先在VRoid Studio中设计并导出VRM格式的角色文件，然后通过VRM4U插件将其导入虚幻引擎项目，并提供了插件安装、配置及常见问题的解决方法。

VRiod的二次元角色导入虚幻引擎

突然想在虚幻项目中用点二次元角色,找了些资料以及自己实践作如下博客,附一篇视频教程:如何在UE5中快速导入VroidStudio的二次元萌妹

VRoid Studio使用

VRoid Studio是由pixiv开发的一款3D角色绘制软件,可以在Steam上免费下载使用.

软件的主要功能就是通过类似绘画的方式进行人物的建模，让用户可以更加轻松地创造自己的虚拟人物（形象）。软件的操作界面也非常的简单直观，里面配备了许多预设项目和参数，让用户不需要从头开始建模，只需选择项目、组合它们并调整参数即可创建自己的角色，其中就包含了面部、发型、衣服、化妆等等可定制的参数。同时，用户能直接想画画一样直观的模拟发型，还能直接在3D模型上绘制特定的面部表情、眼睛或服装设计。此外，用户可以通过全尺寸钢笔工具绘制自己所需要的纹理，它支持数位板压力感应，用户可以直接在3D模型或UV开发上直接实时绘制纹理用来创建角色。

对于我们这种只会写代码的人来说,使用VRoid Studio只需要把他提供的资源组合一下,就能得到很好看的角色.

比如我们选择软件提供的模板,这个蓝头发的美眉,进入微调界面:

VRoid捏二次元角色

调整为自己心仪的模样后点击右上角导出为VRM文件.

捏猫娘脸

不进行骨骼贴图调整,直接使用默认选项导出:

image-20250424223201161

【机器学习】基础知识总结

古月月仔 — Mon, 30 Oct 2023 00:00:00 +0800

机器学习基础知识全梳理：从原理到实践

写在前面

机器学习作为人工智能的核心分支，已经渗透到我们生活的方方面面：推荐系统推荐你喜欢的音乐、垃圾邮件自动识别、自动驾驶车辆感知环境、医疗辅助诊断等等。但你是否想过，这些系统是如何"学习"的？

本文适合对机器学习已有初步了解的学习者进行系统复习，内容从基础概念到算法原理，由浅入深，注重理解而非死记硬背。如果你是机器学习新手，强烈推荐先系统学习吴恩达老师的经典课程。

推荐入门课程：

吴恩达机器学习 2025 重制版 - B站高清完整课程，附课件和实战项目

CS229: Machine Learning - 斯坦福大学官方课程资料

3Blue1Brown: Neural Networks - 视觉化理解神经网络

一、什么是机器学习？

形式化定义

机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习并做出决策或预测，而无需进行明确的编程。

通俗理解：假设你有一个数据集，需要通过这个数据集找出一个函数或方法来分析数据并对新数据进行预测。从这个角度看，机器学习本质上就是"找函数"的过程。

学习范式类比

我们可以用一个形象的类比来理解机器学习的核心思想：

传统编程	机器学习
输入数据 + 明确规则 → 输出结果	输入数据 + 期望输出 → 推导规则
规则由人类编写	规则从数据中学习
适合规则明确的任务	适合规则难以定义的任务

举例说明：

传统编程：编写一个程序判断数字是否能被 2 整除——规则明确（x % 2 == 0）
机器学习：训练模型识别手写数字——规则难以用代码表达，需要从大量样本中学习

学习的三要素

有效的机器学习需要三个核心要素：

数据（Data）：学习的素材，质量决定上限
模型（Model）：函数的假设空间，决定表达能力
算法（Algorithm）：从数据中优化模型参数的方法

延伸阅读：

Mitchell, T. (1997). Machine Learning - 经典教材，学习形式化定义

Learning representations by back-propagating errors - 神经网络反向传播经典论文

二、机器学习四大范式

机器学习范式

【虚幻引擎】设置双人分屏

古月月仔 — Fri, 11 Aug 2023 00:00:00 +0800

本文记录了在项目中实现本地分屏联机功能的过程，包括在项目设置中启用分屏模式、配置游戏模式，并详细解析了用于动态生成玩家角色的蓝图核心逻辑与关键节点。

在开发项目的时候想添加一个本地联机功能,使用分屏功能实现,查了一些资料做此记录博客.

项目设置

在项目设置中Local Multiplayer目录下打开使用分屏功能,可以选择垂直/水平分屏,一般像双人成行那样选择垂直模式.

image-20250425120633628

⚠Warning !

注意此处要跳过将手柄指定到玩家1选项.,因为我们想实现一个玩家1使用键鼠操作,后续玩家使用手柄操作的模式

img

游戏模式设置

打开项目设置后就可以修改我们的游戏模式.

img

古月月仔的博客

【课堂笔记】可计算理论导论：从零开始理解计算的边界

可计算理论导论：从零开始理解计算的边界

前言：为什么我们需要可计算理论？

不存在这样的万能工具。

什么是可计算理论？

教材与学习方法

一、可计算理论的三个分支

【LLM应用开发实践】Agent 实战落地经验与技术思考

Agent 实战落地经验与技术思考

前言

一、重新思考 Agent 框架的价值

1.1 框架层的价值正在降低

1.2 真正的价值在哪里？

【论文阅读】Reflective Context Learning: Studying the Optimization Primitives of Context Space

【LLM应用开发原理】从提示词工程、上下文工程到Harness工程的设计哲学

引言

一、提示词工程（Prompt Engineering）：人机交互接口的第一次对齐

设计哲学：把自然语言变成新的编程语言

核心方法论的演进

二、上下文工程（Context Engineering）：模型记忆能力的工程化突破

设计哲学：让大模型从「闭卷考试」变成「开卷考试」

【Vibe-Coding】前后端基础知识扫盲-1

第一章：网页是如何工作的？

1.1 从输入网址到看到页面，发生了什么？

【LLM应用开发原理】Agent记忆与检索

【LLM应用开发原理】Function Calling底层原理与MCP

从"只能回答"到"能调用工具"：LLM能力的演进

背景与演进

Function Calling底层原理

【LLM应用开发原理】Agent Skill原理与基础

从工具到技能：Agent能力的进化

Skill的设计起源

1. 软件工程的模块化思想

【LLM应用开发原理】Agent经典开发范式

动手学Agent

Agent经典范式

1. ReAct范式（Reasoning and Acting）

【LLM应用开发原理】我怎样理解Agent

怎样理解Agent

Transformer的无状态性

【年度总结】致我的2025：一些事实与感受

致我的2025：一些事实与感受

春

夏

【C++】组合、继承和多态

组合 (Composition)物理嵌套与高效复用

继承 (Inheritance)：结构延伸与逻辑分类

【C++】作用域与内存管理

生命周期与作用域的区别

Object的生命周期

栈 (Stack) 与 栈对象

什么是栈？

什么是栈对象 (Stack Objects)？

【C++】LearnCppDate

前言

Day01

Programs and programming languages

【Games101】动画基础

动画概念

动画概述与历史

关键帧动画 (Keyframe Animation)

【Games101】颜色与感知(Color and Perception)

光谱分布 (SPD)

【Games101】相机与透镜

针孔与透镜

【C++】封装与常用关键字

基本概念

封装的概念

访问修饰符

Example

进阶部分

访问控制的边界与编译时检查

【Games101】高级光线传播与复杂外观建模

高级光线传播 (Advanced Light Transport)

无偏与有偏 (Unbiased vs. Biased)

解决“光路难找”的几种高级策略

双向路径追踪 (BDPT - Bidirectional Path Tracing)

【Games101】材质与外观

BRDF 的物理性质

栈 (Stack) 与栈对象