Z's Blog

Package size optimization: Solution for reusing old-version resources in UE

2026-02-13T09:42:27.000Z

For game projects, we always want players to experience the latest version with minimal cost. This includes CDN costs during operation, as well as the bandwidth and time costs for players during downloads. Smaller, faster, and more efficient are our eternal pursuits.

So, when a game update (what we call a major version update) occurs, must players re-download the entire set of resources?
Large mobile games in the current market have massive resource sizes, often reaching 10+ GB. Requiring a full download for every update is a poor choice for both operational costs and user experience.
However, since players have the full resources of the previous version locally, we can significantly reduce the required download size by leveraging them. We need a mechanism to reuse old version resources!

This article shares a resource reuse solution for major version updates based on this pain point, minimizing player downloads while ensuring ease of release and maintenance.
In actual live project operations, this has achieved excellent results.

Build a Homelab server using an old laptop

2025-12-03T10:39:42.000Z

I have an old laptop from 10 years ago that has been idle for several years. Recently, I tidied it up and repurposed it, deploying a Proxmox environment on the bare metal to turn it into a simple home Homelab server.
It runs Ubuntu and FnOS virtual machines, and with intranet penetration, it can be used as a long-term online VPS or to deploy a NAS system for backing up files and photos.

This article will introduce the complete deployment solution for PVE + Virtual Machines + FRP intranet penetration + Nginx reverse proxy, which can securely expose local area network services for public domain access.

Availability Analysis of UE5 Virtual Assets

2025-09-26T17:34:01.000Z

随着游戏规模和资产精度的提升，以及Nanite等技术的应用，项目工程规模急剧膨胀，达到数百G乃至上T的量级，完整拉取的耗时可能数小时。
而每个人在实际开发中，能够用到的资源只占其中的一小部分，所以怎么样减少工程拉取量级，使工程轻量化是需要优化的问题。
在UE5中，官方推出了虚拟资产(VirtualAssets)机制，与P4结合能够做到这一点。

本篇文章会介绍UE5中虚拟资产的配置流程、资产的虚拟化过程与加载代码分析，以及断网可用性的测试。

UE Hot Update: Updateability and Security

2025-07-17T14:03:51.000Z

In the process of game development, hot update is a very important capability that allows us to update features and fix bugs without replacing the entire package. However, there aren’t many detailed articles currently introducing what can be hot-updated, what cannot, and what carries risks.

In this article, I will introduce my thoughts on hot update capabilities and hot update security during the development of HotPatcher and project hot update practices. This ensures that the hot update capabilities and stability are guaranteed when the project goes online, and that it’s clear what can be hot-updated during the hot update iteration phase, allowing for a good assessment of update risks.
Additionally, by building peripheral capabilities, conducting risk assessments in advance, and automating the hot update process, only the version PM needs to control the patch construction and release timing, with no need for programmers to be involved in the hot update process at all.

UE Plugin and Tools Development: Extensibility Support

2025-07-12T09:54:52.000Z

When developing plugins, as plugin functionalities become increasingly complex, it’s often necessary to provide some extensibility support to implement custom extended features that enrich the plugin’s capabilities, and also to facilitate users in customizing projects without modifying the core program.
In previous articles (HotPatcher’s Modular Refactoring and Development Planning), the support for HotPatcher and extension modules, and how to develop a new module based on HotPatcher were introduced. This article primarily details the specific implementation methods within UE.

Simply put, it means building one’s own extension system on top of UE’s existing plugin system. This article will introduce some of my thoughts and techniques on improving plugin extensibility, and how to conveniently decouple these extension features from the main plugin body for easier maintenance and management.

Encrypted Analysis and Special Protection of PAK in UE

2025-07-11T09:21:59.000Z

UE Plugin Development Series, and will introduce my thoughts and implementations regarding the configurability of plugins during the development process, along with practices in project configuration, task configuration, dynamic parameter replacement, etc., to make the plugin configuration process as flexible and easy to use as possible.

Ultimate Optimization: Reducing the size of UE Android APKs

2025-02-25T09:44:43.000Z

In game projects, when we package for various platforms, we always hope that the package for each platform can be minimized for easier distribution, and there are specific size requirements for some platforms.

For UE, it contains massive code and numerous plugins, and during the Build phase, it generates a lot of reflection glue code, resulting in a significant increase in code segments during compilation. Taking the Android platform as an example, this leads to a sharp increase in the size of libUE4.so, putting pressure on both the package size and runtime memory.

Moreover, some necessary and additional resources brought in by the engine can take up hundreds of MB, making the size of an empty APK easily reach several hundred MB! Not only to meet the platform’s requirements, but it is also necessary to trim down the size of the UE package from the perspective of package size and memory optimization.

This article will take Android as an example and introduce optimization ideas and practices for the cuttable parts in the UE package from various aspects, optimizing both the APK size and the runtime memory usage of native libraries. The strategies can also be reused on other platforms.

UE hot update: Fault analysis of a resource anomaly

2024-10-17T17:30:19.000Z

Recently, I encountered an extremely bizarre bug involving two maps. One map, A, can be accessed with its PAK placed in the engine’s automatic mount directory, but it cannot be accessed from the hot update directory. The other map, B, behaves completely oppositely: it is abnormal in the automatic mount directory but works normally in the hot update directory.

At first glance, the issue appears entirely elusive, with two mutually exclusive behaviors occurring within the same logical framework. Moreover, the hot update mount and the automatic mount only differ in timing and priority, so this problem shouldn’t theoretically exist.

While the issue can ultimately be resolved on the business logic side, this behavior involves another very obscure path within the engine. Understanding why and how it works is crucial. Therefore, I analyzed the engine’s code based on this behavior, came to a reasonable conclusion, and devised a method to detect and mitigate this issue.

This article assumes that readers have some basic knowledge of UE hot updates; if in doubt, please refer to other articles in this blog’s hot update series for more information.

Deploy a self-hosted MEMOS note system

2024-04-13T10:34:01.000Z

For personal knowledge management, I am very keen on creating my own local-first and open source self-hosted services. This way, I can avoid relying on any platform, have complete autonomy over my data, and be able to migrate services at any time. Options like Obsidian, Hexo blog, and the memos introduced in this article all meet these criteria.

The protagonist of this article, memos, is an open-source lightweight note-taking service that allows you to take notes in a way similar to posting on Weibo, supporting TAG marking and citations. It features an account system and permission management, allowing web access at any time, and notes can be public or private, offering great flexibility. I chose it because it complements Obsidian; Obsidian is still too heavy for my needs—it works well on PC but has a poor mobile experience. Thus, I need a lightweight, always-available note-taking service.

This article will introduce how to deploy a Memos service on a VPS using Docker, along with Nginx to bind the domain name, Certbot to issue and automatically update SSL certificates, and regular backups of the memos database, as well as some optimization configurations I made for the service.

Use HotPatcher to accelerate real device resource verification

2024-04-07T18:40:11.000Z

In previous articles, I primarily introduced how HotPatcher can be applied in the hot update process. However, HotPatcher is not just capable of fulfilling the needs for hot updates; it is also a flexible resource packaging framework.

As the project development reaches a certain stage, a massive amount of resources needs to be packaged, and waiting for a complete package to be built can take a long time. If a real device encounters issues, the serial process of repair -> package -> verify can become exceedingly lengthy. There are often cases of script, data, or other resource errors that lead to package abnormalities.

In such cases, waiting hours to generate a complete package prevents smoke testing from proceeding. Even if you rebuild the package, there’s no guarantee that there won’t be other overlooked issues; otherwise, you have to start over again.

Based on this pain point, we urgently need a method to quickly fix resource issues within packages and validate them during the development phase. HotPatcher provides this functionality, allowing you to utilize it fully without waiting for a complete package.

This article will introduce how to utilize the editor features provided by HotPatcher to quickly package preset configurations and specific resources, accelerating the validation process of resources on real devices and significantly improving testing efficiency.

Open source: HotPatcher development progress

2024-04-07T10:01:40.000Z

It’s been more than half a year since the last version of HotPatcher was released. It has good support for UE4, but lacks support for UE5, and many people in the group frequently ask about the adaptation status.

The last Release version of HotPatcher, v81.0, was released on 20230604. It only supported UE5.1.0 and did not support WP and Nanite. Subsequently, Epic launched UE5.2 and 5.3, but the plugin was not adapted. Although compilation errors could be fixed manually, the feature support in UE5 was in a semi-finished state.

Taking advantage of the Qingming Festival holiday, I worked hard for several days, performing comprehensive optimization and adaptation support for HotPatcher. It can now be compatible with the latest versions from UE4.21 to UE5, and a new Release version has been published: v82.0. The latter part of this article will introduce the adaptation status, precautions, and update log of HotPatcher in UE5.

Additionally, in 2020, I wrote an article: Some Thoughts and Ideas on Open Source. Over the past two years, I’ve had some new ideas about maintaining open-source projects, which I’ll summarize here.

Repair your broken iPhone

2024-03-01T14:45:08.000Z

During the New Year’s holiday, my iPhone 12 dropped and caused some malfunctions, making it barely usable. However, recently the battery also swelled and it easily shut down automatically, rendering it completely unusable. After switching to a backup phone, it was set aside for a while.

I recently thought of it again, as it could still power on normally and most of its main functions could still operate, so I speculated that it was only partially faulty and not completely damaged. It would be a pity to completely scrap it, and it seems I can only swap it for a stainless steel basin.

I took it apart to analyze the cause of the faults and attempted to buy parts for repair. This article documents the disassembly and resolution process.

Macau Travel Guide

2024-02-15T15:35:31.000Z

This year, I plan to celebrate the Spring Festival in Shenzhen and the next stop for my Greater Bay Area trip is Macau. Traveling from Shenzhen to Macau is relatively convenient, so I am making arrangements for the trip. I’ve done some research and itinerary planning that can serve as a reference for those visiting Macau for the first time.

Use reflection to create properties cache for assets in UE

2023-10-25T15:27:37.000Z

In the previous article Design and Implementation of Resource Self-Correction in UE, I introduced the implementation plan of filtering using the asset inspection of ResScannerUE, followed by automated processing.

Normally, if you want to check a certain property within a resource, you need to load the asset and retrieve the object:

However, if you want to check the properties of many resources in bulk, loading resources one by one in this way takes a long time, especially in the absence of DDC, where loading resources triggers the construction of DDC cache, which is time-consuming and has a high performance overhead.

As the size of the assets increases, scanning all resources in a project completely can be extraordinarily time-consuming. Therefore, I wonder if it’s possible to implement a method that does not require loading resources but can still retrieve properties within resources.

After research, I found a clever way to achieve this by combining reflection, asset serialization, and the features of AssetRegistry. Moreover, this is a non-intrusive approach that does not require modifying any existing resource type code.

This article will introduce the implementation principles and analyze the related logic in the engine, as well as present the practical application of this mechanism in the project.

Implementation scheme of resource self-correction in UE

2023-10-18T14:45:12.000Z

In a previous article, I introduced the implementation and efficiency optimization of multi-stage and automated resource checks using ResScannerUE in UE.

This already allows for very flexible configuration of resource checks and timely alerts, with very powerful rule expression capabilities. However, they are still limited to the stage of discovering problems for reminders; although there are constraints to prevent submission, manual processing is still required. Especially in cases with a large amount of existing resources, the manpower involved in manual processing is very time-consuming.

Based on this situation, I designed a mechanism for automating resource corrections that can automatically fix resources after rules are established, ensuring that all scanned resources are set to the correct state.

This completes the final piece of the puzzle in my resource check solution and can be applied throughout the scanning process as needed. This article will introduce its design concept and implementation mechanism, as well as some practical application scenarios in projects.

UE plug-in and tool development:j2 design ideas and implementation

2023-10-14T20:23:37.000Z

If I had to choose one recent experience in working with UE that felt the most meaningless and torturous, it would definitely be trying to find a resource in the ContentBrowser based on a long string path.

The inability to quickly jump directly to a directory or resource makes me feel like I’m wasting my life every time I have to navigate deeply nested folders one step at a time.

To address this pain point, I wrote a small tool that significantly alleviates this manual anxiety. I named it j2 (jump to), which is a minimalist ContentBrowser jump tool, open-source on GitHub: hxhb/JumpTo.

This article will introduce the usage of this project, the thought process behind conceptualizing the solution, and the step-by-step code implementation. Although the functionality itself is a very simple plugin, the discovery, analysis, and solution process for the actual pain points is worth documenting.

Build a knowledge management system based on Obsidian

2023-09-07T16:19:40.000Z

In 2020, I wrote an article How to Build Your Own Knowledge System?, which mainly reflects on the daily accumulation of technology, leaning towards methodology.

This article will explore the possibilities of personal knowledge management from the perspective of tools and practical use, based on Obsidian, and attempt to integrate it with the Hexo blog. Of course, this preference for tools and practices has a strong subjectivity; this article is entirely based on my personal practice and experience; there is no best tool, only the one that suits you best.

Hong Kong Travel Guide

2023-08-21T09:37:37.000Z

