What does redux mean in the game?
The game middleware I have encountered---Redux, about Redux:
Recommended courses: C# tutorial.
Substance Redux is a texture processing software plus middleware specifically used for texture generation and compression. According to its user guide, it can optimize texture sets and improve the performance of existing compression algorithms by 50% or more. The compression method can be lossless compression or lossless compression. The compression ratio and image quality can be customized by the user during compression.
Redux can compress and package batch texture files. The operation process is to create a new Project project, import several texture files for the project, and set the compression parameters of each texture. Finally export the compressed file. Redux can compress image files in a variety of formats. If the length and width of the input image are not 2 to the N power, Redux will automatically stretch it to 2 to the N power. The Demo provided by ReduxSDK has the function of decompressing compressed files into DDS format.
The biggest selling point of Redux is its image generation function. It can use several simple graphics elements to generate complex images through algorithms. The graphics elements only need to occupy a small amount of disk space, and the generation method is also saved. It doesn’t take much disk space. According to their official statement, the biggest part of the game that takes up disk space is the texture. Using Redux can reduce the disk space occupied by the texture to the minimum, thus reducing the size of the game’s release package to half at most. 1.
2. Redux compression method
Redux provides 3 texture compression methods:
Redux Mode 1 (Redux Mode 1) is a lossless compression algorithm with the smallest compression ratio in most cases. However, it usually renders the fastest.
Redux mode 2 (Redux mode 2) is a fast compression algorithm that provides high-quality images, but the size reduction rate is about 40%.
Redux mode 3 achieves a rough balance between image quality and size reduction. Image quality is lower than Mode 2, but higher compression ratios are achieved with this mode. The size reduction rate is about 60%.
In actual operation, I compressed 300 DDS files and found that the file sizes generated by Redux mode 2 and Redux mode 3 were the same. I didn't care about the specific compression format of these DDS files at the time. I guess most of them were DXT5.
3. Redux compressed files
Redux mainly compresses batch texture files. The compressed files are divided into two categories. A "header" file that contains the directory of the main data files and provides the location of each texture to the decompression code. This file has a .RDXH extension and stores details about each texture, such as texture name, folder, and path. One or more "data" files that contain the actual compressed textures and have the extension .RDXC. The second type of files will be in "blocks". It is possible to store all textures in one large file so that only one "chunk" of data needs to be processed. For exported compressed "chunk" files, you can have the following three settings:
1. No Chunks (no chunks) - that is, a large data file containing each individual texture in the project;
2. Chunks split according to a size limit - for example, a new chunk is created every 4 MB of data;
3. Chunks split according to content Split blocks) - i.e. create a new block for each texture. At this time, a header file and several chunk files will be generated.
After generating the compressed file, if there are any changes to the original texture file, the compressed file must be regenerated. This kind of compression doesn't quite fit my idea. What I want is to find a compressed file by a texture name, load the file, decompress it and generate the texture. If you use Redux, the engine needs to first load a .RDXH header file and generate a ReduxHandle object defined by Redux. Then find the texture subscript index according to the texture name, and then use the interface provided by Redux to obtain the texture data through the index value. Create a Redux project that contains only one texture file, so that the generated compressed file contains one texture. This is very troublesome and requires a lot of work.
Four. Redux decompression
The Demo provided by ReduxSDK decompresses the compressed file into data that conforms to the DDS format. I have tested its performance: first, use 300 DDS files for testing. The original file size is 59.6M, and if compressed using RAR, the size is 25.9M. The compression format of DDS was not recorded at the time, and it is estimated that most of it was DXT5.
Compression method |
File size |
Loading file time |
Synchronized texture creation time 1 |
Synchronous texture creation time 2 |
No compression |
59.6M |
2355ms |
6172 ms |
6133 ms |
Redux Mode1 Lossless Compression |
19.5M |
743ms |
25016 ms |
24985 ms |
Redux Mode2 40% reduction |
17.3M |
702ms |
25862 ms |
25860 ms |
Redux Mode3 50% reduction |
17.3M |
674ms |
25878 ms |
25911ms |
Redux Mode1 Lossless compression Texture per chunk |
20.6M |
813ms (This is the time when ReduxHandle is created) |
29027ms |
29089ms |
Load local with engine It takes about 8 seconds to create these 300 textures from the file. It takes more than 30 seconds to create 300 textures by decompressing the Redux file, which is 4 times longer than loading locally.
For files of different sizes, the time used to create textures is as shown in the following table:
Texture size |
File Size |
Engine loading creation time |
Redux Mode1 creation time |
Redux Mode2 creation time |
Redux Mode3 creation time |
128*128 |
11K |
1ms |
105 ms |
#31 ms |
30 ms |
1025K |
176 ms |
297 ms |
418 ms |
415 ms |
|
5462K |
242 ms |
2263 ms |
2265 ms |
2294 ms |
The above is the detailed content of What does redux mean in the game?. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

