Blender transplantation method based on domestic SW processor

Abstract

The present application discloses a Blender transplantation method based on a domestic SW processor. The Blender transplantation method based on a domestic SW processor includes: transplanting the Mesa3D library in the domestic SW processor; transplanting xvfb in the domestic SW processor, modifying the Blender source code at the same time, forking a process in the main function to start the xvfb process while running Blender; transplanting Blender in an environment with the Mesa3D library and the xvfb. The present application enables the three-dimensional graphics rendering function of Blender to be separated from the graphics card, and realizes rasterization rendering and ray tracing rendering using only the CPU in the absence of a graphics display card device and a graphical interface; in a cross-compilation environment, when the Shenwei processor needs to be used to generate intermediate source files during the compilation process, the use of this method can avoid manual intervention in the transplantation compilation process, simplify the compilation process, and improve the compilation accuracy; for the first time, the transplantation of Blender was realized on the domestic Shenwei supercomputer machine, which can meet the needs of most three-dimensional graphics rendering application scenarios.

Description

Technical Field

[0001] The present application relates to the technical field of program transplantation, and in particular to a Blender transplantation method based on a domestic SW processor. Background Art

[0002] With the development of 3D graphics rendering technology in downstream practical applications such as architectural virtualization, urban planning, scene roaming, effect scene production, real estate development, virtual education, exhibition hall display, historical monument restoration, traffic route design, 3D games, etc., rendering and simulation has also become a huge industry, and has gradually formed a complete industrial chain with software and hardware manufacturing as the upstream, R&D and design software as the midstream, and various specific applications as the downstream. Among them, 3D model dynamic rendering software occupies an important position in the midstream of the industrial chain, and plays an important role in reducing users' learning and operating costs.

[0003] The downstream industries of 3D model dynamic rendering software mainly include many application fields such as industry, manufacturing and education. Specifically, in the construction industry, 3D model dynamic rendering technology presents the architectural effect in the most realistic way, and is widely used in real estate development, scene roaming, exhibition hall display, interior design and other fields; in the field of medical health, 3D model dynamic rendering technology can be used for surgical rehearsal, to build a 3D model according to the patient's condition, so that doctors can fully study the surgical plan in a virtual environment before the operation; in the field of education, according to the basic requirements of teaching and training, 3D model dynamic rendering technology can simulate real experimental and teaching environments, and allow students and trainees to perform virtual operations in a human-computer interactive way as if they were in a real environment, thereby completing experiments and teaching courses; in the automotive industry, 3D model dynamic rendering technology can be used for medical rehearsal, to build a 3D model according to the patient's condition, and to allow doctors to ... Dynamic rendering technology helps the automotive industry in design, development, and sales. In the entertainment industry, 3D model dynamic rendering technology can make games and movies more immersive. In military simulation and combat simulation, 3D model dynamic rendering technology plays an important role in virtual operation training systems, electronic sand table simulation systems, and 3D situation display stations. Specifically, 3D model dynamic rendering software can construct realistic training scenes in virtual operation training systems, simulate realistic natural geographical conditions such as terrain, weather, and traffic in combat zones, and important military targets such as military facilities, fortifications, and troop deployment in electronic sand table simulation systems, and realize 3D terrain loading and display, 3D battlefield target display, 3D geographic information calculation, 3D visualization of confrontation effects, and 2D and 3D synchronous display in 3D situation display stations.

[0004] As the upstream technical carrier of all the above applications, 3D model dynamic rendering software plays an important role in the entire rendering and simulation industry chain.

[0005] The development of domestic alternatives for 3D model dynamic rendering software can better promote the complementation and strengthening of the rendering and simulation industry chain, while reducing the international dependence of core technologies and breaking the foreign technology monopoly. According to Hengzhou Chengsi's market research report, in 2021, the main participants in the global 3D model dynamic rendering software market include Redhound Studios, F10 Studios, Blackpoint Design, Jarvis Design and David Hier Render Studio, etc. my country's 3D model dynamic rendering software accounts for a low proportion of the global market. Using domestically developed 3D model dynamic rendering software to gradually replace the existing 3D model dynamic rendering software can achieve domestic substitution of some application scenarios of the existing 3D model dynamic rendering software in the short term, which can not only solve the long-term disadvantage of the single supply of 3D model dynamic rendering software, but also serve the existing specific scientific research projects downstream. In the long run, the use of domestically developed 3D model dynamic rendering software to completely replace the existing 3D model dynamic rendering software can not only effectively promote the independent innovation and development of the domestic software industry and form independent and controllable core technologies, but also improve the efficiency of parallel computing development from the perspective of the technology chain, targeting the performance bottlenecks of 3D data rendering to generate images and transplantation of vector sets on domestic platforms, give full play to the computing efficiency of multi-core heterogeneous architectures, and forge a complete 3D model dynamic rendering technology system with independent intellectual property rights, providing important theoretical and technical support for many downstream application fields of 3D model dynamic rendering software such as industry, manufacturing, and education. This is of great significance for improving the technical and application capabilities of the rendering and simulation industry chain.