Shenzhen and Hong Kong are separated by just a river. Although I had long planned to visit Hong Kong, I was unable to do so for the past two to three years due to the pandemic. Now that the pandemic restrictions have eased this year, passing between Hong Kong and the mainland has also become relatively convenient, so I’ve included a trip to Hong Kong in my schedule.

I went to Hong Kong for a weekend trip with my wife. Before we went, I made some travel plans and arrangements that can serve as a reference for first-time travelers to Hong Kong.

UE build improvement: optimize the implementation of remote build IOS

2023-08-16T10:43:50.000Z

Remote building is a very convenient way to package iOS in UE, allowing code compilation only on a Mac without COOKing resources, which greatly reduces the hardware requirements for Mac.

Moreover, Macs are quite expensive. In a traditional setup, if multiple independent iOS package build processes are needed, it usually requires purchasing several separate Mac machines for deployment, leading to high hardware costs.

Additionally, the iOS development environment often needs to be updated with iOS system iterations. Every year at WWDC, a new version of iOS is released, requiring support from the latest XCode, which in turn depends on the latest MacOS—a nested chain of dependencies. If the number of Mac build environments increases, updating the build environments of these machines also becomes a cumbersome repetitive task.

Remote building for iOS can effectively solve this issue. A single independent Mac can simultaneously support multiple iOS build processes, and if an update is needed, it only needs to be handled on one machine. Furthermore, the time it takes to compile code is relatively fixed, and incremental compilation can be performed. In theory, as long as not all machines execute a full compilation at the same time, the performance pressure on the Mac won’t be that great.

There are also articles on enabling remote building for iOS in the blog: UE Development Notes: Mac/iOS Edition, which can be referred to for basic configuration.

However, the default implementation of iOS remote building in UE also presents several issues in actual use, failing to achieve a fully automated process from deployment to building. This article aims to optimize the pain points of remote building in real project applications.

Using AI to help with daily life and development exploration

2023-04-24T17:01:46.000Z

To do a good job, one must first sharpen their tools! AIGC tools represented by ChatGPT and Stable Diffusion have emerged, and the AI wave is sweeping across various industries. As developers, how to leverage AI capabilities to improve efficiency in tasks is a question worth studying.

It is crucial to note that the content generated by GPT may not be entirely accurate and can contain inaccuracies. However, its potential lies in the possibility of achieving a general-purpose AI assistant. No one can possess expert-level knowledge in all fields, but effectively utilizing GPT in unfamiliar domains can significantly lower the entry costs.

In this article, I will introduce some cases of using GPT to assist in work, life, and learning, as well as explore application scenarios for secondary development using the GPT API. At the end of the article, I will share some Prompts I use and recommend some useful GPT tools, as well as a solution for encapsulating Azure OpenAI services using Cloudflare Worker.

DevOps: CI/CD Practices for Unreal Engine

2023-04-15T14:30:56.000Z

DevOps is a philosophy based on automation for Continuous Integration (CI) and Continuous Deployment (CD), optimizing all aspects of development, testing, and operations. It emphasizes the integration of software development, testing, and operations, reducing communication costs between departments or processes to achieve rapid and high-quality releases and iterations.

Although the development situation in the gaming field differs significantly from traditional internet development, leveraging the concept of DevOps to integrate all production elements of a project into automation can greatly enhance efficiency.

This article will introduce the basic concepts of automation in UE and share some of my attempts and actual engineering practices regarding automation builds in Unreal Engine.

Finding Certainty in a Complex World

2023-04-08T14:10:39.000Z

Recently, there is often a strange sense of anxiety. After a period of self-observation and reflection, I believe it is necessary to confront these issues and attempt to provide answers.

This article is a thought experiment that examines and analyzes the current state of life and its problems, summarizing the ideological tools for guiding life and work. As a personal methodology, it contains a large amount of subjective content.

Unreal Resource Management: A raw uasset Encryption Scheme

2023-04-07T12:50:04.000Z

In game project development, a large number of developers from various aspects such as development, art, planning, and outsourcing will be involved. For reasons of resource security and information confidentiality, complex permission controls and synchronization logic are usually implemented.

However, leaving aside permission control and focusing on the resources themselves, in UE, resources are upward compatible, meaning resources can be opened directly with the same version engine or a higher version engine. This means that distributed resources can be used directly in other projects. Therefore, ensuring the security of resources during the development phase is a key focus.

This article provides an idea for encrypting the original UASSET resources in the project and introduces the basic principles that can be used for resource encryption. However, publicly disclosing the specific encryption implementation would be akin to running naked, so this article will only provide an analysis of the uasset resource structure and ideas for implementing encryption, but will not provide specific implementation code.

UE plug-in and tool development:Commandlet

2023-03-23T13:46:03.000Z

When using the Unreal Engine development tool, a significant number of tasks involve resource processing and data export needs. These tasks need to be performed frequently and automatically, often integrated into a CI/CD system.

In the specific implementation, the Commandlet mechanism of UE is utilized to drive the engine in a command-line manner, performing custom behaviors.

Taking the Commandlet features supported in the plugin I developed as an example:

HotPatcher: Export basic package information, pack patches
ResScannerUE: Incremental scanning of changed resources
HotChunker: Standalone packaging of Chunk
libZSTD: Training Shader dictionaries
ExportNavMesh: Export NavMesh data

Commandlet allows for easier integration into CI/CD to achieve automation.

In this article, I will primarily introduce the Commandlet mechanism of UE, analyze its implementation principles, and provide some development tips and insights from my development process.

Additionally, this is the second article in my UE Plugin and Tool Development series, which will continue to be updated, so stay tuned.

Resource Management: Reshaping UnrealEngine Subcontracting Solution

2023-03-15T11:24:32.000Z

I previously wrote an article introducing UE’s default unpacking method (UE Hot Update: Splitting the Base Package), but the default unpacking method in UE is not flexible enough for large-scale resource projects and cannot meet the refined management needs of super-large-scale resource projects.

To address the issues with UE’s default packaging and resource splitting pain points, I developed an extension based on HotPatcherCore that can solve the drawbacks of the default unpacking process, making it sufficiently flexible and powerful. There’s an article on the blog that introduces its overall implementation mechanism: A Flexible and Non-Intrusive Base Package Splitting Solution.

HotChunker can be integrated into UE’s default packaging process non-intrusively, requiring no manual handling. As long as the default UE packaging is done, it will automatically trigger HotChunker’s unpacking process, achieving resource cooking, packaging, and automatic copying to the StagedBuilds directory.

This article will focus on how to configure resource splitting using HotChunker, automate builds, minimize resource redundancy, and implement parallel packaging.

Memory Expansion: Utilize new memory features of IOS in UE

2023-01-31T10:37:38.000Z

Memory optimization is a frequent focus in game development. To avoid excessive memory allocation that triggers an OOM (Out of Memory) to be forcibly terminated by the system, common optimization methods typically start from the usage perspective, enhancing memory utilization efficiency by trimming unnecessary features and controlling resource loading.

However, there is another approach to increase the threshold for triggering OOM, allowing the system to permit our app to allocate more memory. In the new iOS versions, Apple has introduced new memory features for apps, allowing them to extend addressable space and increase allocatable memory.

In this article, I will explore how to leverage these features in UE to enhance the total allocatable memory for games on the iOS platform.

UE plug-in and tool development: basic concepts

2023-01-29T12:12:55.000Z

During the process of project development using Unreal Engine, various types of plugins are often developed and integrated to extend the engine, thereby fulfilling different requirements. For developers, understanding the operational mechanism is more important than using the tools. Thus, it is necessary to understand the principles behind the integration and development of plugins.

Previously, I also developed some tools and plugins for UE, and I hope to write a series of related articles summarizing the common technical content related to UE plugin and tool development and sharing some of my thoughts and functional scaffolding during plugin development. The goal is to achieve the desired functionality with minimal code, minimal invasiveness, and the best implementation strategies.

HotPatcher Modular Transformation and Development Planning

2023-01-07T11:25:54.000Z

With the development of HotPatcher and my research on resource management technology, more and more features are being implemented around HotPatcher, and the implementation is becoming increasingly complex. Coupled with continuous updates of the engine, maintaining compatibility for a large and comprehensive plugin has become more difficult.

With the arrival of the new generation engine UE5, HotPatcher will also follow up with support for UE5 and develop new features based on UE5’s characteristics. I hope it will not only be a resource packaging tool but also include a comprehensive resource management solution encompassing resource management, auditing, packaging, hot updates, package optimization, and build enhancements, and serve as an open resource processing framework.

This article will introduce the modular progress of HotPatcher, support for existing features, and how to use the powerful packaging capability of HotPatcher to customize modular extensions based on project needs. Finally, I will discuss the future development plans for the HotPatcher project.

2022 Unreal Open Day

2022-11-20T10:04:57.000Z

The Unreal Open Day 2022 was hosted by Epic in the form of an offline event combined with online live streaming. I am very happy to have attended the offline Unreal Open Day event this year. I recorded an online technical presentation and also participated in the live event in Shanghai. I am honored to have once again received the Outstanding Community Contributor award granted by Epic, which is both recognition and motivation for me. I look forward to the UE tech community continuing to grow and becoming the most vibrant game developer community. This article serves as a simple record, organizing the materials from UOD 2022, summarizing my participation in UOD, my presentation PPT, and related materials, as well as some photos taken at the UOD live event.

A Flexible and Non-Intrusive Basic Package Splitting Scheme

2022-10-23T15:20:00.000Z

UE’s default resource management is relatively complex. By default, the resource packaging process is executed based on the configurations of maps, directories, and PrimaryAsset specified in ProjectSetting, as well as a combination of condition checks. Furthermore, UE’s Cook dynamically adds resources to the package based on runtime loading, making the resource packaging process almost a black box.

The blog introduces articles on default resource packaging rules and basic package splitting:

This article presents a new idea, utilizing HotPatcher‘s precise Cook and packaging mechanism to implement a HotChunker Mod that can perform non-intrusive, direct reuse of UE’s default packaging process and clearly split the basic package. This article will specifically introduce the usage and implementation principles.

How to write a good technical article

2022-09-12T20:18:36.000Z

Technical articles are an effective way to enhance expression skills and carry out technical accumulation. Unlike simple technical notes, I believe a technical article should be a solution to real problems or new technical ideas, rather than a mere assemblage of technical points.

Regarding how to write a qualified technical article, I have been contemplating this recently. This article will explore some of my thoughts and steps when writing articles, as well as tool recommendations and the implementation of CI/CD automation publishing.

ASTC texture compression analysis and efficiency optimization in UE

2022-09-08T19:01:53.000Z

ASTC stands for Adaptive Scalable Texture Compression, which is a popular texture compression scheme on mobile platforms. When the platform uses ASTC packaging, UE defaults to using the Intel ISPC Texture Compressor for texture compression. However, it has some limitations, only supporting compression specifications of 8x8 and above, while 10x10 and 12x12 are not supported. If specified in the project, it will still use the 8x8 specification. In addition to ISPC, the engine also provides ARM’s astc-encoder compression method, which supports specifications below 8x8, but is not enabled by default. Moreover, the integrated compression efficiency in the engine is very low, and using astc-encoder to compress textures can pose a significant challenge to Cook time in large-scale resources.

This article analyzes the settings for using ASTC compression for textures in UE, as well as the compression efficiency and optimization ideas for the astc-encoder in the engine.

Multi-stage automated resource inspection scheme in UE

2022-08-23T11:30:21.000Z

In large projects, the scale of resources is immense, and the production teams involved are very diverse, including scenes, characters, UI, animations, effects, blueprints, data tables, and so on. Consequently, managing the volume and specification of resources becomes difficult to control.

For the established resource specifications, art production personnel may struggle to cover 100% of the scenarios, potentially overlooking details unintentionally. In most cases, issues are discovered after the packages are created, and for existing resources, a significant amount of manpower is required for handling them, making review and repair challenging.

Based on this pain point, I previously developed a resource scanning tool that allows convenient editing of rules to scan resources within the project.

Recently, I have conducted a comprehensive upgrade of the plugin, enhancing its capabilities during editing and automated checks. This article will introduce how to utilize ResScannerUE to perform resource scans during editing, submitting, CI timed or Hook tasks, and Cooking phases, aiming to expose and prompt solutions to problematic resources as early as possible in production, thus avoiding anomalies in package resources.

In terms of specific implementation, many optimizations have been made for scanning speed, transforming the checking process into a nearly unnoticed action, which will be elaborated upon in the article.

An Efficient ZSTD Shader Dictionary Training Scheme

2022-07-14T13:01:54.000Z

In the article ZSTD Dictionary-based Shader Compression Scheme, I introduced a method for compressing UE’s ShaderCode using ZSTD dictionaries, which can significantly improve the compression ratio of ShaderLibrary. However, the process of training the dictionary and using it for compression remains complex and is not an efficient engineering implementation:

The engine’s default Shader compression must be turned off.
You need to cook the project once to dump the ShaderCode of each unique Shader.
Based on the dumped ShaderCode files, use the ZSTD program to train the dictionary.
Execute a full cook process again to compress using the dictionary and generate the final shaderbytecode.