CustomAttributes are mechanisms used in C# to attach metadata to code elements. Its core function is to inherit the System.Attribute class and read through reflection at runtime to implement functions such as logging, permission control, etc. Specifically, it includes: 1. CustomAttributes are declarative information, which exists in the form of feature classes, and are often used to mark classes, methods, etc.; 2. When creating, you need to define a class inherited from Attribute, and use AttributeUsage to specify the application target; 3. After application, you can obtain feature information through reflection, such as using Attribute.GetCustomAttribute();

The core of designing immutable objects and data structures in C# is to ensure that the state of the object is not modified after creation, thereby improving thread safety and reducing bugs caused by state changes. 1. Use readonly fields and cooperate with constructor initialization to ensure that the fields are assigned only during construction, as shown in the Person class; 2. Encapsulate the collection type, use immutable collection interfaces such as ReadOnlyCollection or ImmutableList to prevent external modification of internal collections; 3. Use record to simplify the definition of immutable model, and generate read-only attributes and constructors by default, suitable for data modeling; 4. It is recommended to use System.Collections.Imm when creating immutable collection operations.

When processing large amounts of data, C# can be efficient through streaming, parallel asynchronous and appropriate data structures. 1. Use streaming processing to read one by one or in batches, such as StreamReader or EFCore's AsAsyncEnumerable to avoid memory overflow; 2. Use parallel (Parallel.ForEach/PLINQ) and asynchronous (async/await Task.Run) reasonably to control the number of concurrency and pay attention to thread safety; 3. Select efficient data structures (such as Dictionary, HashSet) and serialization libraries (such as System.Text.Json, MessagePack) to reduce search time and serialization overhead.

Reflection is a function in C# for dynamic analysis and modification of program structures at runtime. Its core functions include obtaining type information, dynamically creating objects, calling methods, and checking assembly. Common application scenarios include: 1. Automatically bind the data model, such as mapping dictionary data to class instances; 2. Implement the plug-in system, loading external DLLs and calling its interface; 3. Supporting automated testing and logging, such as executing specific feature methods or automatically recording logs. When using it, you need to pay attention to performance overhead, encapsulation corruption and debugging difficulties. Optimization methods include caching type information, using delegates to improve call efficiency, and generating IL code. Rational use of reflection can improve the flexibility and versatility of the system.

Create custom middleware in ASP.NETCore, which can be implemented by writing classes and registering. 1. Create a class containing the InvokeAsync method, handle HttpContext and RequestDelegatenext; 2. Register with UseMiddleware in Program.cs. Middleware is suitable for general operations such as logging, performance monitoring, exception handling, etc. Unlike MVC filters, it acts on the entire application and does not rely on the controller. Rational use of middleware can improve structural flexibility, but should avoid affecting performance.

The key to writing C# code well is maintainability and testability. Reasonably divide responsibilities, follow the single responsibility principle (SRP), and take data access, business logic and request processing by Repository, Service and Controller respectively to improve structural clarity and testing efficiency. Multi-purpose interface and dependency injection (DI) facilitate replacement implementation, extension of functions and simulation testing. Unit testing should isolate external dependencies and use Mock tools to verify logic to ensure fast and stable execution. Standardize naming and splitting small functions to improve readability and maintenance efficiency. Adhering to the principles of clear structure, clear responsibilities and test-friendly can significantly improve development efficiency and code quality.

The following points should be followed when using LINQ: 1. Priority is given to LINQ when using declarative data operations such as filtering, converting or aggregating data to avoid forced use in scenarios with side effects or performance-critical scenarios; 2. Understand the characteristics of delayed execution, source set modifications may lead to unexpected results, and delays or execution should be selected according to requirements; 3. Pay attention to performance and memory overhead, chain calls may generate intermediate objects, and performance-sensitive codes can be replaced by loops or spans; 4. Keep the query concise and easy to read, and split complex logic into multiple steps to avoid excessive nesting and mixing of multiple operations.

Generic constraints are used to restrict type parameters to ensure specific behavior or inheritance relationships, while covariation allows subtype conversion. For example, whereT:IComparable ensures that T is comparable; covariation such as IEnumerable allows IEnumerable to be converted to IEnumerable, but it is only read and cannot be modified. Common constraints include class, struct, new(), base class and interface, and multiple constraints are separated by commas; covariation requires the out keyword and is only applicable to interfaces and delegates, which is different from inverter (in keyword). Note that covariance does not support classes, cannot be converted at will, and constraints affect flexibility.