[0006] Supercomputers are an important indicator of a country's scientific and technological development level and comprehensive national strength. They are characterized by powerful functions, fast computing speed, and large storage capacity. They support the calculation of large and complex application topics and are mostly used in national high-tech fields and cutting-edge technology research. "Shenwei*TaihuLight" is the world's first supercomputer with a performance of more than 100PFlops. It is also my country's first supercomputer with completely independent intellectual property rights. At present, its computing power ranks third in the world in TOP500 (ranked first for three consecutive years from 2016 to 2018) and first in China. Its peak performance is 9.3 petaflops. It is equipped with the domestically produced SW26010 heterogeneous multi-core processor, which uses the 64-bit independent Shenwei instruction set and adopts a master-slave core architecture, such as Figure 1 As shown in the figure, a processor contains 4 core groups, each of which contains 1 master core, 1 8*8 slave core array and 1 memory controller. The peak computing power of a single processor is 3TFlops, and the memory access bandwidth is 130GB / s. The "Sunway TaihuLight" supercomputer contains a total of 40,960 SW26010 heterogeneous many-core processors.

[0007] At present, there is no 3D graphics rendering software on the domestic Sunway supercomputer. It will be very meaningful to build 3D graphics rendering software on the domestic Sunway supercomputer platform.

[0008] The software ecosystem of domestic supercomputer platforms is incomplete, and there is currently no software in the field of 3D graphics rendering. There are significant differences between the heterogeneous multi-core processor architecture of domestic supercomputers and the x86 processor architecture. The existing 3D model rendering software running under the x86 system architecture needs to solve a series of related problems such as porting and optimization before it can adapt to domestic supercomputer platforms. The localization of Blender needs to solve the following problems:

[0009] 1. The domestically produced Shenwei supercomputer platform has no graphics card or display device, so the problem of software substitutability in the absence of a graphics card needs to be solved;

[0010] 2. The domestic supercomputer platform environment is complex, and it is necessary to solve the problem of interaction between different processor architectures and different architecture programs during the cross-compilation process;

[0011] Therefore, it is hoped that a technical solution can be provided to solve or at least alleviate the above-mentioned deficiencies of the prior art. Summary of the invention

[0012] The purpose of the present invention is to provide a Blender transplantation method based on a domestic SW processor to solve at least one of the above-mentioned technical problems.

[0013] In this embodiment, the SW processor is a Shenwei processor, and the SW compiler is a Shenwei compiler.

[0014] One aspect of the present invention provides a Blender transplantation method based on a domestic SW processor, the Blender transplantation method based on a domestic SW processor comprising:

[0015] Transplant Mesa 3D library in domestic SW processors;

[0016] Transplant xvfb in domestic SW processors, modify Blender source code, fork a process in the main function to run Blender and start the xvfb process at the same time;

[0017] Porting Blender to use the Mesa 3D library and xvfb as described above.

[0018] Optionally, the transplanting of the Mesa 3D library in the domestic SW processor includes:

[0019] Specify the compiler as SW compiler through variables CC and CXX;

[0020] Set the C / C++ compilation options supported by the Shenwei compiler through the variables CFLAGS and CXXFLAGS;

[0021] Specify the environment variable PKG_CONFIG_PATH to configure the relevant information of the third-party libraries used by Mesa;

[0022] Specify the SW compiler and set the corresponding compilation parameters, start the porting compilation, and complete the Mesa 3D library porting.

[0023] Optionally, transplanting xvfb in a domestic SW processor includes:

[0024] Set the environment variable PKG_CONFIG_PATH to specify the library path that xvfb depends on;

[0025] Specify the sw compiler and related compilation options to start the transplant compilation;

[0026] Modify the input parameters of blender main function, and fork the process in the main function to start the xvfb service.

[0027] Optionally, the porting of Blender in an environment having the Mesa 3D library and the xvfb includes:

[0028] Blender is ported using cross-compilation, where the SW compiler is located on the x86 platform of the domestic supercomputer platform, and the target code generated by the compilation is the SW processor architecture.

[0029] Optionally, the cross-compilation method for transplanting Blender includes:

[0030] Build a compilation environment and install CMake using source code compilation;

[0031] Write the generation process and submission command of the intermediate source file into cmake, execute the submission command through COMMAND, and submit the process of generating the intermediate source file to the Shenwei processor.

[0032] Beneficial Effects

[0033] The Blender transplantation method based on the domestic SW processor of this application has the following advantages:

[0034] a) Blender's 3D graphics rendering function can be separated from the graphics card, and can be rendered using only the CPU when there is no graphics card device;

[0035] b) In a cross-compilation environment, when the Shenwei processor needs to be used to generate intermediate source files during the compilation process, the use of this method can avoid manual intervention in the transplantation compilation process, simplify the compilation process, and improve the compilation accuracy;

[0036] c) For the first time, Blender was ported to the domestically produced Shenwei supercomputer, which can meet the needs of most 3D graphics rendering application scenarios;

[0037] e) It broke the gap in 3D graphics rendering software on the Shenwei supercomputer platform and realized the localization of 3D graphics rendering software;

[0038] f) On the domestically produced Sunway supercomputer, 3D graphics rendering application research can be carried out based on the successfully transplanted Blender, such as high-resolution earth system model data preprocessing and model building research, large-scale parallel accelerated rendering of ocean data, and ocean big data visualization workflow research based on template customization.

[0039] g) Based on the successfully transplanted Blender, with the help of the powerful computing resources of domestic supercomputers, it is promoted to the market to shorten users' rendering time and improve work efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] Figure 1 It is a flowchart of a Blender transplantation method based on a domestic SW processor according to an embodiment of the present application;

[0041] Figure 2 It is a schematic diagram of an input and output system of an intermediate source file of a cross-compilation of a Blender transplantation method based on a domestic SW processor according to an embodiment of the present application;

[0042] Figure 3 It is a schematic diagram of the cross-compilation process of the Blender transplantation method based on the domestic SW processor according to an embodiment of the present application. DETAILED DESCRIPTION

[0043] In order to make the purpose, technical scheme and advantages of the implementation of this application clearer, the technical scheme in the embodiment of this application will be described in more detail below in conjunction with the drawings in the embodiment of this application. In the drawings, the same or similar reference numerals throughout represent the same or similar elements or elements with the same or similar functions. The described embodiments are part of the embodiments of this application, not all of them. The embodiments described below with reference to the drawings are exemplary and are intended to be used to explain this application, and should not be construed as limitations on this application. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of this application. The embodiments of this application are described in detail below in conjunction with the drawings.

[0044] like Figure 1 The Blender transplantation method based on the domestic SW processor shown includes:

[0045] Step 1: Port the Mesa 3D library to the domestic SW processor;

[0046] Step 2: Transplant xvfb in the domestic SW processor, modify the Blender source code, fork a process in the main function to run Blender and start the xvfb process at the same time;

[0047] Step 3: Port Blender to have Mesa 3D library and xvfb as mentioned above.

[0048] The Blender transplantation method based on the domestic SW processor of this application has the following advantages:

[0049] a) Blender's 3D graphics rendering function can be separated from the graphics card, and can be rendered using only the CPU when there is no graphics card device;

[0050] b) In a cross-compilation environment, when the Shenwei processor needs to be used to generate intermediate source files during the compilation process, this method can avoid manual intervention in the transplantation compilation process, simplify the compilation process, and improve compilation readiness;

[0051] c) For the first time, Blender was ported to the domestically produced Shenwei supercomputer, which can meet the needs of most 3D graphics rendering application scenarios;

[0052] e) It broke the gap in 3D graphics rendering software on the Shenwei supercomputer platform and realized the localization of 3D graphics rendering software;

[0053] f) On the domestically produced Sunway supercomputer, 3D graphics rendering application research can be carried out based on the successfully transplanted Blender, such as high-resolution earth system model data preprocessing and model building research, large-scale parallel accelerated rendering of ocean data, and ocean big data visualization workflow research based on template customization.

[0054] g) Based on the successfully transplanted Blender, with the help of the powerful computing resources of domestic supercomputers, it is promoted to the market to shorten users' rendering time and improve work efficiency.

[0055] In this embodiment, transplanting the Mesa 3D library in a domestic SW processor includes:

[0056] Specify the compiler as SW compiler through variables CC and CXX;

[0057] Set the C / C++ compilation options supported by the Shenwei compiler through the variables CFLAGS and CXXFLAGS;

[0058] Specify the environment variable PKG_CONFIG_PATH to configure the relevant information of the third-party libraries used by Mesa;

[0059] Specify the SW compiler and set the corresponding compilation parameters, start the porting compilation, and complete the Mesa 3D library porting.

[0060] In this embodiment, the transplantation of xvfb in the domestic SW processor includes:

[0061] Set the environment variable PKG_CONFIG_PATH to specify the library path that xvfb depends on;

[0062] Specify the sw compiler and related compilation options to start the transplant compilation;

[0063] Modify the input parameters of Blender's main function, and fork the process in the main function to start the xvfb service.

[0064] In this embodiment, the porting of Blender in an environment having the Mesa 3D library and the xvfb includes:

[0065] Blender is ported using cross-compilation, where the SW compiler is located on the x86 platform of the domestic supercomputer platform, and the target code generated by the compilation is the SW processor architecture.

[0066] In this embodiment, the cross-compilation method for transplanting Blender includes:

[0067] Build a compilation environment and install CMake using source code compilation;

[0068] Write the generation process and submission command of the intermediate source file into cmake, execute the submission command through COMMAND, and submit the process of generating the intermediate source file to the Shenwei processor.

[0069] In this embodiment, porting Blender in an environment with the Mesa 3D library and the xvfb includes:

[0070] Transplant the Jemalloc memory management library. The page size of the Shenwei supercomputer processor is 8K. Modify the page size of the Jemalloc library to match the Shenwei processor to avoid page errors during runtime.

[0071] Transplantation and compilation of other third-party dependent libraries. To adapt to the compilation of domestic Shenwei processors, third-party dependent libraries need to be compiled and modified accordingly, including compiler specification, compilation options, etc. Since there are many dependent libraries involved, third-party dependent libraries are uniformly placed in the lib path, and the dependent library path is set through cmake's -DLIB;

[0072] Due to the difference in hardware architecture between the domestic Shenwei supercomputer and X86, it is necessary to modify the compilation strategy of Blender based on the SW processor compilation system of the domestic Shenwei supercomputer so that Blender can be successfully compiled on the domestic Shenwei supercomputer. For example, the cross-platform processing of intermediate source files mentioned above, turning off the function feature switches that are not supported and incompatible with the SW processor, such as the vectorization switch SSE, CUDA, Embree, etc., to avoid compilation errors when using the Shenwei compiler.

[0073] Based on the domestic SW processor, modify the Blender source code and add the Shenwei supercomputer architecture feature macros, such as ARCH_CPU_X86_FAMILY, ARCH_CPU_X86_64, ARCH_CPU_64_BITS and ARCH_CPU_LITTLE_ENDIAN, to support the program construction of Blender under the Shenwei supercomputer architecture;

[0074] Resolve syntax features that are not supported by the Shenwei compiler during the porting process, such as the smart pointer shared_ptr.

[0075] After completing the above steps, Blender has been successfully ported to the domestically produced Shenwei supercomputer.

[0076] In this embodiment, by transplanting xvfb to replace X server and modifying Blender source code, a child process is created to start the xvfb service, and the driverless mesa3D is transplanted to replace the graphics card to implement the OpenGl interface. The EEVEE renderer in Blender uses OpenGL rasterization rendering. OpenGL is an application programming interface for rendering three-dimensional graphics. The implementation is generally provided by display device manufacturers and is very dependent on the hardware provided by the manufacturer. The original intention of the design of the Shenwei supercomputer platform is to deal with scientific computing problems and speed up the calculation speed. It does not have graphics card hardware, so it lacks the interface implementation of OpenGL. This method uses the transplantation of Mesa 3D library to implement the OpenGL interface. Blender uses GLX to create an OpenGL context. GLX is the abbreviation of OpenGL extension to the X window system. It is part of the X protocol and X sever and is already included in the X server code. GLX allows the OpenGL library to be called through X. That is to say, the GLX used in Blender needs to rely on the X server, and the X server relies on the display device. The original design of the supercomputing platform does not require a display device, so the X server cannot be used. This article uses the transplantation of xvfb to replace the X server. Xvfb is equivalent to a virtual Xserver. It has been verified to be adapted to the existing supercomputing platform and can provide Blender with the need to create a context using GLX. Since the Blender software itself needs to run on the Shenwei computing node, and the Shenwei computing node itself cannot install the program, to solve this problem, this method embeds the xvfb process into Blender, forks a child process in Blender to start the xvfb service. This method allows Blender to use the rasterization rendering function of the EEVEE renderer in an environment without a graphics card and a display device.

[0077] In this embodiment, the following method is used to transplant the Mesa 3D library in the domestic SW processor:

[0078] Set the C / C++ compilation options through the variables CFLAGS and CXXFLAGS:

[0079] export CFLAGS="-o2-mieee-mftz"

[0080] export CXXFLAGS="-o2-mieee-mftz"

[0081] Specify the environment variable PKG_CONFIG_PATH to configure the relevant information of the third-party libraries used by mesa:

[0082] export

[0083] PKG_CONFIG_PATH= / xxx / xcb / lib / pkgconfig: / xxx / libX11 / lib / pkgconfig: / xxx / mesa_dep / lib / pkgconfig: / xxx / X11_cv: / xxx / lib / pkgconfig

[0084] Specify the sw compiler and set the corresponding compilation parameters to start the transplantation compilation:

[0085] CC=swgcc CXX=swg++.. / autogen.sh--build=x86_64-redhat-linux

[0086] --host=alphaev6-unknown-linux-gnu --prefix=--disable-llvm-shared-libs

[0087] --disable-libunwind--disable-opencl-icd--disable-llvm

[0088] -with-dri-drivers=no--with-gallium-drivers=swrast--disable-dri

[0089] --disable-dri3--disable-gbm--disable-egl

[0090] After the compilation is complete, execute make install.

[0091] In this embodiment, the following method is used to transplant xvfb in a domestic SW processor:

[0092] Set the environment variable PKG_CONFIG_PATH to specify the library path that xvfb depends on, including freetype, xcb, openssl, etc. as follows:

[0093] export PKG_CONFIG_PATH= / xxx / freetype / lib / pkgconfig: / xxx / xcb / lib / pkgconfig: / xxx / libX11 / lib / pkgconfig: / xxx / mesa / lib / pkgconfig: / xxx / openssl / lib / pkgconfig: / xxx / xvfb_dep / lib / pkgconfig

[0094] Specify the sw compiler and related compilation options to start the transplant compilation:

[0095] CC=swgcc CXX=swg++.. / configure--build=x86_64-redhat-linux--host=alphaev6-unknown-linux-gnu--prefix= / xxx / xvfb--disable-xorg--disable-xnest--disable-xquartz--disable-xwayland--disable-libunwind

[0096] Modify the input parameters of Blender's main function, and fork the process in the main function to start the xvfb service:

[0097]

[0098]

[0099]

[0100] It is understandable that Mesa of the prior art cannot be applied to domestic SW processors. It needs to be re-ported and compiled using the Shenwei compiler, and needs to be ported to a version without driver support. In addition, the Xvfb of this application cannot be installed and run directly. Instead, after compiling an executable program using the Shenwei compiler, a child process is started in the Blender source code to start the xvfb service, and the two are bound to achieve the effect of Blender using the xvfb service.

[0101] In this embodiment, the domestic Shenwei processor adopts a system architecture different from x86, and is designed as a heterogeneous mode containing a master core and a slave core. The platform uses a cross-compilation method to generate an executable program for the Shenwei processor, that is, the compiler generates an executable program for the Shenwei processor architecture under the x86 platform. Since the Blender project is large, involving different programming languages ​​and the generation of intermediate files that need to be relied on during the compilation process, this method designs an interactive compilation method to solve the problem that the intermediate files relied on during the Blender compilation process cannot be generated on the x86 platform, achieving one-click compilation without user intervention, and improving the work efficiency of developers.

[0102] During the compilation process of Blender, some intermediate source files need to be temporarily generated. The generation of these source files is done by executing the corresponding executable program, inputting files in specific formats, such as glsl, pfb, png, etc., and outputting the corresponding c files and header files. Figure 2 shown.

[0103] Because the compilation of the domestic Shenwei architecture platform adopts cross-compilation method, the compilation process is performed under the x86 system, and the generated target program architecture is the Shenwei processor architecture. When processing the generation of intermediate source files, the way the x86 platform and the Shenwei platform interact is designed.

[0104] Specifically, the cross-compilation method for porting Blender includes: writing the generation process of the intermediate source file and the submission command into cmake, executing the submission command through COMMAND, and submitting the process of generating the intermediate source file to the Shenwei processor.

[0105] Before executing the executable program, the entire execution process is controlled by starting a timer. When the timeout occurs, the Shenwei platform will exit and relevant personnel will be notified by email to troubleshoot the problem.

[0106] After the Shenwei processor completes the processing and generates the intermediate source files, the compilation process on the x86 platform continues. Whenever the intermediate source files are needed during the compilation process, this step will be performed until the compilation is completed. Figure 3 shown.

[0107] The cross-compilation method of the present application is different from the existing compilation method in that: 1. cmake itself already supports cross-compilation, and the method is to specify the target platform in the cmake file. The Shenwei processor platform is an independently developed platform that has not yet been made public and cannot be specified in the cmake file; 2. Blender needs to execute an executable program during the compilation process to generate intermediate source files. The executable program is the Shenwei processor architecture, and the current platform is the x86 architecture. It cannot be run directly during the compilation process, which leads to compilation errors. The executable file needs to be manually submitted to the Shenwei computing node for execution, and the compilation continues after the intermediate source file is generated. This process involves more than 400 intermediate source files. Manual submission to the computing node for execution greatly increases the workload of developers, and the compilation process is constantly interrupted. The above method achieves the effect of one-click compilation, making compilation very, very simple, and everyone can compile. The compilation process does not require the intervention of developers, which greatly improves work efficiency and accuracy.

[0108] Although the present invention has been described in detail above with general descriptions and specific embodiments, it is obvious to those skilled in the art that some modifications or improvements may be made thereto based on the present invention. Therefore, these modifications or improvements made without departing from the spirit of the present invention all fall within the scope of protection claimed by the present invention.

Claims

1. A Blender transplantation method based on a domestic SW processor, characterized in that: The Blender transplantation method based on the domestic SW processor includes: transplanting the Mesa 3D library in the domestic SW processor; transplanting xvfb in the domestic SW processor, modifying the Blender source code at the same time, forking a process in the main function to run Blender and start the xvfb process at the same time; transplanting Blender in an environment with the Mesa 3D library and the xvfb; The transplantation of Mesa 3D library in the domestic SW processor includes: specifying the compiler as SW compiler through variables CC and CXX; setting the c / c++ compilation options supported by the SW compiler through variables CFLAGS and CXXFLAGS; specifying the environment variable PKG_CONFIG_PATH, configuring the relevant information of the third-party library used by Mesa 3D; specifying the SW compiler and setting the corresponding compilation parameters, starting the transplantation compilation, and thus completing the transplantation of Mesa 3D library; The transplantation of xvfb in the domestic SW processor includes: setting the environment variable PKG_CONFIG_PATH to specify the library path that xvfb depends on; specifying the sw compiler and related compilation options to start the transplantation compilation; modifying the blender main function input parameter, and forking the process in the main function to start the xvfb service.

2. The Blender transplantation method based on the domestic SW processor as claimed in claim 1, characterized in that: The porting of Blender in the environment with Mesa 3D library and xvfb includes: porting Blender by cross-compilation, wherein the SW compiler is located on the x86 platform in the domestic supercomputer platform, and the target code generated by the compilation is the SW processor architecture.

3. The Blender transplantation method based on the domestic SW processor as claimed in claim 2, characterized in that: The cross-compilation method for transplanting Blender includes: building a compilation environment, installing CMake using source code compilation; writing the generation process and submission command of the intermediate source file into CMake, executing the submission command through COMMAND, and submitting the process of generating the intermediate source file to the SW processor.

Images