According to the above process, changing the engine is necessary to dump ShaderCode; moreover, the disjointed workflow means that after dumping ShaderCode, you must invoke the zstd program to train the dictionary; finally, you still need to cook the project again to compress the Shader using the trained dictionary. Additionally, turning off Shader compression will cause DDC Cache Miss with LZ4 compression, leading to significant time overhead from repeated cooking, which is unacceptable in projects with a large number of Shaders.

Based on this pain point, I researched and implemented an efficient dictionary training method that requires no changes to the engine, allowing for rapid training of the dictionary and compression based on that dictionary. It can directly train the dictionary from ushaderbytecode and generate ushaderbytecode using ZSTD + dictionary compression, greatly improving processing efficiency. This is a completely Plugin-Only implementation, with almost zero integration cost, and will later be released as an extension module of HotPatcher.

A runtime reorganization scheme for Pak in Unreal Engine

2022-05-23T11:03:22.000Z

Pak is a part of UFS in UE (Unreal File System), constructed as a virtual file system at the application layer. It is used to package game-related resources and files into a Pak file, avoiding the creation of a large number of file handles when accessing game resources at runtime, and allowing for read caching (PakCache) to enhance loading efficiency.

Moreover, within UFS, the priority of each Pak can be controlled to manage the priority of files in the file system. When loading files through UFS, files in Paks with higher priority will be accessed first, allowing them to replace files with lower priority. This is also key to UE’s implementation of hot updates, as detailed in the previous hot update series article .

However, by default, the packaging of Pak is done on the UE side, with PakUtilities and UnrealPak being developer-side functionalities that do not exist at runtime, meaning Pak files cannot be created during runtime. Nevertheless, Pak itself is in the form of an Archive, which theoretically can be reorganized at runtime.

This article will explore the implementation details and application directions of creating Pak files at runtime by discussing the aspects of Pak creation, file format, UFS analysis, and runtime reorganization feasibility.

Shader compression scheme based on ZSTD dictionary

2022-04-17T17:37:38.000Z

As the scale of projects increases, the number of Shader variants in UE gradually accumulates, often reaching millions of Shader variants. Although UE provides the Share Material Shader Code feature to avoid duplicate storage of Shaders by serializing them into a standalone ushaderbytecode file, it can still occupy hundreds of megabytes of package size. By default, UE places these NotUAsset files in Chunk0, which must go into the base package, significantly affecting the base package for mobile platforms where hundreds of megabytes could hold many resources.

To solve this issue, we can only tackle it from three aspects:

Reduce the number of variants in the project, dump Shader information from the project, and analyze which ones are unnecessary;
Split shaderbytecode so that the base package only contains essential Shaders, while others are downloaded as needed. However, UE does not provide such a mechanism by default, but you can use my developed HotPatcher to split the base package, generate multiple shader libs, and dynamically download resources and required shaderbytecode using the hot update process.
Use a compression algorithm with a higher compression ratio to compress ShaderCode; the engine by default uses LZ4.

The first approach requires collaboration between TA and artists, making significant improvements relatively difficult. The second solution is detailed in previous articles about hot updates (Unreal Engine#热更新). This article starts from the third approach, implementing a special compression method for Shaders that effectively reduces the size of shaderbytecode, significantly improving the compression ratio of Shaders and can be combined with solution 2 to enhance compression while splitting shaderbytecode.

Efficient Debugging: Start UE Android App with command line parameters

2022-01-01T19:58:02.000Z

In the process of using UE development, specifying command line parameters is a frequently used feature that facilitates control over certain processes and toggles. UE also extensively uses Commandline to control the behavior of the engine. The official documentation: Command-Line Arguments, allows different modules to read or check parameters from the Commandline, implementing custom command line parameter functionalities.

However, for the mobile Android platform, it is not very convenient to specify startup parameters; editing the ue4commandline.txt file is quite cumbersome.

Based on this pain point, I developed a UE Android plugin during the New Year holiday that allows Android applications to start and specify command line parameters as conveniently as on PC, without needing to modify the engine. Once the plugin is activated, you can package the APK for use. The project is open-sourced on GitHub: hxhb/AppCmderUE.

This article analyzes how UE reads Commandline on the Android side and introduces the implementation principles and usage methods of the AppCmderUE plugin.

UE Resource Management: Engine Packaging Resource Analysis

2021-12-31T14:33:25.000Z

By default, when packaging a project in UE, BuildCookRun is invoked to execute a series of processes such as Compile/Cook/Pak/Stage. In UE, only the assets involved in Cook will be packaged; however, it often includes many unexpected assets, which can be perplexing. What resources does the engine depend on? And how should we manage the resources involved in packaging in UE?

This article starts with analyzing the rules for resource Cook during UE packaging, studying which resources will actually be Cooked, which is beneficial for resource management. Based on this understanding, a custom Cook process can be implemented, distributing Cook tasks to different processes or even machines to achieve parallelization and accelerate the UE build process.

In addition to resources like uasset, there are many Non-Asset files during packaging, such as ini, Shader Library, AssetRegistry, or script files added to the project, etc. These have been introduced in a previous article UE Hot Update: Demand Analysis and Solution Design. UE’s collection of these resources does not occur during the Cook phase (Shader Library and AssetRegistry are generated during the Cook phase), which will not be discussed further in this article, but a dedicated article will be written later on.

My 2021 Annual Summary

2021-12-23T20:58:35.000Z

I have always hoped that everything I want to do can be quantified and recorded. Otherwise, as the years go by, I won’t remember what I have done. So I will make an annual summary.

As 2021 is coming to an end, reflecting on this year, many things happened, and I had many new ideas. It was also the year that had the greatest impact on me.

Things to Analyze Blog Traffic Data

2021-11-21T10:25:13.000Z

Recently, I checked the access data of the blog Google Analysic, and through traffic analysis, I found some very interesting points that can reflect, to some extent, the user characteristics in game development using Unreal Engine. The data sample in this article is the access traffic from our site for the week of 2021.11.14-2021.11.20. The overall data amount is limited and may not truly reflect real trends, only for reference.

UE5: Game Feature Tech Preview

2021-11-17T12:31:24.000Z

The preview video for UE5 introduces a modular development mechanism for GamePlay, similar to mod-style development and management of game features and resources, referred to as “Game Feature”. This has already been enabled in UE4.27 and UE5. I think this new modular gameplay format is great, so I’ve conducted a technical research.

This article introduces the activation process and operational mechanism of Game Features, and at the end shares a demo based on Game Features. Additionally, I implemented a mechanism in HotPatcher that allows features to be packaged independently; Game Features do not need to be pre-packaged into the base package and can be downloaded and loaded on demand during runtime, achieving true modular loading.

Currently, the UE5 EA version still has some imperfections, and related content will be supplemented as the engine updates.

Open Source an Unreal Engine launcher Project:UE Launcher

2021-11-10T14:17:15.000Z

Usually, when developing projects using UE, there are multiple engine versions locally, and the Epic Game Launcher only supports launching installed engine versions and does not support source-compiled engines. When there are multiple engine versions locally, switching becomes inconvenient, and there is no streamlined tool to launch the engine, projects, and add launch parameters easily. When executing Commandlet, it requires creating many scripts, making management very cumbersome. Based on these pain points, I developed a UE launcher: UELauncher, to solve these issues, supporting both UE4 and UE5.

Automated Resource Scanning and Inspection with ResScannerUE

2021-10-25T15:49:18.000Z

For the resource inspection requirements in the project, it needs to be simple and convenient to configure, automate execution, and be able to promptly locate related personnel. Based on this requirement, I have open-sourced a resource compliance scanning tool ResScannerUE, with configuration documentation: UE Resource Compliance Inspection Tool ResScannerUE.
This article will introduce how to achieve automated resource scanning through this tool, provide support for incremental detection combined with Git, use Commandlet to automatically trigger and execute detection rules for Content content changes on CI platforms, and be able to locate the most recent committers of problematic resources, achieving precise positioning and real-time scanning report sending to corporate WeChat, reminding relevant personnel to take action.
Additionally, I also provide a Git-based Pre-Commit Hook implementation, allowing detection of non-compliant resources before submitting and prohibiting the submission, thus avoiding the contamination of remote repositories with problematic resources. The overall solution has been meticulously designed and extensively optimized for experience and enhanced automation support, making it very convenient to configure and integrate, capable of meeting various resource scanning needs.

Details Panel Customization in Unreal Engine

2021-10-25T09:34:21.000Z

When developing editor plugins in UE, it is very convenient to automatically create property panels using the reflection information of USTRUCT, providing a configurable way, but there are often special customization requirements for the property panels, such as providing special panel options, displaying different types of values based on parameters, etc. The property panels in UE are applied in HotPatcher and ResScannerUE, which can conveniently configure and customize plugins. The official documentation from UE: Details Panel Customization.

This article starts with creating an independent Details panel, and through specific cases in ResScannerUE, provides implementation methods for customizing property panels and property items.

UE Hot Update: Config Overloading and Apply

2021-10-18T14:57:38.000Z

In the UE engine, a large number of configurations are set and controlled using ini files. For projects, understanding which of these can be updated can help establish rules for updating the project. Moreover, many functionalities in UE are realized through configurations and dynamic switches, such as CVars, as well as Device Profiles settings for specific platforms or devices, which can similarly implement dynamic dispatch and application of configurations during hot updates.

This article analyzes the loading process of ini config from the engine mechanism, how different config modules are reloaded after hot updates, and how to apply them in projects, focusing on the runtime modification and reapplication of parameters in the engine or project based on ini configuration hot updates, enhancing the ability to update games.

UE Resource Scanning and inspection tool ResScannerUE

2021-09-15T15:29:18.000Z

In game project development, due to the large amount of resources involved and the broad range of personnel, it’s relatively difficult to consciously unify resource standards. If issues arise with the resources, manually checking them requires a significant amount of manpower. This highlights the risks and pain points in resource management.

Based on this demand, I developed a resource scanning standard tool under the editor, ResScannerUE, which allows for easy configuration of rules and automation. This can be executed by artists before submitting resources or on a regular basis to check whether the resources in the project comply, thus avoiding issues that may only be discovered after packaging.

This article introduces the usage methods, operational mechanisms, ways to extend custom rules, and future optimization arrangements for the ResScannerUE plugin.

UE Hot Update: Shader update strategy

2021-09-13T10:24:16.000Z

In some previous articles, the issue of UE hot updates missing shaders and using default materials has been introduced, along with a Shader Patch solution. For details, please refer to the articles:

UE Hot Update: Create Shader Patch
[UE Hot Update: Questions & Answers#Hot Update Resources Not Working / Material Missing](https://imzlp.com/posts/16895/#Hot Update Resources Not Working-Material Missing).

The fundamental reason for the runtime loss of materials is that the shaders dependent on newly added or modified resources were not packaged, leading to reading failures at runtime. This article will introduce the strategy and pros and cons of shader updates, analyze the mechanisms within the engine, and provide an optimized solution that combines the advantages of Shader Patch and Inline Shader Code, which has been implemented in HotPatcher.

UE Hot Update: binary patch solution for resources

2021-09-06T16:27:10.000Z

A series of articles has been introduced regarding the engineering practices of hot updates in UE, capable of achieving version comparison and differential updates based on resources from the original project. However, by default, resource updates depend on file updates; if a resource changes, the entire file must be repackaged. In UE, resource changes after Cook do not cause the entire file to be updated; only certain bytes are modified during serialization. In this case, a file-based patch mechanism can significantly reduce the size of the patch. This article outlines the generation and loading scheme of binary patches based on HotPatcher, allowing for easy generation of binary patches.

To fulfill this requirement, I have ported HDiffPatch to UE and used it as the default DIFF/PATCH algorithm for binary differential patches in HotPatcher; it can also easily extend other algorithms based on the Modular Feature approach.

UE as Lib

2021-08-24T09:34:30.000Z

UE4.27 has introduced a new mechanism that allows UE to be compiled into a library, enabling it to be embedded in external programs, which can then drive the engine’s execution and message communication. However, the official documentation has not yet been released. I analyzed the relevant code in the engine and proposed a practical solution for UE as Lib, which can theoretically be implemented in engine versions before 4.27, although it may be inconsistent with the official documentation released later. The related research content will also be continuously updated in this article.

Profiling IOS With Unreal Insights

2021-08-19T14:14:48.000Z

Unreal Insights is a profiling tool provided by UE since 4.23, which allows for an easy view of the flame graphs of various threads during game execution. However, the official documentation only provides connection methods for PC and Android, not directly supporting iOS, which is not very convenient. After some research, it was found that the main issue with iOS is related to network policies. This article provides a solution for real-device profiling and port communication between UE and iOS devices, supporting real-time profiling and cook on the fly, as well as data exchange between iOS devices and PCs.

UE Multi-User Collaborative Editing Service Deployment Guide

2021-08-05T16:15:28.000Z

In the context of the large-scale project and the remote working demand caused by the pandemic, collaborative editing under development has become particularly important. In UE’s resource mechanism, maps are single resources; although they can be split using the Sub-level format, the smallest element remains a single resource. When different designers modify the same resource, it can lead to file conflicts, and merging is not as straightforward as with text. Furthermore, when each person is responsible for editing a single sub-level, there is no way to preview the entire scene’s effect in real-time, which is a bottleneck in collaborative development.

After UE4.23, UE officially launched a multi-user collaboration mechanism that allows multiple people to edit the same map simultaneously without causing conflicts. It can also synchronize other changing resources and take effect in real time. As a supplement to version control, it effectively resolves issues of synchronized collaboration.

This article records the enabling process, usage specifications, network strategies, and other issues. It will also extract an independent server-side program without relying on the complete engine, allowing for convenient deployment of the server side.

Comparison of Zlib/Oodle/ZSTD algorithm performance

2021-07-06T19:59:39.000Z

I previously wrote an article about integrating the ZSTD compression algorithm into UE: ModularFeature: Integrating ZSTD Compression Algorithm into UE4, and extracted the Oodle compression algorithm library from UE5 for use in UE4: Oodle Compression. Recently, I analyzed their compression, decompression, CPU, and memory consumption, testing on three platforms: WindowsNoEditor, Android_ASTC, and iOS, as well as the performance of Oodle’s Kraken using different compression levels on different platforms.

A first look at the next generation of UE5

2021-05-25T12:22:44.000Z

Finally, at the end of May 2021, UE5 is set to launch its first preview version, Unreal Engine 5 — Early Access Program starts at 10 PM on May 26, Wednesday China time!.

I have been looking forward to UE5 for a long time; last year, Nanite and Lumen created a huge stir, and after a year’s wait, I finally get to experience it. Over the past year, there haven’t been many technical updates about UE5. I have summarized and analyzed some information disclosed by Epic regarding UE5, which can be found in notes/ue5. This article will document some experiences using UE5, focusing on the changes in development methods compared to UE4, the transition from UE4 to UE5, and a technical pre-research on applying UE5 in production environments. I will keep updating this article in the near future.

UE project optimization: PSO Cache

2021-04-22T19:40:55.000Z

In UE, there is a PSO Cache mechanism, which stands for Pipeline State Object Caching. It is used to pre-record and construct the shader information dependent on the materials used at runtime. When the project first utilizes these shaders, this list can speed up the shader loading/compilation process. The PSO Cache saves rendering states, vertex declarations, primitive types, render target pixel formats, and other data to files, enhancing shader loading efficiency. This article primarily introduces the enabling and construction process of PSO Cache, and will analyze the loading process of PSO Cache in the engine, along with implementing hot-update PSO methods, error handling, etc. The principle of PSO Cache will be analyzed in detail later.

UE Development Notes: Android

2021-04-15T19:54:12.000Z

In a previous article, I introduced the development notes and some engineering practices for Mac/iOS: UE4 Development Notes: Mac/iOS Edition. This article serves as a sister piece, documenting the standardized environment, debugging tools, engineering practices, and analysis of related engine code that I used while developing on Android with UE. It records some pitfalls encountered in the project, primarily organized from my previous notes notes/ue. Future Android-related content will also be updated in this article.

UE Performance Analysis: Memory Optimization

2021-03-30T10:59:16.000Z

In game development, program performance is a crucial issue that needs to be emphasized. To cover the largest possible user base, we must consider the operational effects on mid to low-end devices and ensure compatibility with a wide range of hardware specifications. In this context, it is key to analyze and optimize the performance bottlenecks of the game.

Loading more resources into memory at runtime is essentially a trade-off of space for time. Frequent I/O from the disk is quite time-consuming, and pre-loading resources into memory allows for fast retrieval. However, memory resources are also limited and cannot be used without restrictions, especially for some mid to low-end mobile devices where devices with 4GB or even less memory still have a significant market share. Therefore, it is important to avoid wasting memory, as excessive memory usage may lead to termination by the system.

Memory optimization fundamentally seeks to strike a balance between loading efficiency and memory consumption, aiming to use as much available memory as possible while ensuring that more low-end devices run normally without triggering OOM.

I plan to write a few articles related to performance optimization. This article will start with UE memory analysis, introducing commonly used memory analysis tools and methods, as well as organizing the memory optimization techniques that can be applied in UE projects. This part was previously recorded in the form of notes at notes/ue, and subsequent memory-related content will be added to this article.

UE Hot update: Questions & Answers

2021-03-12T10:45:44.000Z

HotPatcher project has been open source for over a year, undergoing numerous updates and optimizations. It has increasingly been chosen by developers as a hot update solution for their projects. During this time, many have inquired about common issues related to UE4 hot updates, which I noticed frequently repeated, so I decided to organize these common questions to help newcomers quickly troubleshoot the UE4 hot update solution.

This article will continually update the Q&A content related to UE4 hot updates and HotPatcher. If you have any questions, feel free to comment directly on this article. I will periodically consolidate responses. You can also join my UE4 hot update group to discuss encountered issues (QQ group 958363331).

UE Hot Update: Create Shader Patch

2021-03-12T09:49:27.000Z

In the previous series of articles on hot updates, the process and packaging details of UE hot updates were introduced. In fact, there are some engineering practices for optimizing hot update patches that I think can be discussed in detail.

This article starts with the generation of Shader patches, aiming to reduce the size of shaders during each hot update. It will analyze some internal implementation details of the engine, address issues related to Shader patches in the engine, and automate the Shader patch process based on HotPatcher.

2021.11.02 UPDATE: HotPatcher now supports collecting all compiled shaders of Cooked resources in the patch and packaging them into a Shader Library, which can replace the Shader Patch mechanism. For more details, see the article: UE Hot Updates: Shader Update Strategy.

UE reflection impl analysis: reflection code generation (part 1)

2021-03-10T15:14:19.000Z

I previously wrote two articles analyzing the implementation of reflection in UE, introducing the basic concepts of reflection in UE and some of the C++ features it relies on. This article will begin analyzing the specific process of UE’s reflection implementation.

The C++ standard does not have reflection features, and the reflection used in UE is a mechanism based on marker syntax and UHT scanning to generate auxiliary code. As David Wheeler famously said, “All problems in computer science can be solved by another level of indirection,” UHT does just that: it analyzes the marked code before actual compilation and generates real C++ code, collecting metadata regarding reflection types for runtime use.

UHT generates a large amount of code. To avoid organizational confusion in this article, I will mainly discuss the actual C++ code generated in generated.h after UHT processes reflection markers like GENERATED_BODY and UFUNCTION.

The code generated by UHT is located in generated.h and gen.cpp. The code in generated.h mostly defines some macros added to declared classes through compiler preprocessing to introduce common members, while the code in gen.cpp represents the specific code generated by UHT to describe class reflection information, maintaining separation of declaration and definition.

UE Hot Update: asset management and audit tools

2021-03-09T18:16:31.000Z

In the previous article, the rules and implementation of basic package splitting were introduced. After the basic packaging rules are stabilized, the focus in daily development shifts to asset management, package resource auditing, and analyzing asset sizes and redundancy in the project.

This article introduces resource packaging configuration in UE, commonly used asset management methods, and asset auditing tools in engineering practice. It is also a supplement to the previous article UE4 Hot Update: Splitting Basic Packages in the series on resource management for hot updates.

UE Hot Update: split the basic package

2021-01-27T21:51:56.000Z

In previous articles, we introduced the implementation mechanism of UE hot updates and the automation process of hot updates. Recently, we plan to continue writing a few articles to discuss the process and rules of resource package management in UE hot updates.

Of course, different types of projects will have different packaging strategies, and resource management does not have a universal best strategy. This article mainly introduces the engineering practice of splitting the base package in the hot update process, involving the modification of the engine to implement a common splitting method for Android/iOS. We hope to provide some useful ideas for projects in different businesses.

In practical engineering, we abandoned the default package splitting scheme provided by UE and implemented a flexible package splitting scheme based on the HotPatcher framework. For details, see the article: Resource Management: Reshaping UE’s Package Splitting Scheme.

UE hot update: automated process based on HotPatcher

2021-01-24T12:47:34.000Z

HotPatcher is an open-source version management and resource packaging tool for UE4 hot updates that I developed earlier. It allows for convenient differential analysis between versions and pak packaging. Previous articles have visually introduced this based on manual configuration and packaging within the editor. In actual engineering practice, it’s preferable to automate repetitive operations to avoid manual involvement. I added commandlet support to the plugin earlier, and recently, I have fixed some issues and added many optimizations for commandlet. This article discusses the engineering practice of the automated hot update process based on HotPatcher.

Some thoughts and ideas on open source

2020-12-18T22:21:02.000Z

Open source is not just about making the code available; it’s about how to use your code to address real-world needs, continuously iterate and update, and build a community for open source projects. Based on my experiences with open source over the past couple of years, I want to share my views on open source from a developer’s perspective and some thoughts on open source behavior.

UE reflection impl analysis: C++ features

2020-12-13T19:39:37.000Z

In the previous article, the basic concepts of UE’s reflection were introduced. This article begins to explore the specific implementation of UE’s reflection mechanism.

Before introducing UE’s code, some C++ features need to be highlighted. Although UE’s reflection implementation relies heavily on UHT’s code generation, it also requires support from C++ syntax features. Only by understanding these features and their underlying meanings can we better grasp UE’s reflection mechanism.

The C++ features and standards described in this article are based on ISO/IEC 14882:2014, which is the C++14 standard.

UE reflection impl analysis: basic concepts

2020-12-12T23:56:24.000Z

Reflection refers to the ability of a program to perform self-inspection at runtime, which is very useful in the editor’s property panel, serialization, GC, and other areas. However, C++ does not support reflection features inherently. UE implements the generation of reflection information through UHT based on the syntax of C++, thereby achieving the goal of runtime reflection.

In previous articles, some content related to UE’s build system and reflection was discussed.

Articles related to UE’s build system:

Articles on using UE’s reflection mechanism for various tricks:

UE4: Hook UObject

The implementation of UE’s reflection relies on UHT in the build system to perform code generation. This article provides a basic concept introduction to UE’s reflection, and subsequent articles will thoroughly introduce the implementation mechanisms of reflection in UE.

2020 Unreal Open Day

2020-12-05T13:38:15.000Z

The 2020 Unreal Open Day was held in the form of online live streaming and technical sub-forums. I was very happy to participate in this year’s UOD event. I recorded a technical video for UOD and also attended the UOD award ceremony live in Shanghai. I am honored and grateful to Epic for awarding me the Outstanding Community Contributor award, which is both recognition and motivation for me. I will strive to produce more technical content to promote the development of the UE community.

This article serves as a simple record, organizing the materials related to UOD and summarizing the videos, presentation PPTs, and relevant materials I participated in, as well as some photos taken on-site during the UOD live broadcast.

Best practices for UPL and JNI calls in UE

2020-11-15T10:45:27.000Z

When developing Android with UE4, it is sometimes necessary to obtain platform-related information or perform platform-related operations. In such cases, it is essential to add Java code in the codebase and call it from C++. Some requirements also necessitate receiving events from the Java side in the game, requiring handling the Java calling C++ process.

This article mainly involves the following sections:

Adding Java code to UE projects
Java function signature rules
Java calling C++ functions
C++ calling Java functions

How to utilize UE’s UPL features, Java’s signature rules, and implement JNI calls in UE will be detailed in the article.

UE：Hook UObject

2020-11-08T22:35:37.000Z

Hook is a mechanism that allows you to meet your requirements by intercepting and hooking into certain events. Unlike traditional low-level hooks, this article mainly introduces how to use similar hooking mechanisms in UE to achieve business needs.

Some requirements necessitate the global modification of all objects of a specific class, such as playing a uniform sound effect for a certain type of Button in the UI. If every control needs to listen to its OnClicked and then play the sound, it leads to a lot of redundant operations. So, I want to find a method that can globally listen to the click events of all UButtons and handle them collectively. Alternatively, if I want to control an attribute that is invisible in blueprints, modifying the engine’s code for simple needs seems counterproductive.

These requirements can be achieved through UE’s reflection mechanism. This article provides a simple implementation analysis.

BuildGraph：构建支持多平台打包的二进制引擎

2020-11-08T15:40:19.000Z

UE Toolset: Introduction to my open source project

2020-10-11T10:33:56.000Z

工欲善其事必先利其器，本文主要介绍我在使用 UE 的过程中开发的一些开源的工具和插件，能够方便地在项目中使用，提高开发效率。之前简单罗列在资源页面里，今天做一个详细的整理，对各个工具、插件做一些介绍。

How to build your own knowledge system?

2020-10-10T10:08:52.000Z

Learning is like rowing upstream; not to advance is to drop back. This is especially true in the field of CS, where new technologies and frameworks are developing rapidly, and the technical iteration on the business level is very fast. You may become familiar with a technology only to see it quickly become obsolete. Therefore, only by continuously engaging with, understanding, and learning new knowledge and skills can one continually expand their programming career.
This article is a reflection on the technical accumulation I’ve made over the past few years while blogging. Originally intended as a record of the notes revision, I now feel it’s appropriate to separate it into a standalone article. I rarely write reflective pieces, thinking that methodologies are too abstract, but if one has the self-discipline to turn theoretical guidance into action, methodologies are indeed necessary. I hope I can accomplish this as well.

UE integrated WWise: concept and code analysis

2020-09-12T15:31:46.000Z

WWise is Audiokinetic’s cross-platform audio engine that interacts well with game engines, allowing audio designers to handle audio solely within WWise. This separates game logic from audio production and management, providing events and parameters for use in game engines, achieving decoupling with business logic and precision control over audio.

This article mainly introduces the integration of WWise with UE4, remote building, resource analysis, documentation collection, the control interaction between WWise and UE, and code analysis of generated Banks.

UE import atlas: TexturePacker

2020-09-11T15:53:22.000Z

When developing games, a large number of image resources are used, and the purpose of using texture atlases is to reduce DrawCall and improve performance. In UE, there is no packaging tool for texture atlases, and a popular solution is to use the third-party texture packing tool TexturePacker. The new version of TexturePacker supports direct export of UE4 Sprites and can be imported directly into the engine. In earlier versions, it was possible to import data via a Json Array using VaTexAtlas, but compared to the direct export of UE Sprites by TexturePacker, VaTexAtlas does not have an advantage. UE Sprites can be previewed directly, while VaTexAtlas cannot. Given that official support is already available, it is not recommended to use VaTexAtlas as a method for importing texture atlases into UE.

This article mainly focuses on documenting the analysis of TexturePacker atlas generation files, importing into UE, introducing options, and recording the issues encountered while using it in UE.

UE Development Notes: Mac/iOS

2020-09-01T21:45:03.000Z

The main content of this article introduces the deployment of the UE development environment on Mac, configuration of iOS remote packaging, the application of UPL on iOS (intervening in the ipa packaging process), tools and development skills, as well as analysis of related engine code, documenting some pitfalls encountered in the project. It is primarily compiled from my previous notes, and related Mac and iOS content will also be updated in this article in the future.

UE hot update: demand analysis and solution design

2020-05-16T11:22:35.000Z

Game hot updates are a way for players to obtain the latest game content without reinstalling the game. They are widely used in network games on both PC and mobile platforms, as quick adjustments, bug fixes, and content updates are often needed after a game goes live. If even the smallest change requires players to update the app through the App Store, or manually download and install it from a website, and given that different platforms have inconsistent review rules and feedback times, operations could become chaotic.

While there may be relatively mature solutions for hot updates in other engines, comprehensive discussions on implementing hot updates in UE4 are not commonly found. Fortunately, I have previously analyzed and implemented UE4’s hot update mechanism and plan to write a couple of articles to document my thoughts and implementation plans, along with a runnable demo, which I hope will be of help to those who need it.

To conveniently collect and manage common questions and solutions regarding hot updates and HotPatcher, I’ve created a new article to document and organize them: UE4 Hot Update: Questions & Answers. If you encounter issues, please check this FAQ page first.

Integrate ZSTD compression algorithm for UE4 using ModularFeature

2020-04-20T21:52:56.000Z

UE uses Zlib by default as the compression algorithm for packaging resources, but it is not the best choice in terms of compression ratio and decompression speed. The efficiency comparison of various compression algorithms can be seen from the Squash Compression Benchmark. I chose the Facebook open-source ZStandard to replace Zlib, as ZSTD provides a good compression ratio while also having decent decompression speed. This article will not only explain how to integrate a compression algorithm into UE but will also briefly introduce a modular organization method for some features in UE—ModularFeature. Using this method makes it easy to replace certain functionalities, and the replacement compression algorithm in this article serves as a practical example.

I integrated ZSTD into UE by writing a plugin. The source code is available on GitHub: hxhb/ue-zstd, which supports Android, Windows, iOS, and macOS. Feel free to give it a star.

UE hot update: Lua programming guide based on UnLua

2020-03-24T10:50:17.000Z

UE uses C++ as a compiled language, which means it becomes binary after compilation, and players can only update the game by reinstalling it. However, in game development, there’s often an urgent need for requirement adjustments and bug fixes, and frequently prompting players to update the app is unacceptable. Generally, game projects use Lua as the scripting language to transform the immutable C++ code at runtime into updatable Lua code.

Although UE does not officially support Lua, Tencent has open-sourced UnLua, which is being used in my current project. Over the past few days, I’ve organized some materials on UnLua (mainly the official documentation, issues, and presentation PPT) and combined it with my own experience from testing UnLua while writing a small demo, resulting in this programming guide for UE combined with UnLua. This article summarizes some basic methods and pitfalls for using UnLua to write business logic and will be updated continuously.

Additionally, Lua files can be packaged into Pak using my previously open-sourced tool: hxhb/HotPatcher. I’ve also modified a version based on UnLua, adding some extra optimizations. The source code integrates the Luasocket/Luapanda/lpeg/Sproto/Luacrypt libraries, and you can use LuaPanda for debugging. The GitHub address is: hxhb/debugable-unlua.

The Differences and Relationships between UEC++ and Standard C++

2020-02-11T11:22:44.000Z

Due to the impact of COVID-19, I’ve been confined at home throughout the Spring Festival, and I haven’t returned to work yet. I can only read books and organize my notes, hoping the pandemic ends soon and that my friends stay healthy.
The main content of this article is to analyze the differences in syntax between the C++ used in UE development and standard C++. UEC++ is essentially a superset of C++, supporting and utilizing all features of C++, but it has built its own syntax on top of the standard features. Many compilation issues during development can only be quickly and accurately identified at different stages by understanding the boundaries between the two. For those who learned C++ before using UE, this isn’t a problem, but for students who first encounter UE and then gradually learn C++, this can be quite a significant issue.

Standard C++ is based on the language standard ISO/IEC 14882 (C++98/03/11/14/17, etc.), while UEC++ is Epic’s extended usage built on standard C++. This article will not cover topics like GC or reflection or various libraries in UE, focusing instead on the core syntax level.

Modify the default data storage path for Android games

2020-01-22T09:10:02.000Z

By default, after packaging a game with UE and installing the Apk on a phone, launching the game will create the game’s data directory under /storage/emulated/0/UE4Game/ (which is at the root of the internal storage). According to Google’s rules, it is best for each app’s data files to be placed in their own private directory. Therefore, I want to put all the game’s data packaged by UE into the directory /storage/emulated/0/Android/data/PACKAGE_NAME (regardless of whether it’s log, ini, or crash information).
This seemingly simple requirement has several different approaches involving UE4’s path management, JNI, Android Manifest, and analysis of UBT code.

HotPatcher: A open source UE resource hot patching tool

2020-01-15T09:41:30.000Z

Important Notice: The author does not have any platform or channel to record paid courses and does not endorse any commercial activities by third parties. Please stay vigilant and be cautious of scams.
The open source license of this software: Allows free use of features in commercial projects, but does not allow any third party to charge any form of secondary fees based on this plugin, including but not limited to recording paid courses, secondary distribution of the plugin and code, etc.

HotPatcher is a tool used for managing hot updates and resource packaging, aimed at tracking changes in original resources of project versions to generate patches. It supports one-click cooking for multiple platforms, one-click packaging for multiple platform patches, and editor support for Windows and MacOS. Writing a process to download patches from a server creates a complete hot update solution for games. HotPatcher has been used in many UE projects and will continue to update to support new engine versions. Issues are welcome.

HotPatcher differs from the Patch mechanism in UnrealFrontEnd; there are some issues with UE’s Patch management for projects: based on the original project version, it is difficult to generate identical patches on different computers, it is not possible to generate a new patch based on the version of a patch, and the content included in a patch cannot be previewed intuitively. Additionally, it is not convenient to package external files into pak (such as lua files, db, and other non-assets, which often reside outside the Content directory), nor to manage project and patch versions easily.

This plugin is designed to solve such issues by using the project’s original resources as the version basis, only needing to manage the project itself without paying attention to other files generated by UE. It allows easy operations such as cooking, generating pak, extracting resource information from basic packages, diff between versions, and patch splitting. It has very rich configuration options and Commandlet support, making it convenient to achieve an automated hot update packaging process.

The currently supported engine versions are UE4.21-UE5, and support for the IoStore mechanism is provided! Many friends have contacted me privately to inquire about plugin-related issues, so I created a group to discuss UE hot updates and the HotPatcher plugin (QQ group 958363331). You are welcome to join and exchange technical knowledge related to UE.

To conveniently collect and manage common questions and solutions regarding hot updates and the HotPatcher, I have created a new article to document and organize: UE4 Hot Update: Questions & Answers. If you encounter problems, you can check this FAQ page first. Regarding the issue that many people have reported about the inconsistency between the configuration parameters in the plugin and the previous recorded video, it is because the plugin has undergone many updates. You can check the Change Log for detailed changes for each version.

Design specifications and code standards for UE projects

2020-01-01T11:55:16.000Z

Recently, a new project has been initiated, summarizing some issues from previous projects and listing design specifications and code standards for UE development projects (the term “code standards” seems too strict; coding habits are quite subjective, and “coding conventions” would be a better term, but strict execution is necessary for promotion within the team). This article will be continuously updated and organized, and feedback and discussions are welcome.

Become a content creator for the Unreal Engine Marketplace

2019-12-08T22:49:19.000Z

Last week, I uploaded a plugin I had previously written, ExortNavigation, to the Unreal Marketplace. I familiarized myself with the submission process for UE code plugins and would like to document it here.

Export Recast Navigation Data from UE4

2019-11-01T09:18:13.000Z

The latest version supports UE5, see the UE5.0 branch on github: ue4-export-nav-data/tree/UE5.0.

Recast Navigation is an open-source game navigation/pathfinding engine that provides pathfinding calculations for AI in games. Both UE and Unity integrate RecastNavigation to provide navigation and pathfinding calculations for games (of course, in modified versions). The UE modules NavigationSystem and NavMesh contain relevant code implementations. Recently, there was a requirement to export the client’s map information to a server with a non-UE network architecture, for verifying player locations on the server. It occurred to me that the navigation data generated by the client could be exported as a map of the client world, so I tinkered and wrote a UE plugin (open-sourced on Github: ue4-export-nav-data) that implements directly exporting the navigation data generated by UE. If interested, you can directly view the specific code. Based on the exported navigation data, pathfinding calculations based on Recast Navigation can be fully implemented on the server with a non-UE network architecture, seamlessly integrated with UE.

2019.12.04 Update: This plugin has been listed on the Unreal Marketplace, purchase link ExportNavigation. In support of programmer sentiment for open-source, this project’s repository on Github will not be closed, but it is unlikely to be updated. If this plugin is useful to you, feel free to purchase it on the marketplace to support the author.

Oculus Quest Development with UE4

2019-09-24T10:41:10.000Z

Oculus Quest is the new generation of all-in-one VR headset released by Oculus, supporting 6DoF, with no need for a PC connection or additional positioning base stations. It also supports Guardian; when the user walks out of the positioning boundary while wearing the headset, real-world visuals will immediately display in the headset to prevent accidental mishaps.

The Oculus Quest features two Pentile OLED screens, with a single-eye resolution of 1440x1600 and a refresh rate of 72Hz, powered by a Qualcomm Snapdragon 835 processor based on the arm architecture, which is the same as the flagship processors from two years ago (such as Xiaomi 6, Samsung S8).

Quest employs the Oculus Insight (inside-out tracking) positioning solution, using four cameras located at the four corners of the headset panel for positional tracking.
The introduction of Oculus Insight during the release event: Oculus Insight VR Positional Tracking System (Sep 2018)

And a video of a user’s test of Quest’s tracking range abroad: Quest Distance Test.

The 64G storage version of Oculus Quest is priced at $399, while the 128G version costs $499, with tax-excluded prices roughly around 3500; compared to HTC’s similar new product (HTC Vive Focus), it is significantly cheaper, and it offers even greater advantages over PC-Based VR since it does not require a high-performance host. I believe that 6DoF all-in-one VR devices must be the trend of the future!

Before the National Day holiday at OC6, Oculus announced two technologies: Oculus Link and finger tracking, both are impressive and promising.

The entire Quest device is about the same size as a 10.5 inch iPad, making it easy to carry in a small bag:

There’s no need to elaborate on the specifications of the Quest device; the main content of this article will focus on the environment setup, development documentation, debugging tools, and additional considerations when using UE to develop Quest projects, which will be updated continuously.

UE Build System：Target and Module

2019-09-12T13:14:22.000Z

Module is the basic element that constitutes Unreal. Each Module encapsulates and implements a set of functions, which can be used by other Modules. The entire Unreal Engine is driven by the combination of various Modules, and even the game project that we create is a separate Module.

So how does UE create and build these Modules? This is the main purpose of writing this article, to study Unreal’s build system and the various properties they support (Target and Module).

It is recommended to read my previous article before looking at this one: Build flow of the Unreal Engine4 project, which mainly outlines the build process of UE; this article is merely one part of the UE build system.

UE tool chain configuration and development skills

2019-09-09T23:32:08.000Z

工欲善其事，必先利其器！Mastering the right tools can elevate development efficiency to a new level.
This article is a compilation of notes I usually keep in notes about the UE toolchain and some configuration and usage tips for tools using UE. Future content in this area will also be included in this article.
Below are some standalone articles I previously wrote about the UE toolchain or relevant extensions:

Analyzing the content distribution restrictions of EULA in UBT

2019-08-24T14:15:36.000Z

The EULA License Grant/(A) of UE clearly states that content developed using UE and redistributed must not include uncooked source formats or paid content developed based on engine tools. This article studies the specific content distribution details in the EULA and how to technically circumvent this limitation.

PixelStreaming: Basic Concepts and Getting Started

2019-07-30T17:48:27.000Z

PixelStreaming is a technology supported by UE_4.21 that enables games to run on a server, allowing players to play via a browser. The player side requires no additional operation, only needing a browser, while all logic processing and rendering occurs in the “cloud.” It is not merely a plugin (although there is the PixelStreamingPlugin, which is just one part of the PixelStreaming implementation). Its implementation has a distinct design and organizational approach independent of UE games.
This article mainly introduces the basic concepts of PixelStreaming and shares practical experiences with the Demo using PixelStreaming.

UE Modules:Find the DLL and load it

2019-07-16T18:23:29.000Z

On Windows, UE modules are loaded via DLL lookup in non-IS_MONOLITHIC (Monolithic) mode, which means they are not packed into a single executable file. You can call functions like LoadModuleWithFailureReason or LoadModuleChecked from FModuleManager to load a module by passing its string name. This article serves as an extension and supplement to UE4 Modules: Load and Startup, focusing on the details of DLL lookup and loading for modules rather than the timing and order of engine startup and module loading.

UE access to SteamSDK and related information

2019-05-27T23:02:17.000Z

To launch a game on Steam, it is necessary to integrate the SteamSDK. This article briefly introduces the method of integrating SteamSDK in UE4, with future content related to integrating Steam platform services also included in this article.

The integration of SteamSDK allows the game to connect with the Steam community, which has a robust community ecosystem that Epic’s newly launched Epic Games Store cannot currently compete with~(of course, I support market competition).

UE code analysis: GConfig loading

2019-05-27T22:57:58.000Z

The UE4 provides a mature configuration mechanism for INI files, and the engine uses ini as configuration files for both the engine and projects. This article will briefly analyze the loading of GConfig in the engine.

UE development problem notes and data collection

2019-05-27T22:07:50.000Z

In daily development and learning, I have encountered and resolved some issues and collected some materials, which I have casually written down in notes. I have accumulated a fair amount related to UE, while other topics are mixed together and relatively chaotic. I have organized them into this article. Unlike the UE4 and VR Development Technical Notes, the content here is more focused on actual problem records and material collection within projects.

HTC Vive Tracker Developer Guide

2019-04-03T11:41:23.000Z

HTC released the Vive accessory Vive Tracker to expand devices connected to SteamVR. It also features Pogo pins, allowing users to DIY special function accessories. Recently, I’ve seen some amazing creative uses of the Vive Tracker. Relevant materials and technical details are organized in this article.

Create A Standalone Application in UE4

2019-03-30T18:14:46.000Z

Although UE is a game engine, it is not limited to writing games—you can even use it to write Win32 GUI applications 😏. Typically, we create a UE game project using the Editor and build our own classes based on it for use in the game. However, if you don’t want to create a game project, UE also supports Standalone Applications that can construct their own programs autonomously from the main function, fully controlling which Modules to enable without relying on the engine’s own logical architecture. This can also serve as a lightweight method for learning and testing UE modules.

Note: UE does not provide a direct method to create a Standalone Application, so I wrote a tool to create a Program project: hxhb/ue4program, and implemented a demo for a standalone tool: hxhb/UE4Launcher.

LaTeX Mathematical Symbols Quick Lookup Table

2019-03-22T00:27:13.000Z

Recently, while reading The Dragon Book DX12, I’ve been using LaTeX to document some formulas. To facilitate searching, I’ve compiled a table of commonly used LaTeX mathematical symbols syntax. More symbols can be found at LaTeX:Symbols.

Engine Source Analysis: Module Loading and Startup

2019-03-19T11:11:57.000Z

UE is a modular architecture, where Engine/Game Project/StandaloneApplication/Plugins are all Modules (Unreal Engine API Reference lists the Modules provided by the Engine). This article analyzes how UE’s Modules are loaded and started via FModuleManager::LoadModule using the code from FModuleManager.

Build flow of the Unreal Engine4 project

2019-03-16T23:09:52.000Z

UE builds projects through UBT (whether using Build in VS or Compile in the Editor, it eventually calls UBT). UBT and UHT are the cornerstones of the UE toolchain, and due to the vast amount of content, it is impossible to analyze everything at once. Let’s outline the main points now and supplement them later as time allows.

C++ Polymorphism and Virtual Function Table

2019-02-26T13:36:47.000Z

C++ is a language that supports object-oriented programming (object-oriented Programming), with inheritance and polymorphism (Polymorphic) being its most important features. There has been considerable discussion in previous articles about various aspects of C++ inheritance and class member content. This article primarily investigates one implementation method of C++ polymorphism by the compiler: virtual function tables.

The C++ standard ([IOS/IEC 14882:2014]) states:

Virtual functions support dynamic binding and object-oriented programming. A class that declares or inherits a virtual function is called a polymorphic class.

Note: The C++ standard does not specify how polymorphism is implemented, so the implementation of polymorphism by the compiler is Implementation-defined Behavior, meaning different compilers may implement polymorphism differently, and different platforms may yield different experimental results.

UE Package Error:ObservedKeyNames.Num()>0

2019-01-17T09:50:36.000Z

Recently, I encountered a very strange error during the project packaging:

1
2

// package log
Ensure condition failed: ObservedKeyNames.Num() > 0 [File:D:\Build\++UE4+Release-4.18+Compile\Sync\Engine\Source\Runtime\AIModule\Private\BehaviorTree\Decorators\BTDecorator_BlueprintBase.cpp] [Line: 67]

I debugged the UE4 code and analyzed the cause and solution process.

Macro defined by UBT in UE4

2019-01-09T18:17:35.000Z

UE4 Engine defines many macros and some processing logic within the engine, such as WITH_ENGINE/WITH_EDITOR, etc. Some of these are defined by UBT through reading the configurations in *.target.cs files, and some logic is processed by reading configurations in *.Build.cs.

I have read some of the UBT code and extracted part of the configuration files (Target.cs/Build.cs) parameters and their mutual definitions with MACROs as a quick reference manual.
You can view the parameters in *.Target.cs here: UnrealBuildSystem/Targets
You can view the parameters in *.Build.cs here: UnrealBuildSystem/ModuleFiles
UE’s build system documentation: Build Tools

Extract Tor and build Tor Bridge

2018-11-04T19:36:04.000Z

Tor’s Bridge, if widely disseminated, may get blocked within a few days, so frequently changing it can be a hassle (this reminds me of the days when I modified the hosts file to access Google). Today, I tinkered a bit and built a Tor Bridge on my VPS for personal use. Additionally, I extracted tor from the Tor Browser so that it doesn’t rely on the Tor Browser and can be used with other browsers.
Warning: Deploying a Bridge may increase the probability of the server being blocked.

Use of dynamic link libraries: loading and linking

2018-10-15T20:50:34.000Z

In some SDK integrations, some platforms provide only the DLL without an import library for us to use. In this case, we can only use code to load the DLL to call functions within it. This article documents two usage methods and analyzes their pros and cons.

Crawl UE API and generate Dash documents with indexes

2018-07-05T23:43:43.000Z

不知为何，UE API现在已经不随引擎发布chm的离线文档了，官方发布的最新版本还是2014年的，UE发展到现在有了很多变化，显然四年前的API文档已经丧失部分参考价值了。但是UE文档站自身的搜索功能就我的体验而言，十分的烂。
所以折腾了一下把UE API的所有页面爬了下来，并且生成了Dash支持的文档，检索起来十分酸爽。(文后附下载链接)

2022.06.07更新：把API文档更新至UE 5.0.2，可在文末下载。。

Use frp to penetrate the intranet

2018-06-09T11:40:09.000Z

最近想到还有块树莓派在吃灰，今天使用frp折腾了一下内网穿透，把放在家里的树莓派也可以通过外网访问。

UE and VR Development Technical Notes

2018-06-06T08:16:10.000Z

Some technical notes written in the daily cursive about UE4 and VR development, as well as some related materials. Previously scattered in imzlp.com/notes, they have been organized today, and future notes will be placed in this article.

Pass Actor To Next Level Through Seamless Travel

2018-04-28T00:43:40.000Z

Because Unreal Engine destroys all objects in the current level when switching levels (OpenLevel), we often need to retain certain objects for the next level. Today, I read some relevant code, and this article will explain how to achieve this. Unreal’s documentation does mention this (Travelling in Multiplayer), and it’s not too complicated to implement. However, the UE documentation is consistently lacking in detail, especially in Chinese, where resources are very scarce (mostly machine-translated and outdated). I couldn’t find any reliable information during my search, so I took some notes while reading the code implementation.

Build protobuf with MSVC on Windows

2018-02-27T10:01:32.000Z

Recently, I have been using Protobuf in VS, and I will briefly record the process of building Protobuf using MSVC.

Reverse proxy Github Pages to enable HTTPS

2017-09-07T20:49:29.000Z

Due to Github Pages not supporting custom domain HTTPS, I spent some time today setting up a reverse proxy from Nginx to Github Pages on a VPS. I used a certificate issued by Let’s Encrypt to achieve full HTTPS for the entire site (all external resource links were also changed to HTTPS). Here’s a simple record of the process.

Why can't we override && and || and , (comma)?

2017-06-24T22:21:39.000Z

C++ provides two logical operators || and && as well as the , (comma) operator in its basic syntax. We can overload these operators in a class, but we should avoid doing that. In this article, I will outline the standard descriptions and the reasons why they should not be overloaded.

In summary, because the built-in || and && have short-circuit evaluation semantics, overloading them turns them into regular function calls, yielding semantics that are entirely different from the built-in || and &&. Furthermore, the , operator has left-to-right evaluation semantics, so if you overload it, it will also become a function call and result in semantics that differ from the built-in version.

C++ Template Metaprogramming Data Collection

2017-06-17T23:21:33.000Z

This article mainly summarizes my insights during the learning process of template metaprogramming, and I will also include some template metaprogramming code I have written here.

operator new: void* to T* conversion

2017-05-22T18:03:33.000Z

In the C++14 standard (as well as C++98/11), there is a statement in Annex C Compatibility:

Change: Converting void* to a pointer-to-object type requires casting

char a[10];
void* b=a;
void foo() {
  char* c=b;
}

ISO C will accept this usage of pointer to void being assigned to a pointer to object type. C++ will not.

But why does operator new() return void* and allow assigning to T* without an explicit conversion to T*?

How lambda is implemented in the compiler

2017-05-17T23:35:54.000Z

In C++, the result of a lambda-expression is called a closure object. This article is not intended to introduce the usage of C++ lambdas (this is covered in detail in “TC++PL” and “C++ Primer,” or you can refer to my previous summary C++11 Syntactic Sugar #lambda Expressions), but rather to analyze how lambda-expression is implemented in Clang from the perspective of LLVM-IR.

Visibility and accessibility of access control mechanisms

2017-05-13T10:44:06.000Z

In the previous article Breaking the Access Control Mechanism of C++ Classes, we briefly mentioned that the member access control of C++ classes (public/protected/private) only limits the accessibility of member names, rather than their visibility. This article mainly analyzes the consequences of this property and how to avoid them.

Breaking through the access control mechanism of C++ classes

2017-05-12T11:58:05.000Z

It is well known that class members in C++ can have three access specifiers: public, protected, and private:
[ISO/IEC 14882:2014] A member of a class can be

private: that is, its name can be used only by members and friends of the class in which it is declared.
protected: that is, its name can be used only by members and friends of the class in which it is declared, by classes derived from that class, and by their friends (see 11.4).
public: that is, its name can be used anywhere without access restriction.

From the standard’s intention, it aims to hide implementation details and underlying data of a class, which is encapsulation. However, we can also bypass access restrictions through some special means.

C++ Technical Book Reviews Summary

2017-05-06T02:57:42.000Z

Separate an article; previously scattered book reviews were scattered in notes and tweets, and not collected in one place, making indexing inconvenient. In the future, after reading technical books, I will write some comments and put them all here. Since the subjects of the reviews are technical books, mere phrases cannot describe all the technical details. The intent of this article is not “technical notes,” but rather “book reviews,” so I won’t delve too deeply into the technical details described in the books. Instead, I will share my own reading experiences and tips as an ordinary reader. If I express any opinions about certain books, they are my personal evaluations of the books with no intention of demeaning the authors.

Implicit declaration of special member-func and their standard behavior

2017-05-04T23:37:05.000Z

In C++ programming, one of the most frustrating things is that the compiler does too much behind the backs of programmers. This article compiles various situations and actual behaviors of six special member functions: default constructor, copy/move constructor, copy/move assignment operator, and destructor, as outlined in the C++ Standard ([ISO/IEC 14882:2014]). It can serve as supplementary material for “Inside The C++ Object Model,” enhancing the understanding of compiler implementations through standard descriptions.

Additionally, “Inside The C++ Object Model” mainly describes things from the perspective of “compiler implementation,” but from the “C++ standard” perspective, many things in the book are dependent on compiler implementation. For example, the virtual function table; the standard does not specify how the compiler should implement polymorphic behavior, thus it cannot describe details about the virtual function table.

Moreover, many ambiguous interpretations related to the behavior of “compiler-generated” can be addressed here, which is part of the joy of reading the C++ standard—regardless of whether it’s good or bad, the standard specifications cannot be wrong; all implementations that do not adhere to the standard descriptions are unstandard.

Specialization and overloading of C++ function templates

2017-05-04T00:20:56.000Z

Unlike class templates, which can have explicit specializations and partial specializations, function templates do not have the concept of “partial specializations”; they only have explicit specializations and overloads.

Pointers to class members in C++ are not pointers

2017-04-29T21:28:17.000Z

“Pointers to members” is a feature in C++ that is not commonly used. However, the use of the term “pointer” is somewhat inaccurate here, as they do not contain an address, and their behavior is not like pointers. This article will analyze how “pointers to class members” are implemented in clang through LLVM-IR, alongside some definitions from the C++14 standard and related LLVM-IR syntax.

Why is extern "C" needed?

2017-04-11T22:20:00.000Z

In the previous article (C/C++ Compilation Model Analysis), the reasons and methods for compilation and linking in C and C++ were introduced. Following the issues discussed in the previous article, this article starts with extern "C" to analyze the differences and causes in the compilation and linking models of C and C++, focusing primarily on function overload, function signatures, and name mangling.

C/C++ compilation and linking model analysis

2017-04-10T23:05:44.000Z

C and C++ both use separate compilation to support a multi-source file modular mechanism, but why this is done and how it is achieved is a topic worth exploring. This article is not about the syntactic rules that create different linking in C and C++, but rather analyzes how C/C++ compilers implement the compilation and linking model.

Array of length zero

2017-03-30T19:00:01.000Z

I looked at the usage of Array of length zero in C, and I feel quite inspired. However, from a standard perspective (as opposed to compiler extensions), this feature only exists in the C language (after C99) and does not exist in C++. Let’s dig into it.

Analysis of Virtual Memory Page Fault Exception

2017-03-22T01:22:02.000Z

Consider this question: Is it possible to pass the address of an object from process A to process B (where there is no relationship between A and B) through a pipe (fifo), and thus access the object of process A from process B?

Iterator Invalidation of STL Containers

2017-03-17T11:43:47.000Z

The size of a container refers to the number of elements in the container; the capacity of a container refers to the number of elements that the container can hold before reallocating more memory. When resizing or changing capacity, the elements may move to new storage locations. This means that iterators (as well as pointers or references) pointing to the elements may become invalid (i.e., point to the old element locations).
Iterators pointing to elements of associative containers only become invalid when the pointed element is removed from the container (erased). In contrast, iterators pointing to elements of sequential containers may become invalid when memory is reallocated (resize()/reverse() or push_back()) or when the pointed element moves within the container (such as by performing an erase() or insert() at its previous position).

Analyze C++ code semantics through IR code

2017-03-08T11:46:55.000Z

IR code is the Intermediate Code generated by LLVM. By analyzing the IR code, we can understand how the compiler parses and executes the code we write, making the analysis of code semantics clearer. The syntax and semantics of the IR code can be referenced in the LLVM Language Reference Manual.

A brief discussion on fork/vfork

2017-03-06T13:40:08.000Z

In *UNIX, multi-process programming can be implemented using fork/vfork. Here is a summary of the relevant knowledge.

Programming skills and concepts in C/C++

2017-03-05T01:21:25.000Z

Some examples in C++ that can be confusing or have peculiar usages are recorded.

Main-function prototype verification and program termination behavior

2017-02-27T15:30:09.000Z

In C and C++, there are many versions of the main function prototype that circulate, and different books present different ways of writing it. Today, I will explore what constitutes “standard behavior” from the perspectives of several standards (C89/99/11 and C++98/03/11/14) and what happens after the main function returns.

Incompatibilities between C and C++

2017-02-27T15:25:56.000Z

Previously, it has been mentioned several times that C and C++ are not the same language. Even the part inherited from C in C++ has significant differences from ISO C. I will gradually compile some of their incompatible features here.

The difference between declaration and define in C++

2017-02-24T21:09:53.000Z

Many C++ books do not clearly state the difference between declaration and definition, or they only mention the need to support separate compilation, indicating that using the extern specifier is a declaration, while without it is a definition. In fact, I think the C++ standard describes the difference between declaration and definition more clearly.

C++ object construction and destruction order

2017-02-19T18:04:24.000Z

Through a CppQuiz question to describe the order of construction and destruction of C++ objects in the context of inheritance according to the C++14 standard, as well as throwing exceptions during object construction/destruction.

C++ overload and override

2017-02-06T05:08:43.000Z

In C++, overload and override are not related, but they are easily confused due to the similarity of the terms.

Samba Configuration on Linux

2017-02-04T05:29:47.000Z

Through Samba, we can mount folders from Linux to Windows. After deploying Samba on a Linux virtual machine, I can use the remote compilation plugin I wrote a few days ago (sublimeRemoteCompile) to write code on Windows! It’s quite enjoyable. Today, I will briefly record how to configure Samba sharing on the server for friends with similar needs.

Knowledge collection of tools and development environments

2017-02-03T23:39:14.000Z

Some tips on tools and environment configuration or related knowledge concepts are recorded here.

Remote compilation plugin for SublimeText

2017-01-25T01:43:55.000Z

Running some small test codes on Linux from Windows can be quite tedious, especially since I have to manually execute the compilation commands on Linux. Also, using Samba on my Raspberry Pi to share the code to Windows requires me to SSH and compile it manually, which is a waste of time.
These past few days, I wrote a small Sublime Text plugin during my free time to remotely compile C/C++ code on Windows, meaning that I write the code on Windows but it actually executes on Linux. I’ve only implemented the functionality for now, and I plan to optimize it during my break after the holidays.
The code is hosted on GitHub: sublimeRemoteCompile, using some C++11 features, and the compiler must be specified during compilation.

The logic behind array subscript access

2017-01-16T00:59:09.000Z

For arrays, subscript operations are a way of random reading and writing, and they are also the most common method. However, many textbooks (especially domestic ones) state that the array name is a pointer, which is incorrect. Moreover, there are a set of rules behind array subscript access; familiarizing yourself with these rules can help analyze the actual meaning of the code in some complex semantic situations.

Wrap an override member function pointer

2016-12-31T04:02:13.000Z

Using variable-length parameter templates and lambda (or using generic lambda) to wrap overloaded member function pointers for convenient usage (like bind binding or other places that require overloaded member function pointers). For more introduction on member function pointers, please see my other article: Pointers to Class Members in C++ Are Not Pointers.

The C++ Object and Memory Model

2016-12-15T21:11:24.000Z

More documentation:Memory Model and Default Constructor Construction.

Some thoughts on reading

2016-12-11T20:43:42.000Z

How to delineate the most important 20% in an unfamiliar field or book? How to identify trivial details?
I hadn’t deeply contemplated these methodologies in my previous reading and studying, thinking they were merely empty talks. However, I now feel that mastering a suitable technique is like having a sharp blade in hand, allowing one to navigate obstacles with ease.

Reading TC++PL/C++Primer/ISO C++

2016-12-06T23:16:00.000Z

Spent a month reading TC++PL4E. Since I had previously read C++ Primer and understood most of the C++ syntax, the reading speed was quite fast. However, by reading alongside the C++ standard, I discovered many things in C++ that I previously didn’t know. From the perspective of the standard and the father of C++, C++ is indeed comprehensive enough. Thus, I’ll compare C++ Primer, TC++PL4E, and the ISO C++ documentation.

What is POD in C++?

2016-12-03T00:04:28.000Z

POD is Plain Old Data. In C++, it refers to objects that can be treated as “data only,” where programmers do not need to worry about the complexity of class layout, as well as user-defined constructors, copy, and move semantics.

Radical ADL (Argument-dependent lookup)

2016-11-29T22:39:14.000Z

ADL is the abbreviation for Argument-dependent lookup, which in Chinese translates to 参数依赖查找. ADL is useful for avoiding verbose code, but it can also cause some ambiguity.

TC++PL4E Chinese and English Edition Errata

2016-11-20T21:46:53.000Z

最近在读The C++ Programming Language Fourth Edition(简称TC++PL4E)，由于我入的实体书是中译本(原版好贵)，所以我是对照着英文版PDF看的，发现了一些原版和中译本中的勘误，还有一些我觉得书中歧义的地方，查阅标准(ISO/IEC 14882:2014(E))之后的定义也一并贴出，汇总在这里列出来。

Some excerpts from the C/C++ standard

2016-11-12T01:19:51.000Z

There are countless resources on C/C++ available online, but I often find that, after reading some articles, it seems the authors themselves don’t fully understand what they wrote (looking back at my own earlier articles, my perspective was too one-sided and superficial at that time). Therefore, for C/C++ materials, I believe it’s essential to refer directly to the standard documentation, as standards do not introduce ambiguities. One should not blindly search the internet and trust second-hand digested materials.

I think consulting these four documents is enough for understanding the features of the C/C++ languages (click to preview online or download):

ISO/IEC 9899:1999 (E) (C99 standard)
The C Programming Language Second Edition (The major work of C language creators Dennis Ritchie and Brian Kernighan)
ISO/IEC 14882:2014(E) (C++14 standard)
The C++ Programming Language Fourth Edition (Written by the father of C++, based on the C++11 standard)

The reason the C language standard does not follow the latest C11 standard is that the current C++ standard (C++14) references ISO/IEC 9899:1999 in its Normative references, which means TCPL and TC++PL can serve as applicable descriptions for the C/C++ standards and can corroborate each other.

For more about C++ Normative references, refer to ISO/IEC 14882:2014(E) §1.2 Normative references.

I will gradually extract some commonly ambiguous language features from the standard norms here to ensure that what I write is backed by the standard documentation.

Some interesting questions and analysis of CppQuiz

2016-10-24T06:15:05.000Z

CppQuiz is a simple online quiz that you can use to test your knowledge of the C++ programming language.
It’s quite interesting; I wrote down a few questions I encountered today. I’ll add more here whenever I have time. In fact, many questions in CppQuiz can be explained by “Deep Exploration of C++ Object Model”… If you find yourself struggling with many questions, I recommend buying a copy of “Deep Exploration of C++ Object Model” and reading it thoroughly!
In addition, I will try to find relevant descriptions in the C++ standard (ISO/IEC 14882:2014) while answering questions.

Automatically deploy Github/Coding Pages blog using Travis CI

2016-10-21T06:36:49.000Z

This blog has switched to Github Action for automated deployment.

Using Hexo to generate a static blog and then deploying it to Github/Coding Pages is currently how my blog is hosted. It’s quite enjoyable to use, but there are several issues:

The environment configuration for Hexo is too cumbersome; it’s almost impossible to update the blog when changing to a new computer.
Each time I modify an article, I have to regenerate everything.
Additionally, the number of command executions for submitting the blog source files is too high (mainly the first step).

I wasted a lot of time submitting articles, so I optimized the process to almost achieve fully automated submissions.

Boost source code analysis notes

2016-10-19T21:39:33.000Z

Recently, I’ve been reading the Boost code and writing some analyses on the usage and implementation of useful modules in the Boost libraries, with updates to come periodically.

Configure SublimeText for Boost dev-environment

2016-10-13T09:24:16.000Z

Recently, I would like to study the Boost library. Most tutorials available online are based on using IDEs (such as VS/Code::Blocks), but I find it frustrating to have to open a bloated IDE just to write some test code. Today, I fiddled around and managed to compile/link code that uses the Boost library in SublimeText. I also organized the process/tools I worked with, so if others have similar needs and happen to see this article, they can save some time.

2016.11.01 Update
I used the latest version of MinGW64-GCC6.2 (x86_64-6.2.0-posix-seh-rt_v5-rev1) to compile LLVM/Clang 3.9, and then I used the compiled Clang to compile Boost1.62. The error messages that occurred when linking the Boost library in Clang are gone now.
Note: When compiling Boost with Clang, it is best to ensure that the current version of clang is compiled from the version of gcc in the current system; otherwise, when linking the static libraries produced by clang, strange issues might arise.

You can download my compiled versions here: MinGW62-GCC6.2(x86_64-6.2.0-posix-seh-rt_v5-rev1), LLVM/Clang3.9 compiled with GCC6.2 (above MinGW version), and Boost(MinGW64-GCC6.2/LLVM3.9/VC14-ALL). You can choose the version of the linked library (debug/release/static, etc.) as needed.
You can download the full compilation toolchain here.

Deploy shadowsocks service using Docker

2016-10-10T22:10:01.000Z

Arukas is a Japanese Docker service provider that is currently in the testing phase and can be used for free. We can easily use Docker to do some interesting (useful) things, such as deploying our own blog or shadowsocks server.

Using Git for version control in UE4

2016-10-07T23:31:01.000Z

The Source Control provided in Unreal Editor allows you to implement basic functions such as version submission/version comparison/reverting changes through Git for blueprint projects, which is far less powerful than Git Bash, but the Diff between BluePrints is still very useful.

Git Quick Start Guide

2016-09-29T22:19:37.000Z

Our company recently set up an intranet server. From now on, all projects will use Git for version control. I’m documenting some common operations here for easy reference.

Add case string matching to C++ switch

2016-09-24T22:43:23.000Z

The switch in the C++ standard cannot implement string case matching, but we often have this need, so let’s implement it.

Summarize some of my coding habits

2016-09-13T07:26:09.000Z

At the beginning when writing code, I always rolled up my sleeves and got to work as soon as I encountered a problem, essentially writing code while debugging and simultaneously designing the solution flow. However, this approach is simply too slow, often leading to writing and deleting code, effectively resulting in a poorly designed code structure requiring refactoring, which wastes a lot of time.

Reading "D&E" and answers to some questions

2016-09-09T08:15:46.000Z

C++ Language Design and Evolution is a book written by C++ author Bjarne Stroustrup, discussing the thought process and trade-offs from the conception and design to the actual implementation of C++. It is arguably the only book on the market written from the perspective of a language designer on language design.

There are many issues where we should not only know How, but also understand Why, as this allows for a deeper comprehension of the subject. Fortunately, “C++ Language Design and Evolution” is precisely that kind of book. Recently, I realized many aspects of C++ that I only knew How but did not understand Why (too much was sacrificed for compatibility with C), and this article serves as a reading note and a record of Why, which I will gradually organize.

Capturing 360° panoramic video with Unreal Engine 4

2016-09-05T19:44:11.000Z

This article excerpts some content from the official Unreal Engine blog post: Capturing Stereoscopic 360 Screenshots, Videos, Movies in Unreal Engine 4, while the rest corrects errors in that article and provides a ready-to-use solution.

Reading CSAPP: Comparison with Modern Operating Systems

2016-08-30T01:32:15.000Z

These past few days, I’ve been enthusiastic about reading CSAPP, and I even posted yesterday that reading CSAPP is more enjoyable than reading Modern Operating Systems (haha).

Dynamic memory and smart pointers

2016-08-25T08:18:53.000Z

Smart pointers, as one of the most important features of C++11, were originally recorded in C++11 Syntactic Sugar, but this part is so important that I have recently been relatively free (逃) and decided to summarize it in detail separately.

Source Insight plugin and configuration

2016-08-14T08:08:31.000Z

Recently, I’ve been experimenting with a few development-related tools that can be considered artifacts. As the saying goes, “A workman must sharpen his tools before he can work well.” I’ll take some time to organize and write about it.

Use VisualGDB to write Linux programs on VS

2016-08-08T00:53:42.000Z

As a C++ developer and Linux user, I often write code on Linux. Recently, I discovered VisualGDB (a VS plugin), which is a fantastic tool that allows me to write and run programs directly on Linux from Windows! The debugging experience is even better!

Deploy shadowsocks service on VPS

2016-07-27T20:34:32.000Z

In the past few days, I helped a colleague set up a VPS for proxy use and organized some related materials along the way. This article is not aimed at beginners. Before reading the following content, you should first have a VPS that can access the external network (foreign network), and secondly, you should have some basic knowledge of Linux operations.

Some books and tools for learning C/C++

2016-06-12T12:08:43.000Z

From the time I began learning C language to now, it has been five or six years, during which I have read quite a few good and bad books, tried many tools (the holy war of compilers/editors), and here I will summarize everything in detail. After messing around for a long time, I have come to a kind of thought, which is different from the “take-it-for-granted” mindset; it is an experience of “doing it yourself.”

2016: Future Plans

2016-06-10T09:52:32.000Z

It’s hard to believe that I will soon graduate from university. Although I have learned (and struggled with) quite a lot during my time at university, I still feel that I need to improve and keep working hard.
I have a few thoughts about the future, and I will write them down at this moment to motivate myself.

Talk about the college entrance examination

2016-06-08T07:44:11.000Z

These days are the time for the college entrance examination, and it reminds me of a few years ago when I took the exam. Back then, I was still too young, thinking that if I had something I wanted to pursue, I should go for it, wasting a lot of time learning programming. But looking back now, it’s important to study hard in high school, as a degree is indeed a threshold for just graduating.

Pthread multithreaded programming

2016-06-04T17:08:48.000Z

POSIX Threads (English: POSIX Threads, commonly abbreviated as Pthreads) is the POSIX thread standard that defines a set of APIs for creating and manipulating threads.

Memory leak caused by deleting void* pointer

2016-06-04T10:51:47.000Z

When a void* points to a class object, performing a delete operation on it will lead to undefined behavior—it is certain that this delete operation will not call the object’s destructor, resulting in a memory leak.

Memory alignment problem of structure members

2016-06-02T10:12:34.000Z

Before discussing memory alignment, let’s first introduce a related concept—offset.

The distance between the actual address of a storage unit and the segment address where it is located is called the intra-segment offset, also known as the “effective address or offset.”

In simple terms, in a structure, the offset refers to the difference between the address of a member in a structure variable and the address of the structure.

C language does not have a native bool type

2016-06-01T19:46:55.000Z

It seems a bit clickbaity; to be precise, there is no bool keyword in the C language standard to represent boolean types. In C++, we usually use bool variables to store logical values. However, there is no bool type in C; C only has the _Bool type. Today, when discussing this issue with someone, it can indeed be confusing, so I’m writing it down for future reference.

Turning the Raspberry Pi into a portable Linux compilation environment

2016-05-25T09:04:52.000Z

I have a Raspberry Pi 2B+ that has been collecting dust for quite a while. Due to frequent power outages at school, I haven’t used it for running scripts or downloads. However, recently, the SSH connection to the VPS has been dropping due to power/network issues, which has been quite frustrating. So I’ve decided to turn the Raspberry Pi into a portable compiling environment.

Some misunderstandings about compiler-generated default constructors

2016-05-18T19:38:50.000Z

When a class we write does not explicitly provide a constructor but the compiler needs a constructor (be sure to note this phrase), the compiler will generate one for us. However, the default constructor generated by the compiler does not meet our expectations of what it can accomplish.

Operating system interprocess communication

2016-05-17T19:48:04.000Z

The methods for achieving inter-process/thread communication include:

Inter-process communication methods: file mapping, shared memory, anonymous pipes, named pipes, message slots, clipboard, dynamic data exchange, object linking and embedding, dynamic link libraries, remote procedure calls, etc.
Thread synchronization methods: events, critical sections, mutexes, semaphores.

C++11 syntactic sugar

2016-05-12T22:30:19.000Z

From C language to C++03, the OO features feel absolutely great. Recently, I focused on the new features of C++11 and found many fantastic syntactic sugars! It’s also very enjoyable to use.

Memory leak caused by STL releasing pointer elements

2016-05-08T13:51:13.000Z

When we delete a pointer, the object it points to will be deleted. However, this does not happen when pointer objects are stored in an STL container.

Use Gprof to analyze code performance bottlenecks

2016-05-07T13:32:34.000Z

Using profiler to analyze the performance of code is more efficient, detailed, and intuitive than pure cognitive analysis.

Detailed analysis of type conversion in C++

2016-05-04T19:35:17.000Z

In C++, when the operand types of an operator are inconsistent, these operands will be converted to the same type. Type conversion is divided into implicit conversion and explicit conversion.

Summary of some object-oriented knowledge in C++

2016-04-16T17:31:49.000Z

近期准备求职面试。
将C++中面向对象部分的基础知识复习整理一下。

Select member and non-member impl of operator-override

2016-03-21T16:54:58.000Z

When designing classes to overload operators, it is essential to choose whether to implement the operator as a member or as a regular non-member function.

Reading "Life" and discussing the choices we face

2016-03-20T14:07:26.000Z

"please enter the password before reading."

Usage of placeholder modifier * in C/C++

2016-03-19T11:49:16.000Z

In the process of solving problems, I came across this code snippet for formatting output: printf("%*s%s%*s\n",__________);
The required output format is: ________123456________//The underscores represent spaces

Ambiguity caused by incorrect use of macro definitions in C++

2016-03-14T19:07:46.000Z

When writing code, the macro (#define) command is often used. Recently, I encountered two instances where macros were misused, so I’ll analyze them here.

Configure SublimeText as a lightweight IDE for C/C++

2015-12-26T21:54:01.000Z

As a C++ programmer, I have long been accustomed to using tools like GCC, but I must say that GCC’s error messages are terrible. Although there are error prompts, it often requires manual debugging to understand them… Now, the good news is here, the accuracy of Clang‘s messages is incomparably better than that of GCC.

Using Wolfram|Alpha to Evaluate Integrals

2015-12-24T20:52:35.000Z

Actually, using WolframAlpha to compute integrals is quite overkill (but it’s also a strict requirement for laziness). Recently, I’ve been studying Wolfram Language and slowly discovering new ways to play with it.

Use Koding to manage static blogs online

2015-11-27T13:16:33.000Z

Previously, I would complete articles on local and then publish them, having already set up a bunch of things like node.js, hexo, git, etc. on my own computer. So, it’s very convenient to use on my computer, but if I switch to another computer, it’s tragic; everything needs to be configured by myself, so I almost end up in a non-usable state whenever I change computers.

Reading "The Beauty of Mathematics"

2015-10-24T18:22:02.000Z

I have had “The Beauty of Mathematics” for some time now, and as a book I’ve been reading during my leisure time, it has indeed piqued my interest a great deal. Since I don’t allocate much time to reading, averaging only one or two chapters a day, I finished all the chapters yesterday and was left wanting more.

Analyzing the Mathematical Principles in Cryptography

2015-09-09T18:19:26.000Z

Recently, I’ve been intrigued by the mathematical models in computers discussed in “The Beauty of Mathematics” and the number theory from “What is Mathematics.” Today, I managed to suppress my laziness for a moment, and I’m going to analyze the mathematical models in cryptography!

Deploy Shadowsocks service on Linux

2015-08-26T17:31:57.000Z

These past few days, I reinstalled Linux and wanted to avoid using GUI for SS. The information online wasn’t very useful, so I experimented a bit.

Extract the RSS source of Youku subscription videos

2015-08-19T14:56:12.000Z

I’ve been tinkering with RSS these past few days and have collected quite a few RSS sources. For lazy people like us, knowing the news without opening a webpage is what RSS is truly about. Recently, I managed to get the RSS output for QQ Space (not very practical…) as well as for Sina Weibo and Sina Blog. However, I still prefer Logic Thinking (on Youku), which does not provide an RSS subscription. So far, I haven’t discovered any particularly effective methods to extract Youku subscription RSS feeds. Various online conversion sites are mostly useless, and I can’t tolerate the hassle of having to open a webpage to do this. So, I decided to dive into how to turn Youku subscriptions into an RSS feed, and I succeeded! It was very satisfying.

Customize Dvorak keyboard layout under Windows

2015-08-19T11:01:32.000Z

After several twists and turns, I finally sorted out the Dvorak layout in Windows (though with some modifications).
Let’s start with the layout diagram of Dvorak.

Chrome plugin recommendation

2015-08-18T14:50:26.000Z

LastPass: Free Password Manager
A powerful password manager, from now on you only need to remember one password.
Momentum
On how to elegantly use Chrome, a beautiful wallpaper every day.

Pocket
Read later, better organization on the computer after shopping on mobile.

Constructors of containers in STL

2015-08-18T12:44:55.000Z

Note: All initializations in this document are based on the following container

// Create vector<int> container test and assign values to it
vector<int> test;
for(int i=0;i<10;i++)
	test.push_back(i);

C++ floating point rounding

2015-08-18T12:39:17.000Z

Recently, while organizing my notes, I discovered a strange issue:

Sequential and associative containers in C++

2015-02-18T13:26:31.000Z

C++ STL’s concepts and usage of sequential containers and associative containers.

Basic C++ syntax

2015-01-20T11:50:59.000Z

C++ Basic Syntax Concepts Organization.

C/C++ Cheat Sheet

2015-01-15T23:56:13.000Z

A sorted C/C++ cheat sheet, regularly organized and placed here for convenient reference.

Write some of my own feelings: my software major

2015-01-04T22:32:01.000Z

This article is a post previously published at my school, discussing my past experiences and views on learning programming, intended to provide some insights for junior students in the software major. It was recently dug up, and since I almost forgot about it, I’ll tidy it up and share it here.

Use Github to manage blog source files

2014-11-20T23:52:01.000Z

Hosting the source files of the blog (non-hexo generated files) on GitHub for easy synchronization and version control.

Deploy an independent blog using Github Pages and Hexo

2014-11-18T11:11:11.000Z

Previously, I found using Blog Garden quite unsatisfactory, and I also tried building my own blog. WordPress is too bloated, and other options don’t have strong functionality (the interface doesn’t look good). After thinking it over, I decided to use GitHub Pages + Hexo to build a static blog, focusing on writing.

As of 2021.03.23, I have been using Hexo to deploy my blog for nearly six years. During these six years, I have written more than a hundred articles, and the way I deployed using Hexo has undergone many changes; writing blogs has gradually become a habit. I vaguely remember one day in college when I wanted to build my own blog, so I spent a day working on this article, and the history of this site began from there. I hope I can continue to use Hexo to write for ten years or twenty years!

BulletinBoard

2014-01-01T00:00:00.000Z

Welcome to my blog. This is a technical site focused on game development. My open-source projects on GitHub: