WO2021253641A1 - Shading language translation method - Google Patents

Abstract

A shading language translation method. In the method, an abstract syntax tree of a code file in the original shading language is obtained, and keywords of nodes in the abstract syntax tree are analyzed to obtain shading language information contained in the code file in the original shading language. In combination with a set information mapping rule, the shading language information can be translated to obtain a code file in another shading language. In this process, node analysis is performed on the basis of the abstract syntax tree, and the original syntactic structure of the code file in the original shading language is retained. Moreover, analysis is performed on the basis of the keywords of the nodes, so that corresponding translations among different types of information are realized, and the improvement of the readability of translation results is facilitated; in addition, the information mapping rule can be updated according to actual needs, so that the expansibility of a language translation method is improved, and the quick support for a new shading language syntax is facilitated.

Description

Coloring language translation method

cross reference

This application is cited in the Chinese Patent Application No. 2020105396814 named "Method of Coloring Language Translation" filed on June 15, 2020, which is fully incorporated into this application by reference.

Technical field

This application relates to the field of data processing technology, and in particular to a coloring language translation method.

Background technique

Shading Language (Shading Language) is a type of shading language specifically used to program shaders. At present, a high-level shader language (HLSL) developed and owned by Microsoft is more popular in the industry. However, HLSL can only work on Windows (an operating system developed by Microsoft) platform, which in turn leads to the problem of restricted use of target platforms running other operating systems.

In the prior art, there is a way of translating HLSL code into code usable by the target platform through a disassembly operation. However, the code obtained by disassembly operation translation has the defect of poor readability, which is not conducive to optimization and debugging on the target platform. Therefore, a new solution needs to be proposed.

Summary of the invention

In view of the above-mentioned problems, the present invention is proposed to provide a coloring language translation method that overcomes the above-mentioned problems or at least partially solves or alleviates the above-mentioned problems.

According to one aspect of the present invention, a color language translation method is provided, which includes: performing syntax analysis on a first code file corresponding to the first coloring language to obtain an abstract syntax tree of the first code file; The keywords of multiple nodes in the tree are analyzed to obtain the coloring language information of the first code file; according to the set information mapping rules, the coloring language information of the first code file is translated to obtain the second A second code file corresponding to the coloring language; wherein the information mapping rule is determined according to the grammatical rules of the first coloring language and the second coloring language.

The beneficial effects of the present invention are: node analysis is performed based on the abstract syntax tree, and the original syntax structure of the code file of the original coloring language is retained. At the same time, node-based keyword analysis realizes the corresponding translation between different types of information, which is conducive to improving the readability of the translation results; in addition, the information mapping rules can be updated according to actual needs to improve The scalability of the language translation method is improved, and the new coloring language grammar can be supported quickly and conveniently.

The above description is only an overview of the technical solution of the present invention. In order to understand the technical means of the present invention more clearly, it can be implemented in accordance with the content of the specification, and in order to make the above and other objectives, features and advantages of the present invention more obvious and understandable. In the following, specific embodiments of the present invention will be cited.

Description of the drawings

By reading the detailed description of the preferred embodiments below, various other advantages and benefits will become clear to those of ordinary skill in the art. The drawings are only used for the purpose of illustrating the preferred embodiments, and are not considered as a limitation to the present invention. Also, throughout the drawings, the same reference symbols are used to denote the same components. In the attached picture:

FIG. 1 is a schematic flowchart of a coloring language translation method provided by an exemplary embodiment of this application;

2 is a schematic flowchart of a coloring language translation method provided by another exemplary embodiment of this application;

FIG. 3 is a schematic structural diagram of an electronic device provided by an exemplary embodiment of this application;

FIG. 4 is a schematic structural diagram of a server provided by an exemplary embodiment of this application;

Fig. 5 is a schematic structural diagram of a computing program product provided by an exemplary embodiment of the application.

Specific embodiment

The present invention will be further described below in conjunction with the drawings and specific embodiments.

In order to make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be described clearly and completely in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments It is a part of the embodiments of the present invention, but not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present invention.

In view of the technical problem that the existing coloring language translation method cannot translate and obtain a highly readable translation result, in some embodiments of the present application, a solution is provided. The following describes each embodiment of the present application in detail with reference to the accompanying drawings. Provide technical solutions.

FIG. 1 is a schematic flowchart of a coloring language translation method provided by an exemplary embodiment of the application. As shown in FIG. 1, the method includes:

Step 101: Perform syntax analysis on a first code file corresponding to the first coloring language to obtain an abstract syntax tree of the first code file.

Step 102: Analyze keywords of multiple nodes in the abstract syntax tree to obtain the coloring language information of the first code file.

Step 103: Translate the coloring language information of the first code file according to the set information mapping rule to obtain a second code file corresponding to the second coloring language; wherein, the information mapping rule is based on the first coloring language. The language and the grammatical rules of the second coloring language are determined.

Among them, the abstract syntax tree (Abstract Syntax Tree, AST) is an abstract representation of the source code syntax structure. It expresses the grammatical structure of the source code in a tree structure, and a node on the tree structure represents a structure in the source code.

Among them, the key of the node may be the key of the variable corresponding to the node. The keyword can be the name of the variable in the code corresponding to the node, or the character string contained in the variable, which is not limited in this embodiment.

Wherein, the operation of obtaining the abstract syntax tree of the first code file can be implemented based on the syntax tree generator, which is not limited in this embodiment. For example, when the first code file is implemented as the source.hlsl file of the HLSL shading language, the HlslParser open source software can be used to extract the abstract syntax tree of source.hlsl to obtain source_AST.

Wherein, the mapping rule includes: a variable mapping rule between the first shading language and the second shading language; and/or, a function between the first shading language and the second shading language Mapping rules.

Wherein, the variable mapping rule and the function mapping rule are determined according to the grammar rules of the first shading language and the second shading language. The variable mapping rule is used to translate the variables involved in the coloring language information of the first code file, so as to translate the variables in the first code file into variables that conform to the grammar of the second coloring language. The function mapping rule is used to translate the functions included in the shading language information of the first code file, so as to translate the functions in the first code file into a function conforming to the syntax of the second shading language.

Among them, the first shading language is applicable to the first platform, and the second shading language is applicable to the second platform. The first platform and the second platform may be platforms equipped with different operating systems. Based on this embodiment, the shading language suitable for the first platform can be translated into the shading language suitable for the second platform, so as to realize the cross-platform flexible use of the shading language.

In this embodiment, node analysis is performed based on the abstract syntax tree, and the original syntax structure of the code file of the original coloring language is retained. At the same time, node-based keyword analysis realizes the corresponding translation between different types of information, which is conducive to improving the readability of the translation results; in addition, the information mapping rules can be updated according to actual needs to improve The scalability of the language translation method is improved, and the new coloring language grammar can be supported quickly and conveniently.

Generally, some words are defined internally in translation tools, and these words are called reserved words. Reserved keywords cannot be used as variable names or process names. Therefore, in order to avoid using reserved keywords, the first code file can be preprocessed, which will be illustrated below.

In some optional embodiments, the variable to be processed may be determined from the first code file, and the name of the variable to be processed contains the same character string as the reserved keyword in the translation tool. Next, the name of the variable to be processed can be modified to avoid the occurrence of reserved keywords during the translation process.

Optionally, the variable to be processed includes at least one of a global parameter variable named Buffer, a variable whose name contains the character string Texture, and a variable whose name contains the character string Buffer. Optionally, when the name of the variable to be processed is modified, the name Buffer of the global parameter variable in the first code file may be set to Cbuffer; and the name of the variable in the first code file may be The texture of is set to texture; or, the Buffer in the name of the variable in the first code file is set to buffer.

Step 103 of the foregoing embodiment records a solution for analyzing the keywords of multiple nodes in the abstract syntax tree to obtain the coloring language information of the first code file. In some optional embodiments, the first code The coloring language information of the file includes: information about the global parameter variable structure in the first code file, information about the resources in the first code file, information about the structure in the first code file, and the first code file. At least one of the function information in the code file.

In the following, taking any one of the multiple nodes as an example, the process of analyzing the keywords of the node will be exemplified.

It should be noted that the Shader involved in the following embodiments refers to a code file that stores a shading language, for example, an HLSL file, a GLSL file, or a SPIR-V file, and will not be explained one by one in the following.

In some optional embodiments, for any node of the plurality of nodes, the key variable corresponding to the node is determined according to the type keyword of the node; then, the key variable corresponding to the node is analyzed to obtain the The coloring language information corresponding to the node. After traversing the abstract syntax tree, the coloring language information corresponding to each of the multiple nodes can be obtained, and then the coloring language information of the first code file can be obtained according to the coloring language information corresponding to each of the multiple nodes.

For nodes, the basic type of the node can be determined based on the type keyword of the node, and the basic type of the node is used to describe the coloring language information stored by the node.

Optionally, the type keyword of the node may include: at least one of a global parameter-passing variable structure, class definition, structure definition, variable, function definition, function declaration, sampler, and function call type.

Taking the first code file implemented as an HLSL code file as an example, in the HLSL code file, the node type keywords and the corresponding shader functions can be as shown in Table 1 below:

Table 1

Basic types of nodes	Shader function
CBuffer	Global parameter variable structure
Class	Class definition
Struct	Structure definition
Variable	variable
FunctionDefinition	Function definition
FunctionDeclaration	Function declaration
SamplerState	Sampler
FunctionCall	Function call

Among them, the key variable corresponding to the node refers to the variable that stores the coloring language information of the node. By analyzing these key variables, the coloring language information stored in the node can be obtained. Among them, when the node type keyword is different, the key variable of the node is also different.

For example, when the node stores resource information, the key variable of the node may be a register allocation variable (RegisterAllocationOptData variable), and the register allocation variable contains the register information of the resource.

For example, when the type of the node is a function definition (FunctionDefinition) or a function declaration (FunctionDeclaration), the key variables of the node may include: a function type (FunctionType) variable, a function parameter variable (FunctionParamsOptData), and a code block variable (Block). Among them, the FunctionType variable stores the return type information of the function, FunctionParamsOptData stores the parameter information of the function, and the Block contains all the statements inside the function.

For example, when the basic type of a node is a function call (FunctionCall), the node will have an argument variable (ArgumentList), which contains the parameters passed in when the function is called.

For another example, when the basic type of the node is a structure (Struct), the node will have a class member declaration variable (ClassMemberDeclarations), which contains the member variable information in the structure.

Based on the above, the key variable of the node can be determined according to the type keyword of the node, and the key variable of the node can be analyzed to obtain the coloring language information corresponding to the node.

Optionally, if the type keyword of the node is a global parameter variable structure, then the type variables and name variables of the child nodes of the node are parsed to obtain the global parameter variable structure contained in the global parameter variable structure Type and name; the type and name of the global parameter variable contained in the global parameter variable structure should be stored in the variable dictionary.

Continuing to take the HLSL code file as an example, when the basic type of a certain high-level node in the abstract syntax tree is "CBuffer", all child nodes of the node can be parsed. Among them, each sub-node can parse out the information of a global parameter variable. For each child node, by analyzing the type variable (Type variable) and name variable (Name variable) of the child node, the name and type of the global parameter variable corresponding to the child node are obtained. Then, save the information of all global parameter-passing variables in the global parameter-passing variable structure into a global variable dictionary. Optionally, the global variable dictionary can be recorded as GVariableDictionary.

Optionally, if the type keyword of the node contains a character string representing a resource, the name variable and register allocation variable of the node are parsed to obtain the name and register address of the resource; the name and register address of the resource correspond to Saved in the resource dictionary.

Optionally, the resource includes: at least one of a texture resource, a buffer resource, and a register resource. The following will be described in combination with the above-mentioned multiple resources.

Optionally, if the value of the type variable of the node contains a string representing the texture resource, the value of the name variable of the node is obtained as the name of the texture resource; then, the register allocation variable of the node is parsed to obtain the The register address of the texture resource; then, the name of the texture resource and the register address are correspondingly saved in the texture dictionary.

Continuing to take the HLSL code file as an example, when the Type variable value of the syntax tree node contains the string "Texture", the Name variable value of this node can be recorded as the name of the texture resource corresponding to the node, and the RegisterAllocationOptData of this node can be parsed. Variable, get register address. Then, save the texture resource and the corresponding register address in a global texture resource dictionary, which is recorded as GTexutreDictionary.

Optionally, if the value of the type variable of the node contains a character string representing the buffer resource, the value of the name variable of the node is obtained as the name of the buffer resource; then, the register allocation variable of the node is parsed to Obtain the register address of the buffer resource; then, the name of the buffer resource and the register address are correspondingly saved in the buffer dictionary.

Continuing to take the HLSL code file as an example, when the Type variable value of the syntax tree node contains the string "Buffer", the Name variable value of this node can be recorded as the name of the Buffer resource, and the RegisterAllocationOptData variable of this node can be parsed to obtain The address of the register corresponding to the Buffer resource. Next, save the Buffer resource and its corresponding register address in a global register resource dictionary, which is recorded as GBufferDictionary.

Optionally, if the type of the node is a sampler, the value of the name variable of the node is obtained as the name of the sampler; then, the register allocation variable of the node is parsed to obtain the register address of the sampler; then, Save the sampler's name and register address correspondingly in the sampler resource dictionary.

Continuing to take the HLSL code file as an example, when the basic type of the advanced node of the syntax tree is "SamplerState", the Name variable of this node can be recorded as the name of the sampler resource, and the RegisterAllocationOptData variable of this node can be parsed to obtain the sampler resource The address of the register. Then, record the sampler resource and its register address in a global sampler resource dictionary, and record it as GSamplerDictionary.

It should be understood that when the foregoing implementation manner is executed, the abstract syntax tree can be traversed to obtain information about all texture resources, all buffer resources, and all sampler resources in the first code file. Among them, the information of all texture resources in the first code can be stored in GtexutreDictionary, all buffer resources can be stored in GbufferDictionary, and all sampler resources can be stored in GsamplerDictionary, which will not be repeated here.

Optionally, if the type keyword of the node is a function definition or a function declaration, the function type variable and name variable of the node are parsed to obtain the return type and function name of the first function, and the The type and name of the formal parameter variable are written into the information of the first function.

Among them, the function type variable is the Type variable of the node, and the name variable is the Name variable of the node.

Continuing to take the HLSL code file as an example, in this implementation manner, all function information can be recorded in a global dictionary, which is recorded as GFunctionDictionary. When the basic type of the node in the abstract syntax tree is "FunctionDefinition" or "FunctionDeclaration", this node can be recorded as Fnode, and the function corresponding to this node is recorded as function F0. Next, get the return type of function F0 from the FunctionType variable of FNode, and get the function name of function F0 from the Name variable.

Further optionally, the type variable and the name variable of the child node of the function parameter variable of the node may be parsed to obtain the type and name of the formal parameter variable of the first function.

Among them, the function parameter variable can be the FunctionParamsOptData variable corresponding to the node. Each sub-node of a function parameter variable represents a formal parameter variable. Therefore, the type and name of each formal parameter variable of the first function can be obtained by analyzing the type variable and name variable of each sub-node of the function parameter variable.

Optionally, if the formal parameter variable of the first function includes a formal parameter variable with an out or inout attribute, then the formal parameter variable with an out or inout attribute is recorded in the information of the first function.

Following the above HLSL example, the child nodes of the FunctionParamsOptData variable of FNode can be analyzed. Each child node of the FunctionParamsOptData variable represents a formal parameter variable, and the type and name of each formal parameter variable can be obtained according to the Type and Name variables of each child node. Among them, if the type of one or more formal parameter variables is modified with out or inout, these variable information can be additionally recorded in the information of the function F0.

Further optionally, the subtree corresponding to any child node of the code block variable of the node can be obtained; if the type of the first node in the subtree is a function call, the name variable and the actual parameter of the first node are parsed Variable to get the function name and parameter passing information corresponding to the first node; then, in the function dictionary, query the function name corresponding to the first node and the target function corresponding to the parameter passing information as the calling function of the first function . Among them, the code block variable can be the Block variable corresponding to the node. For any child node of the code block variable, a subtree with the child node as the root node can be obtained as the subtree corresponding to the child node.

Among them, the actual parameter variable may be the ArgumentList variable of the first node. Among them, the first node refers to any node in the subtree whose type is a function call.

Continuing with the above HLSL example, we can analyze the Block variable of FNode. Each child node of the Block variable represents each statement implemented by the function. Let a (any) child node of Block be FNode_B_C, and obtain the subtree with FNode_B_C as the root node from the abstract syntax tree, and analyze the subtree. When the basic type of a node in the subtree is "FunctionCall", a function name can be obtained according to the value of the Name variable of the node, and the formal parameter information can be parsed from the ArgumentList variable of the node. Among them, each child node of ArgumentList represents a function to pass parameters. Then, according to the function name and parameter information obtained by the analysis, go to the GFunctionDictionary to find it. If the corresponding function is found, record this function as F1, then add F1 to the list of calling functions of function F0.

Optionally, on the basis of the foregoing embodiment, based on the subtree, information about the resources used by the first function can be further obtained. An exemplary description will be given below.

Embodiment D: Optionally, if the second node in the subtree uses the first global resource, the information of the first global resource is written into the information of the first function; the first global resource includes texture At least one of resources, buffer resources, and sampler resources.

Continuing to follow the above HLSL example, we can continue to analyze the subtree with FNode_B_C as the root node. When a certain node in the subtree is found to use a certain global resource, record the information of this global resource in the information of function F0 . Among them, if function F0 uses multiple global resources, such as Buffer, Texture and sampler resources, you can record Buffer, Texture and sampler resources respectively.

Embodiment E: Optionally, if the third node in the subtree uses the first global parameter passing variable, the information of the first global parameter passing variable is written into the information of the first function.

It should be understood that in this article, the terms "first", "second", "third" and other terms are used to limit the objects that need to be described, which are only used to facilitate the description and distinguishing of objects with the same or similar names, and do not apply to the above-mentioned objects. The chronological order, positional order or level constitute any restriction, and will not be explained one by one in the following.

Continuing with the above HLSL example, we can continue to analyze the subtree with FNode_B_C as the root node. When it is found that a node in the subtree uses a global parameter variable, record this global parameter variable in the information of function F0 information.

Based on the foregoing embodiments, the coloring information of the first function corresponding to the node can be obtained, and then the information of the first function can be stored in the function dictionary.

Among them, when recording the information of the first function, in the variable information used to record the parameter variable, the main member variables shown in Table 2 are defined:

Table 2

When recording the information of the first function, the function information defines the main member variables as shown in Table 3:

table 3

In some optional embodiments, according to the abstract syntax tree, all the functions in the first code file are obtained, and after all the function information is recorded in the function dictionary, the functions in the function dictionary can be further filtered to determine the first code file. A function actually used when the code is running, thereby reducing the workload of subsequent function translation operations.

Optionally, determine the entry function from the function dictionary; starting from the entry function, use a depth-first search method to search for each function called by the entry function; record the searched function called by the entry function to the target Function collection.

Continuing to take the HLSL code file as an example, the GFunctionDictionary generated in the foregoing embodiment can be traversed, and when the name of a certain function is found to be "main", it is determined that this function is the entry function, which is recorded as MainFunc. Then, starting from the entry function, use the depth-first search method to search for each function it calls. Record the searched function into a global dictionary and record it as GusedFunction. The function in the GusedFunction dictionary represents the set of functions actually used in the current shader. Furthermore, functions that are not called can be removed in the subsequent function translation process, which reduces the amount of translation calculations and streamlines the translation results.

Optionally, if the type keyword of the node is a structure definition, the name variable of the node and the child nodes of the class member declaration variable are parsed to obtain the name of the first structure corresponding to the node and the first structure The information of the class members included; the name of the first structure and the information of the class members included in the first structure are stored in the global linked list.

Optionally, in order to further obtain the type of the first structure, the function dictionary may be traversed to determine the entry function from the function dictionary; if the first structure matches the return type of the entry function, the first structure is determined A structure is an output type structure; if the first structure matches the type of the formal parameter variable of the entry function, it is determined that the first structure is an input type structure.

Continuing to take the HLSL code file as an example, when the basic type of the node in the abstract syntax tree is "Struct", the Name variable value of the node can be recorded as the name of the structure corresponding to the node. Among them, each child node of the ClassMemberDeclarations variable of the node represents a structure member. Therefore, each child node of the ClassMemberDeclarations variable can be parsed to obtain all structure member information of the structure to be structured. Then, you can save all structure member information in the structure. Among them, after obtaining the information of all the structures in the first code, the information of all the structures can be stored in a global linked list, which is recorded as GStructList.

Then, the GFunctionDictionary generated in the foregoing embodiment can be traversed, and when the name of a certain function is found to be "main", this function is the entry function, which is recorded as MainFunc. Next, search for the structure corresponding to the return type of MainFunc in GStrcutList, and if found, record the found structure as the structure of the output type. At the same time, search for the structure corresponding to the type of the MainFunc formal parameter in GStrcutList, and if found, record the structure of the input type that is found.

Based on the node analysis method provided by the foregoing embodiments, the abstract syntax tree of the first code file can be traversed to obtain the coloring language information of each node. Then, according to the coloring language information of the multiple nodes, the coloring language information of the first code file can be obtained. According to the record in the foregoing embodiment, the coloring language information of the first code may include: resource information contained in the resource dictionary, global parameter information contained in the variable dictionary, structure information contained in the global linked list, and information contained in the objective function set. Function information.

Next, based on the set information mapping rules, the coloring language information of the first code file can be translated to obtain the second code file. Among them, the second code file is adapted to the syntax of the second shading language.

The set information mapping rules may include at least one of variable mapping rules and function mapping rules. Among them, the variable mapping rule and the function mapping rule can be pre-defined according to the grammatical requirements of the second coloring language, which is not limited in this embodiment.

It is worth noting that in this embodiment, the information mapping rules can be updated according to requirements. For example, the mapping relationship between words and words, structure and structure can be flexibly added, and the scalability is strong, and the new coloring can be easily and quickly supported. Language grammar.

Among them, the second shading language may be Metal shading language or GLSL shading language.

Among them, Metal is a low-level, low-overhead hardware-accelerated application program interface that takes into account both graphics and computing functions. It can be applied to systems after IOS 8.0. GLSL shading language is the shading language used by OpenGL, and it is a high-level shading language based on C language.

Correspondingly, the first platform can be implemented as a platform equipped with Windows operating system (an operating system developed by Microsoft Corporation), and the second platform can be implemented as a platform equipped with IOS (iPhone Operation System, an operating system developed by Apple). System platform or platform equipped with Android (operating system developed by Google) operating system.

The following will firstly take the implementation of the second shading language as the Metal shading language as an example to illustrate.

When the first shading language is implemented as HLSL and the second shading language is implemented as the Metal shading language, the variable mapping rule can be as shown in the following HLSL to Metal variable keyword mapping table, and the function mapping rule can be as the following HLSL to Metal function The mapping table is shown.

Among them, the variable keyword mapping table from HLSL to Metal is shown in Table 4 below:

Table 4

HLSL	Metal
SamplerState	sampler
Texture1D	texture1d<float>
Texture2D	Texture2d<float>
Texture3D	Texture3d<float>
Texture1DArray	texture1d_array<float>
Texture2DArray	Texture2d_array<float>
TextureCube	texturecube<float>
TextureCubeArray	Texturecube_array<float>
Texture2DMS	texture2d_ms<float>
SV_DispatchThreadID	[[thread_position_in_grid]]
SV_GroupID	[[threadgroup_position_in_grid]]
SV_GroupIndex	[[thread_index_in_threadgroup]]
SV_GroupThreadID	[[thread_position_in_threadgroup]]
matrix	float4x4
double	float

Among them, the function keyword mapping relationship from HLSL to Metal is shown in Table 5 below:

table 5

HLSL	Metal
reversebits	reverse_bits
ddy	dfdy

ddx	dfdx
asuint	as_type<uint>
asint	as_type<int>
asfloat	as_type<float>
frac	fract
SampleLevel	sample
Sample	sample
SampleGrad	sample
GatherAlpha	gather
Load	read

First, the variable dictionary obtained from the analysis of the foregoing embodiment can be translated. Optionally, the global parameter variable in the variable dictionary can be mapped to the member variable of the first target structure. In other words, all global parameter variables in the first code file of the first target structure are used as member variables of the first target structure.

Continuing to continue the aforementioned HLSL example, a structure can be used to organize the global parameter variable in the GVariableDictionary, and each global parameter variable is used as a member variable of this structure. In this embodiment, the structure can be named Uniform. A typical translation example can be shown in Table 6 below:

Table 6

Next, the structure in the global linked list obtained by the analysis of the foregoing embodiment can be translated. The following will exemplify the implementation of translating the structure in the first code file by taking the first structure in the global linked list as an example.

Optionally, first, the first structure can be obtained from the global linked list generated in the foregoing embodiment. Then, the variables in the first structure can be translated according to the variable mapping rules, so as to map the first structure into a second structure conforming to the grammar of the second shading language.

Taking the translation of HLSL to Metal as an example, when translating all the structure information in the global linked list, the type of the variable in each structure can be mapped from HLSL grammar to Metal grammar according to the variable keyword mapping relationship shown in Table 4 .

Optionally, if the first structure is a structure of the input type of the vertex shader, set the attribute number of the variable in the second structure obtained by mapping and the value of the variable in the first structure. The attribute numbers are the same.

Continue to take the translation of HLSL to Metal as an example. According to the input and output types obtained by parsing HLSL, the input type of Metal can be generated, and the data can be organized by structure.

For the input type of vertex shader, the attribute number (attribute number) of each variable in the translated structure should be consistent with the ATTRIBUTE number (attribute number) in the original HLSL. A typical translation example can be shown in Table 7 below:

Table 7

The input type of the fragment shader shader is handled in the same way as the output type of the vertex shader shader.

Optionally, if the first structure is the output type structure of the vertex shader or the input type structure of the fragment shader Shader, then the attribute in the first structure is mapped to the variable of SV_POSITION After the variables in the second structure, add the [[position]] tag to the mapped variables.

Continue to take the translation of HLSL to Metal as an example. For the output type of the vertex shader, after translating the variable whose attribute is SV_POSITION in HLSL into the variable corresponding to Metal, add the [[position]] mark to the translated variable. In addition to the variables listed above, other variables in HLSL do not need to translate their attribute information. A typical translation example can be shown in Table 8 below:

Table 8

Optionally, if the first structure is a structure of the output type of the fragment shader, the variable whose attribute is SV_Target in the first structure is mapped to the variable in the second structure. , Add [[color]] to the mapped variable, and synchronize the number of the variable whose attribute is SV_Target.

Continue to take the translation of HLSL to Metal as an example. For the output type of the fragment color shader, after translating the variable whose attribute is SV_Target in HLSL into the variable corresponding to Metal, add the color identifier to the translated variable, and the number of the variable before and after the translation. be consistent. A typical translation example can be shown in Table 9 below:

Table 9

Next, the functions in the set of objective functions obtained from the foregoing analysis can be translated. The following will continue to take the first function in the target function set as an example to illustrate the translation operation of the function in the first code file.

Optionally, the first function is obtained from the target function set; the first function is translated according to the information of the first function and the function mapping rule, so as to map the first function to conform to the second shading language The second function of the syntax.

Among them, the function mapping rule can be pre-defined according to the grammatical requirements of the second coloring language, which is not limited in this embodiment.

Optionally, when translating the first function according to the information of the first function and the function mapping rules: if the first function is not an entry function, the inline keyword is added before the return type of the second function.

Optionally, if a formal parameter variable with out or inout attribute is recorded in the information of the first function, a third structure is generated in the second function; according to the transmission of the formal parameter variable with out or inout attribute In the order of parameters, at least one formal parameter variable is defined in sequence in the third structure; wherein, the type of the at least one formal parameter variable is the same as the type of the formal parameter variable with the out or inout attribute, and the at least one formal parameter variable The name is prefixed with output parameters. Among them, the name of the third structure is determined according to the function name of the first function and the type of the formal parameter.

Optionally, the return type of the first function can also be determined from the information of the first function; if the return type of the first function is not empty, a return parameter variable is defined in the third structure; the return parameter The variable has the same return type as the first function.

Optionally, when translating the first function according to the information of the first function and the function mapping rules, if it is determined according to the information of the first function that the first function uses the first global parameter variable, then When generating the formal parameter information of the second function, use the first target structure as the first formal parameter of the second function. Among them, the first target structure is obtained by mapping the global parameter passing variables in the variable dictionary, and the member variables in the first target structure may include all global parameter passing variables in the variable dictionary.

If it is determined based on the information of the first function that the first function uses the first global resource, then when generating the formal parameter information of the second function, the information of the first global resource is placed in addition to the first target structure Before other formal parameters outside the body.

Wherein, the order of the first global resource in the formal parameter of the second function is: buffer resource, texture resource, sampler resource;

Wherein, the resources within any one of the first global resources are sorted according to the size of the register corresponding to the resource.

Optionally, when translating the first function according to the information of the first function and the function mapping rules: if the first function is an entry function, declare the first target in the formal parameter variable of the entry function Structure, buffer resources in the resource dictionary, texture resources in the resource dictionary, and sampler resources in the resource dictionary;

Wherein, a buffer mark is added after the first target structure and the buffer resource, a texture mark is added after the texture resource, and a sampler mark is added after the sampler resource.

Optionally, in the formal parameter variables of the first function, the stage keyword is used to mark the formal parameters of the input type;

Optionally, if the first function corresponds to a vertex shader, a keyword representing a vertex (vertex) is added before the return type of the first function.

Optionally, if the first function corresponds to a fragment shader, a keyword representing a fragment (fragment) is added before the return type of the first function.

Continue to take the translation of HLSL to Metal as an example to further explain the function translation process described above. When translating functions, only the functions recorded in GUsedFunction are translated. Except for the Shader entry function, all functions of Metal should add the inline keyword before the function return type. The Metal function definition method is roughly the same as the HLSL definition, and the main differences in use from HLSL are as follows:

1. Metal function parameters do not support out and inout keywords. When translating HLSL functions that use out and inout attribute parameters, a structure is first generated before the Metal function definition is generated. The name of the structure is determined according to the function name and the type of the function parameter. Then, according to the parameter passing order of using the out and inout attribute parameters, the variables of the same type as the parameters can be defined in the structure in sequence, and the prefix of the name is outParam. If the return type of the function is not empty, you also need to define a variable of the same type as the return type in the structure, with the name returnParam. When generating a function return statement, return this structure variable, which contains the out/inout parameter value to be returned and the return value of the function itself. A typical translation example can be shown in Table 10 below:

Table 10

When other functions call this function, use the comma expression to process, return the structure value at the call site, and assign the function parameters to the function parameters according to the order of the variables in the structure. If there is a returnParam parameter, use returnParam as end. A typical translation example is shown in Table 11 below:

Table 11

Second, Metal's function cannot directly obtain the global parameter variable like HLSL, but needs to pass the global parameter variable from its parent function. Therefore, when generating the formal parameter information of the function, if the global parameter-passing variable is used in the function, the global parameter-passing variable structure is added and placed in the position of the first formal parameter of the function. When using global parameter-passing variables within a function, it is necessary to access it through the global parameter-passing variable structure parameter. In other words, when calling this function, the Uniform variable name needs to be added and placed in the position of the first parameter. A typical translation example can be shown in Table 12 below:

Table 12

3. Metal functions cannot directly obtain resource variables like HLSL, but need to pass in resource variables from its parent function as a parameter. Therefore, when generating the formal parameter information of a function, if resource information is used in the function, all the resource information used is added to the formal parameters and placed before all the formal parameters except the global parameter variable structure. If there are multiple resources, the order of addition is: first add the Buffer resource parameter, then add the Textue resource parameter, and finally add the Sampler resource parameter. Among them, the internal order of each parameter is arranged according to the register value from small to large. All resources have been stored in the function information during preprocessing. Therefore, the resource type name can be mapped through the variable mapping table during translation. When calling this function, you can add the resource name in the corresponding position in the function parameter according to the global resource information recorded in the function information. A typical translation example can be shown in Table 13 below:

Table 13

Then, the entry function in HLSL can be translated into an entry function that conforms to Metal grammar.

The entry function of Metal needs to list all resource information and global parameter variable structure in the formal parameters. Among them, Texture, Buffer and Sampler resources can be obtained from GTextureDictionary, GBufferDictionary and GSamplerDictionary, and the global parameter variable structure is previously defined Uniform structure.

Among them, when the Uniform structure and Buffer resource are declared in the formal parameters, [[buffer(n)]] should be added after it, and n is the register value. When the Texture resource is declared in the formal parameter, [[texture(n)]] should be added after it, and n is the register value. When the Sampler resource is declared in the formal parameter, add [[sampler(n)]] after it, and n is the register value.

At the same time, the Shader uses the stage keyword to mark the parameters input by the Shader. For the vertex shader, add the vertex keyword before the function return type; for the fragment shader, add the fragment keyword before the return type.

An example of fragment coloring translation is shown in Table 14 below:

Table 14

Based on the foregoing embodiments, the coloring language information of the node obtained by analyzing the code file corresponding to the HLSL can be translated to obtain the code file corresponding to the Metal coloring language. That is, as shown in Figure 2, the HLSL Shader file is translated into a MetalShader file. Furthermore, the shader can be programmed on the IOS platform to facilitate the development of 3D graphics programs that can be used by devices such as iPhone, iPad, and iPod Touch.

Next, the implementation of the second shading language as the GLSL shading language will be used as an example to illustrate.

When the first shading language is implemented as HLSL and the second shading language is implemented as GLSL, the variable mapping rules can be as shown in the following HLSL to GLSL variable keyword mapping table, and the function mapping rules can be as the following HLSL to GLSL functions The mapping table is shown.

Among them, the variable keyword mapping table from HLSL to GLSL is shown in Table 15 below:

Table 15

HLSL	GLSL
Texture1D	sampler1D
Texture2D	Sampler2D
Texture3D	Sampler3D
Texture1DArray	sampler1DArray
Texture2DArray	sampler2DArray
TextureCube	samplerCube
Texture2DMS	sampler2DMS
RWTexture2D	image2D
Buffer<float>	samplerBuffer
Buffer<float2>	samplerBuffer
Buffer<float3>	samplerBuffer
Buffer<float4>	samplerBuffer
RWBuffer<float>	imageBuffer
RWBuffer<float2>	imageBuffer

RWBuffer<float3>	imageBuffer
RWBuffer<float4>	imageBuffer
SV_DispatchThreadID	gl_GlobalInvocationID
SV_GroupID	gl_WorkGroupID
SV_GroupIndex	gl_LocalInvocationIndex
SV_GroupThreadID	gl_LocalInvocationID
float4	vec4
float3	vec3
float2	vec2
float4x4	mat4
float3x3	mat3
float3x2	mat3x2
half4	vec4
Half3	vec3
Half2	vec2
half	float
int4	ivec4
int3	ivec3
int2	ivec2
uint4	uvec4
uint3	uvec3
uint2	uvec2

Among them, the function keyword mapping relationship from HLSL to GLSL is shown in Table 16 below:

Table 16

HLSL	GLSL
lerp	mix
frac	fract
ddx	dFdx
ddx_coarse	dFDxCoarse
ddx_fine	dFDxFine

ddy	dFdy
ddy_coarse	dFDyCoarse
ddy_fine	dFDyFine
mad	fma
SampleLevel	textureLod
Sample	texture
SampleGrad	textureGrad
GatherAlpha	textureGather
Load	texelFetch

First, the variable dictionary obtained from the analysis of the foregoing embodiment can be translated. Optionally, the global parameter variable in the variable dictionary can be mapped to the member variable of the second target structure. In other words, all global parameter variables in the first code file are used as member variables of the second target structure.

Continuing to continue the aforementioned HLSL example, a structure can be used to organize the global parameter variable in the GVariableDictionary, and each global parameter variable is used as a member variable of this structure. In this embodiment, the structure is modified by uniform and can be named cb.

Optionally, while declaring the second target structure, a uniform variable block (Uniform Buffer Object, UBO) can be defined, and the second target structure can be stored in the uniform variable block; the abstract syntax tree is traversed, if The name of the current node traversed is the same as the name of any global parameter variable stored in the uniform variable block, and the name identifier of the uniform variable block is added before the name of the current node.

Among them, the uniform variable block is used to store the buffer object of the uniform type variable in the shading language. Using UBO allows the uniform variable to be shared in different shading language programs, and the setting and setting of uniform type variables can also be realized in the shading language program. renew.

For example, taking the translation of HLSL to GLSL as an example, while declaring a structure named cb, you can define a cb variable named ubo. Then, in the coloring language information of GLSL, the global parameter variable is accessed through the variable named ubo. When traversing the abstract syntax tree, if the name of the current node is the name of a global parameter variable, when the current node is translated into GLSL, the text "ubo." can be added before the node name.

A typical translation example can be shown in Table 17 below:

Table 17

Next, you can translate the global parameter variable structure in the variable dictionary. GLSL's global parameter-passing variable structure needs to use layout to set the set modifier and binding modifier. Based on this, optionally, the global parameter-passing variable structure can be obtained from the pre-generated variable dictionary; then, layout is used to set the set modifier and binding modifier of the global parameter-passing variable structure. Among them, the binding value is consistent with its corresponding register (register) value in the HLSL resource. Among them, the value of the set modifier can be set to 0, and the set modifier is used for subsequent Vulkan (an application program interface) translation.

Next, you can translate the resources in the resource dictionary.

Optionally, any resource to be translated can be obtained from the resource dictionary; then, use layout to set the binding modifier of the resource to be translated, and add the uniform keyword before the variable type of the resource to be translated; Wherein, the value of the binding modifier is determined according to the value of the register of the resource to be translated. Among them, in addition to the above modifiers, when translating the variable type of the resource to be translated, the type variable of the resource can be mapped in combination with the variable keyword mapping table to obtain the translated type variable of the resource. Go into details one by one.

Taking the translation of HLSL to GLSL as an example, the information of Texture resources can be obtained from GTextureDictionary. For each Texture resource, when translating it into the corresponding resource in GLSL, the layout can be used to set the binding modifier, and the binding value is the register value of the corresponding resource in HLSL. The variable type of the translated resource is determined according to the variable keyword mapping table, and the uniform keyword is added before the translated variable type.

Among them, the Buffer resource information can be obtained from GBufferDictionary. For each Buffer resource, when translating it into the corresponding resource in GLSL, layout can be used to set the binding modifier, and the binding value can be obtained according to the register value of the corresponding resource in HLSL. The variable type of the translated resource is determined according to the variable keyword mapping table, and the uniform keyword is added before the translated variable type. Among them, Sampler resources do not need to be translated.

A typical resource translation result can be shown in Table 18 below:

Table 18

Next, the structure obtained in the global linked list obtained by the analysis of the foregoing embodiment can be translated.

Taking the first structure in the global linked list as an example, the variables in the first structure can be translated according to the variable mapping rules to map the first structure into a second structure conforming to the grammar of the second shading language. Among them, the input type and output type corresponding to the first structure can be respectively translated into the input variable and output variable of the second structure. That is to say, when translating the structure in HLSL into the structure in GLSL, because the structure definition of GLSL is consistent with the structure definition of HLSL, the information of all the structures can be obtained from the global linked list GStrcutList, according to the variable Keyword mapping table, mapping the types of variables in the structure from the HLSL syntax to the GLSL definition can realize the translation operation of the structure. In the translation process, the input and output variables of GLSL can be generated according to the input and output types obtained by parsing HLSL.

Among them, each output and output variable of GLSL needs to be globally defined in Shader. Therefore, when translating the structure of HLSL to GLSL, if it is found that the current structure type is the input and output type of Shader, the structure is no longer defined in GLSL, but the name of the structure is defined as a float type. , To facilitate subsequent translation. In addition, a part of the non-special member variables in the structure can be defined as the global parameter variable of GLSL Shader, and the translation of the variable type is processed through the variable keyword mapping table.

The special member variables of another part of the structure can be processed as follows:

If the first structure is a structure of the input type of the vertex shader, the layout keyword is used to define the location modifier for the input variable in the second structure, and when the input variable in the second structure is declared , Add the in keyword before entering the variable type in the second structure; wherein, the value of the location modifier is consistent with the attribute number of the variable in the first structure. That is to say, for the input type of the vertex shader, each input variable after translation can be defined with the layout keyword to define the location modifier, and the location value is consistent with the ATTRIBUTE number of the corresponding variable in HLSL. At the same time, when declaring each GLSL input variable, you need to add the in keyword before the type of the input variable to indicate that this variable is an input variable. When translating the input type in the entry function of the Shader, you can find the input type of the Shader from the formal parameters of the entry function, and record the variable name corresponding to this type, denoted as input. When translating the entry function of Shader, replace all the structure of "input.variable name" with the corresponding GLSL global parameter variable name.

Among them, if the first structure is a structure of the output type of the vertex shader, when translating the first structure, the reserved keyword gl_Positon is used to replace the variable whose attribute is SV_POSITION; and, when the second structure is declared When inputting variables in the second structure, add the out keyword before the type of the input variable in the second structure. In other words, for the output type of the vertex shader, the HLSL output variable with the SV_POSITION attribute can be replaced by the reserved keyword gl_Positon in GLSL, and in the Shader entry function of GLSL, gl_Positon can be directly assigned without additional declaration. .

For other output variables in HLSL, the layout keyword is used to define the location attribute value in the Shader of GLSL. At the same time, when declaring each GLSL output variable, you can add the out keyword before the type of the output variable to indicate that this variable is an output variable. When translating the output type in the entry function of the Shader, you can find the variable defined by the output type of the Shader from the statement of the entry function, and record the variable name as output. When translating Shader's entry function, the structure of "output. variable name" is processed. If the variable name in the structure of the output type has the SV_Position attribute, replace "output.variable name" with gl_Position, otherwise replace "output.variable name" with the global output variable name corresponding to GLSL. Since the Shader output type of HLSL is processed by the macro definition, there is no need to translate the Shader output type definition in the entry function. In this way, the translation process can be simplified without affecting the function of the Shader.

A translation example of the input and output types of the vertex shader can be shown in Table 19 below:

Table 19

Among them, if the first structure is the input type structure of the fragment shader, when translating the variable with the SV_POSITION attribute in the first structure, the origin_upper_left modifier is set in the layout and the SV_POSITION Add the in keyword before the variable type of the attribute variable, and set the variable name to gl_FragCoord. That is to say, for the input type of the fragment coloring shader, when translating the variable with the SV_POSITION attribute in HLSL, you can set the origin_upper_left modifier in the layout, and add the in keyword before the variable type, and add the variable The name is set to gl_FragCoord.

For other member variables of the HLSL input type, the translation method is similar to the output type of the vertex shader. The difference is that the in keyword is added before the translated variable instead of the out keyword.

When translating the input type in the Shader entry function, the Shader input type can be found from the formal parameters of the entry function, and the variable name corresponding to this type can be recorded as input. When translating the Shader entry function, the structure of "input. variable name" is processed. If the variable name corresponding to the variable in the input type structure has the SV_POSITION attribute, use gl_FragCoord to replace "output.variable name", otherwise use the global input variable name corresponding to GLSL to replace "input.variable name".

Wherein, if the first structure is a structure of the output type of the fragment shader, the layout keyword is used to set the location modifier for the output variable in the second structure obtained by translation, and the value of the location modifier is It is consistent with the SV_Target attribute number of the corresponding variable in the first structure, and the out keyword is added before the type of the output variable in the second structure. That is to say, for the output type of the fragment coloring shader, when translating into the output variable of GLSL, you can use layout to set the location modifier. The location value is consistent with the SV_Target attribute number of the corresponding variable in HLSL, and it must be before the variable type. Add the out keyword.

When translating the output type in the Shader entry function, find the variable defined by the Shader output type from the entry function statement, and record the variable name as output. When translating the Shader entry function, replace all the structures of "output. variable name" in HLSL with the corresponding GLSL global parameter variable name.

A translation example of the input and output types of the Shader for the fragment coloring can be shown in Table 20 below:

Table 20

Next, the functions in the objective function set can be translated.

Except for the entry function, the function definition method of GLSL is roughly the same as that of HLSL function, and the difference in usage is mainly reflected in the aspect of reading resources. GLSL's Texture and Buffer's resource reading functions are different in structure from HLSL. Continue to take the first function in the objective function set as an example. If the first function is a resource reading function, when the first function is translated into a second function that conforms to the grammatical rules of the second shading language, the second function obtained by the translation is In the function, write the type of the resource to be read, the location of the resource to be read, and other parameters in the body of the second function. An exemplary description will be given below.

For texture resources, the read function structure used by HLSL is as follows:

"Texture resource. Read function (sampler, read position, other parameters)"

The structure of the read function used by GLSL is as follows:

"Read function (texture resource, read location, other parameters)"

For Buffer resources, the structure of the read function used by HLSL is as follows:

"Buffer resource. Read function (read position, other parameters)"

The structure of the read function used by GLSL is as follows:

"Read function (Buffer resource, read position, other parameters)"

The resource dictionary acquired in the foregoing embodiment contains all resource information in the Shader, including resource variable types and variable names. When translating the function call statement in Shader, if the name of the function caller in HLSL is a global resource name, and the calling function is the built-in resource reading function of HLSL, it can be judged that the current statement is a resource reading statement. When translating it into GLSL, the text of the resource variable of this function before the resource reading function is no longer printed to the GLSL Shader, and the resource variable is set as the first parameter of the reading function. For texture resources, the sampler parameter of the resource reading function in HLSL can be omitted during translation. The read function name can be translated according to the function key mapping table.

A typical translation example for resource reading can be shown in Table 21 below:

Table 21

When translating the Shader entry function, the return value of the GLSL entry function is void, and there is no formal parameter list. An example of fragment coloring translation is shown in Table 22 below:

Table 22

Based on the above embodiment, the HLSL Shader file can be translated into the GLSL Shader file. Among them, the GLSL Shader file and the HLSL Shader file have a one-to-one correspondence effect on words, and are highly readable, which is convenient for subsequent optimization and error adjustment on the target platform.

Next, you can use the glslang tool provided by Khronos to translate the translated GLSL Shader file into a SPIR-V file, as shown in Figure 2. Among them, SPIR-V is a modern binary low-level intermediate representation language used in many APIs (Application Programming Interface) such as Vulkan, OpenCL, and OpenGL. Among them, Vulkan is a low-overhead, cross-platform application program interface for two-dimensional and three-dimensional graphics and computing. Similar to OpenGL, Vulkan is designed for real-time 3D graphics programs on all platforms.

It should be noted that the execution subject of each step of the method provided in the foregoing embodiment may be the same device, or the method may also be executed by different devices. For example, the execution subject of steps 201 to 204 may be device A; for another example, the execution subject of steps 201 and 202 may be device A, and the execution subject of step 203 may be device B; and so on.

In addition, in some of the processes described in the above-mentioned embodiments and drawings, multiple operations appearing in a specific order are included, but it should be clearly understood that these operations may be performed out of the order in which they appear in this document or performed in parallel. The sequence numbers of operations, such as 201, 202, etc., are only used to distinguish different operations, and the sequence numbers themselves do not represent any execution order. In addition, these processes may include more or fewer operations, and these operations may be executed sequentially or in parallel. It should be noted that the descriptions of "first" and "second" in this article are used to distinguish different messages, devices, modules, etc., and do not represent a sequence, nor do they limit the "first" and "second" Are different types.

FIG. 3 is a schematic structural diagram of an electronic device provided by an exemplary embodiment of the present application. As shown in FIG. 3, the electronic device includes a memory 301 and a processor 302.

The memory 301 is used to store computer programs and can be configured to store other various data to support operations on the electronic device. Examples of such data include instructions for any application or method operated on an electronic device, contact data, phone book data, messages, pictures, videos, etc.

Among them, the memory 301 can be implemented by any type of volatile or non-volatile storage device or their combination, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable Except programmable read only memory (EPROM), programmable read only memory (PROM), read only memory (ROM), magnetic memory, flash memory, magnetic disk or optical disk.

The processor 302 is coupled with the memory 301, and is configured to execute a computer program in the memory 301, so as to perform a syntax analysis on a first code file corresponding to the first shading language to obtain an abstract syntax tree of the first code file; Analyze the keywords of multiple nodes in the abstract syntax tree to obtain the coloring language information of the first code file; perform the coloring language information of the first code file according to the set information mapping rules Translate to obtain a second code file corresponding to the second shading language; wherein the information mapping rule is determined according to the grammatical rules of the first shading language and the second shading language.

Further optionally, the mapping rule includes at least one of the following: a variable mapping rule between the first shading language and the second shading language; one of the first shading language and the second shading language Function mapping rules between.

Further optionally, the processor 302 is further configured to: determine a variable to be processed from the first code file, and the name of the variable to be processed contains the same character string as the reserved keyword in the translation tool; The name of the variable to be processed is modified to avoid using reserved keywords as variable names in the second code file.

Further optionally, the variable to be processed includes at least one of a global parameter variable named Buffer, a variable whose name includes the character string Texture, and a variable whose name includes the character string Buffer.

Further optionally, the coloring language information of the first code file includes: information about global parameters in the first code file, information about resources in the first code file, and the first code At least one of structure information in the file and function information in the first code file.

Further optionally, when the processor 302 analyzes keywords of multiple nodes in the abstract syntax tree to obtain the coloring language information of the first code file, it is specifically configured to: target the multiple nodes For any node in the node, determine the key variable corresponding to the node according to the type keyword of the node; analyze the key variable corresponding to the node to obtain the coloring language information corresponding to the node; according to the multiple The coloring language information corresponding to the respective nodes is used to obtain the coloring language information of the first code file.

Further optionally, when the processor 302 analyzes the key variable corresponding to the node to obtain the coloring language information corresponding to the node, it is specifically used for: if the type keyword of the node is a global parameter variable structure , The type variables and name variables of the child nodes of the node are analyzed to obtain the type and name of the global parameter-passing variable contained in the global parameter-passing variable structure; the global parameter-passing variable structure contained in the global The type and name of the passed parameter variable are stored in the variable dictionary.

Further optionally, when the processor 302 analyzes the key variable corresponding to the node to obtain the coloring language information corresponding to the node, it is specifically configured to: if the type keyword of the node contains a character string representing a resource, Then, the name variable and the register allocation variable of the node are parsed to obtain the name and register address of the resource; the name and register address of the resource are correspondingly saved in the resource dictionary.

Further optionally, the resources include: at least one of texture resources, buffer resources, and register resources.

Further optionally, when the processor 302 analyzes the key variable corresponding to the node to obtain the coloring language information corresponding to the node, it is specifically used for: if the type keyword of the node is a function definition or a function declaration, Parse the function type variable and name variable of the node to obtain the return type and function name of the first function corresponding to the node; use the return type and function name of the first function as the information of the first function , And save the information of the first function in the function dictionary.

Further optionally, the processor 302 is further configured to: parse the type variable and the name variable of the child node of the function parameter variable of the node to obtain the type and name of the formal parameter variable of the first function, and compare the The type and name of the formal parameter variable of the first function are written into the information of the first function; if the formal parameter variable of the first function includes a formal parameter variable with out or inout attribute, then the In the function information, the formal parameter variable with the out or inout attribute is recorded.

Further optionally, the processor 302 is further configured to: obtain a subtree corresponding to any child node of the code block variable of the node; if the type of the first node in the subtree is a function call, parse the The name variable and actual parameter variable of the first node are used to obtain the function name and parameter passing information corresponding to the first node; in the function dictionary, the function name corresponding to the first node and the target corresponding to the parameter passing information are queried Function as a calling function of the first function, and writing the calling function into the information of the first function.

Further optionally, the processor 302 is further configured to: if the second node in the subtree uses the first global resource, write the information of the first global resource into the information of the first function; The first global resource includes at least one of a texture resource, a buffer resource, and a sampler resource; if the third node in the subtree uses the first global parameter variable, the first global parameter is transmitted The information of the parameter is written into the information of the first function.

Further optionally, the processor 302 is further configured to: determine an entry function from the function dictionary; starting from the entry function, use a depth-first search method to search for each function called by the entry function; The function called by the entry function is recorded in the target function set.

Further optionally, when the processor 302 parses the respective key variables of the multiple nodes to obtain the coloring language information of the first code file, it is specifically configured to: if the type keyword of the node is a structure Body definition, the name variable of the node and the child node of the class member declaration variable are parsed to obtain the name of the first structure corresponding to the node and the information of the class member contained in the first structure; The name of the first structure and the information of the class members contained in the first structure are stored in the global linked list.

Further optionally, the processor 302 is further configured to: traverse the function dictionary to determine an entry function from the function dictionary; if the first structure body matches the return type of the entry function, determine all The first structure is an output type structure; if the first structure matches the type of the formal parameter variable of the entry function, it is determined that the first structure is an input type structure.

Further optionally, when the processor 302 translates the coloring language information of the first code file according to the set information mapping rule, it is specifically configured to: obtain the first structure from the global linked list; According to the variable mapping rules, the variables in the first structure are translated to map the first structure into a second structure conforming to the grammar of the second shading language.

Further optionally, when the processor 302 translates the variables in the first structure according to the variable mapping rules, it is specifically configured to: if the first structure is the structure of the input type of the vertex shader, Set the attribute number of the variable in the second structure obtained by mapping to be consistent with the attribute number of the variable in the first structure; if the first structure is the structure of the output type of the vertex shader or Is the input type structure of the fragment shader, after mapping the variable with the attribute SV_POSITION in the first structure to the variable in the second structure, add [[position] to the mapped variable ] Identification; if the first structure is a structure of the output type of the fragment shader, after mapping the variable whose attribute is SV_Target in the first structure to the variable in the second structure, Add [[color]] to the mapped variable, and synchronize the number of the variable whose attribute is SV_Target.

Further optionally, when the processor 302 translates the coloring language information of the first code file according to the set information mapping rule, it is specifically configured to: map the global parameter variable in the variable dictionary to The member variable of the first target structure.

Further optionally, the processor 302 is specifically configured to: obtain the first function from the target function set when translating the shading language information of the first code file according to the set information mapping rule; According to the variable mapping rule and/or the function mapping rule, the first function is translated to map the first function to a second function conforming to the grammar of the second shading language.

Further optionally, when the processor 302 interprets the first function according to the information of the first function and the function mapping rules, it is specifically configured to: if the first function is not an entry function, then Add the inline keyword before the return type of the second function.

Further optionally, when the processor 302 interprets the first function according to the information of the first function and the function mapping rules, it is specifically configured to: if the information of the first function records that there is out or The formal parameter variable of the inout attribute generates a third structure in the second function; according to the parameter transfer order of the formal parameter variable with the out or inout attribute, at least one is defined in the third structure in turn A formal parameter variable; wherein the type of the at least one formal parameter variable is the same as the type of the formal parameter variable with the out or inout attribute, and the name of the at least one formal parameter variable is provided with an output parameter prefix.

Further optionally, the processor 302 is further configured to: determine the return type of the first function from the information of the first function; if the return type of the first function is not empty, perform the A return parameter variable is defined in the structure; the return parameter variable is the same as the return type of the first function.

Further optionally, when the processor 302 translates the first function according to the information of the first function and the function mapping rule, it is specifically configured to: if the first function is determined according to the information of the first function, The function uses the first global parameter variable, when generating the formal parameter information of the second function, the first target structure is used as the first formal parameter of the second function; If the information of the first function determines that the first function uses the first global resource, when the formal parameter information of the second function is generated, the information of the first global resource is placed in addition to the first global resource. Before a formal parameter other than the target structure.

Further optionally, the order of the first global resource in the formal parameters of the second function is: buffer resource, texture resource, sampler resource; wherein, any one of the first global resources is global The resources inside the resource are sorted according to the size of the register corresponding to the resource.

Further optionally, when the processor 302 interprets the first function according to the information of the first function and the function mapping rules, it is specifically configured to: if the first function is an entry function, perform the In the formal parameter variable of the entry function, declare the first target structure, the buffer resource in the resource dictionary, the texture resource in the resource dictionary, and the sampler resource in the resource dictionary; Add a buffer mark after the first target structure and the buffer resource, add a texture mark after the texture resource, and add a sampler mark after the sampler resource.

Further optionally, the processor 302 is further configured to perform at least one of the following operations: in the formal parameter variable of the first function, the stage keyword is used to mark the formal parameter of the input type; if the first function and vertex coloring If the first function corresponds to the fragment shader, add the keyword representing the fragment before the return type of the first function. Keywords.

Further optionally, the first code file is a code file of the HLSL shading language; the second code file is a code file corresponding to the Metal shading language.

Further optionally, when the processor 302 translates the coloring language information of the first code file according to the set information mapping rule, it is specifically configured to: map the global parameter variable in the variable dictionary to Member variables of the second target structure; define a uniform variable block, and store the second target structure in the uniform variable block; traverse the abstract syntax tree, if the name of the current node traversed is consistent with the If the name of any global parameter variable stored in the uniform variable block is the same, the name identifier of the uniform variable block is added before the name of the current node.

Further optionally, the processor 302 is further configured to: obtain the global parameter passing variable structure from the variable dictionary; use layout to set the set modifier and binding modifier of the global parameter passing variable structure.

Further optionally, when the processor 302 translates the coloring language information of the first code file according to the set information mapping rule, it is specifically configured to: obtain any resource to be translated from the resource dictionary ; Use layout to set the binding modifier of the resource to be translated, and add a uniform keyword before the variable type of the resource to be translated; wherein the value of the binding modifier is based on the register of the resource to be translated The value is OK.

Further optionally, when the processor 302 translates the coloring language information of the first code file, it is specifically configured to: obtain the first structure from the global linked list; Translate the variables in the first structure to map the first structure to a second structure conforming to the grammar of the second shading language; translate the input type and output type corresponding to the first structure respectively Are the input variables and output variables of the second structure; if the first structure is the input type structure of the vertex shader, the layout keyword is used to define location for the input variables in the second structure Modifier, and when declaring the input variable in the second structure, add the in keyword before the type of the input variable in the second structure; wherein, the value of the location modifier is the same as that of the first The attribute numbers of the variables in the structure are the same; if the first structure is the output type structure of the vertex shader, when translating the first structure, the reserved keyword gl_Positon is used instead of the variable whose attribute is SV_POSITION ; And, when declaring the input variable in the second structure, add the out keyword before the type of the input variable in the second structure; if the first structure is the input of the fragment shader Type structure, when translating the variable with the SV_POSITION attribute in the first structure, set the origin_upper_left modifier in the layout, and add the in keyword before the variable type of the variable with the SV_POSITION attribute, and Set the variable name to gl_FragCoord; if the first structure is a structure of the output type of the fragment shader, use the layout keyword to set the location modifier for the output variable in the second structure obtained by translation, where The value of the location modifier is consistent with the SV_Target attribute number of the corresponding variable in the first structure, and the out keyword is added before the type of the output variable in the second structure.

Further optionally, the processor 302 may perform at least one of the following operations when translating the first function according to the information of the first function and the function mapping rule: acquiring the target function set The first function; according to the variable mapping rule and/or the function mapping rule, the information of the first function is translated, so as to map the first function to the first function conforming to the grammar of the second shading language Second function; if the first function is a resource reading function, in the second function obtained by translation, the type of the resource to be read, the location of the resource to be read, and other parameters are written in the In the function body of the second function; if the first function is an entry function, the return value of the second function obtained by mapping the first function is set to void.

Further optionally, the processor 302 is further configured to: the first code file is a code file of the HLSL shading language; the second code file is a code file corresponding to the GLSL shading language.

Furthermore, as shown in FIG. 3, the electronic device further includes: a communication component 303, a display 304, a power supply component 305, an audio component 306 and other components. Only part of the components are schematically shown in FIG. 3, which does not mean that the electronic device only includes the components shown in FIG. 3.

The communication component 303 is configured to facilitate wired or wireless communication between the device where the communication component is located and other devices. The device where the communication component is located can access a wireless network based on a communication standard, such as WiFi, 2G, 3G, 4G, or 5G, or a combination of them. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast related information from an external broadcast management system via a broadcast channel. In an exemplary embodiment, the communication component may be based on near field communication (NFC) technology, radio frequency identification (RFID) technology, infrared data association (IrDA) technology, ultra-wideband (UWB) technology, Bluetooth (BT) technology, and other technologies to realise.

Among them, the display component 304 includes a screen, and the screen may include a liquid crystal display (LCD) and a touch panel (TP). If the screen includes a touch panel, the screen may be implemented as a touch screen to receive input signals from the user. The touch panel includes one or more touch sensors to sense touch, sliding, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure related to the touch or slide operation.

Among them, the power supply component 305 provides power for various components of the equipment where the power supply component is located. The power supply component may include a power management system, one or more power supplies, and other components associated with the generation, management, and distribution of power for the equipment where the power supply component is located.

In this embodiment, node analysis is performed based on the abstract syntax tree, and the original syntax structure of the code file of the original coloring language is retained. At the same time, node-based keyword analysis realizes the corresponding translation between different types of information, which is conducive to improving the readability of the translation results; in addition, the information mapping rules can be updated according to actual needs to improve The scalability of the language translation method is improved, and the new coloring language grammar can be supported quickly and conveniently.

Correspondingly, the embodiments of the present application also provide a computer-readable storage medium storing a computer program, and when the computer program is executed, the steps that can be executed by the electronic device in the foregoing method embodiments can be implemented.

The various component embodiments of the present invention may be implemented by hardware, or by software modules running on one or more processors, or by a combination of them. Those skilled in the art should understand that a microprocessor or a digital signal processor (DSP) may be used in practice to implement some or all of the functions of some or all of the components in the electronic device of the embodiment of the present invention. The present invention can also be implemented as a device or device program (for example, a computer program and a computer program product) for executing part or all of the methods described herein. Such a program for realizing the present invention may be stored on a computer-readable medium, or may have the form of one or more signals. Such a signal can be downloaded from an Internet website, or provided on a carrier signal, or provided in any other form.

For example, FIG. 4 shows a server, such as an application server, that can implement the shading language translation method of the present invention. The server traditionally includes a processor 410 and a computer program product in the form of a memory 420 or a computer-readable medium. The memory 420 may be an electronic memory such as flash memory, EEPROM (Electrically Erasable Programmable Read Only Memory), EPROM, hard disk, or ROM. The memory 420 has a storage space 430 for executing the program code 431 of any method step in the foregoing method. For example, the storage space 430 for program codes may include various program codes 431 respectively used to implement various steps in the above method. These program codes can be read from or written into one or more computer program products. These computer program products include program code carriers such as hard disks, compact disks (CDs), memory cards, or floppy disks. Such a computer program product is usually a portable or fixed storage unit as described with reference to FIG. 5. The storage unit may have storage segments, storage space, etc., arranged similarly to the storage 420 in the server of FIG. 4. The program code can be compressed in a suitable form, for example. Generally, the storage unit includes computer-readable codes 431', that is, codes that can be read by, for example, a processor such as 410, which, when run by a server, causes the server to perform the steps in the method described above.

The “one embodiment”, “an embodiment” or “one or more embodiments” referred to herein means that a specific feature, structure or characteristic described in conjunction with the embodiment is included in at least one embodiment of the present invention. In addition, please note that the word examples "in one embodiment" here do not necessarily all refer to the same embodiment.

In the instructions provided here, a lot of specific details are explained. However, it can be understood that the embodiments of the present invention can be practiced without these specific details. In some instances, well-known methods, structures, and technologies are not shown in detail, so as not to obscure the understanding of this specification.

It should be noted that the above-mentioned embodiments illustrate rather than limit the present invention, and those skilled in the art can design alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses should not be constructed as a limitation to the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "a" or "an" preceding an element does not exclude the presence of multiple such elements. The invention can be implemented by means of hardware comprising several different elements and by means of a suitably programmed computer. In the unit claims that list several devices, several of these devices may be embodied in the same hardware item. The use of the words first, second, and third, etc. do not indicate any order. These words can be interpreted as names.

In addition, it should also be noted that the language used in this specification is mainly selected for readability and teaching purposes, not for explaining or limiting the subject of the present invention. Therefore, without departing from the scope and spirit of the appended claims, many modifications and changes are obvious to those of ordinary skill in the art. For the scope of the present invention, the disclosure of the present invention is illustrative rather than restrictive, and the scope of the present invention is defined by the appended claims.

Claims (24)

1. A coloring language translation method, which is characterized in that it includes:

   Performing syntax analysis on the first code file corresponding to the first coloring language of the first platform to obtain an abstract syntax tree of the first code file;

   Analyzing the type keywords of the multiple nodes in the abstract syntax tree to determine the key variables corresponding to each of the multiple nodes, and using the key variables to obtain the coloring language information of the first code file;

   According to the variable mapping rules between the first coloring language and the second coloring language of the second platform and/or the function mapping rules between the first coloring language and the second coloring language, the first coloring language Translating the coloring language information of the code file to obtain a second code file corresponding to the second coloring language;

   Wherein, the variable mapping rule and the function mapping rule are determined according to the grammar rules of the first shading language and the second shading language.
2. The method according to claim 1, further comprising:

   Determine the variable to be processed from the first code file, and the name of the variable to be processed contains the same character string as the reserved keyword in the translation tool;

   Modify the name of the variable to be processed.
3. The method according to claim 1, wherein the shading language information of the first code file comprises:

   Information about the global parameters in the first code file, information about the resources in the first code file, information about the structure in the first code file, and information about the functions in the first code file At least one of the information.
4. The method according to claim 3, wherein using the key variable to obtain the coloring language information of the first code file comprises:

   For any one of the multiple nodes, if the type keyword of the node is a global parameter variable structure, then the type variables and name variables of the child nodes of the node are parsed to obtain the global transmission The type and name of the global parameter variable contained in the parameter variable structure;

   The type and name of the global parameter-passing variable contained in the global parameter-passing variable structure are stored in the variable dictionary.
5. The method according to claim 4, wherein using the key variable to obtain the coloring language information of the first code file comprises:

   If the type keyword of the node contains a character string representing a resource, parse the name variable and register allocation variable of the node to obtain the name and register address of the resource;

   Save the name and register address of the resource in the resource dictionary correspondingly;

   Wherein, the resources include: at least one of texture resources, buffer resources, and register resources.
6. The method according to claim 5, wherein using the key variable to obtain the coloring language information of the first code file comprises:

   If the type keyword of the node is a function definition or a function declaration, parse the function type variable and the name variable of the node to obtain the return type and function name of the first function corresponding to the node;

   The return type and function name of the first function are used as the information of the first function, and the information of the first function is stored in a function dictionary.
7. The method according to claim 6, further comprising:

   Parse the type variable and name variable of the child node of the function parameter variable of the node to obtain the type and name of the formal parameter variable of the first function, and write the type and name of the formal parameter variable of the first function Enter the information of the first function;

   If the formal parameter variable of the first function includes a formal parameter variable with an out or inout attribute, then the formal parameter variable with an out or inout attribute is recorded in the information of the first function.
8. The method according to claim 7, further comprising:

   Acquiring a subtree corresponding to any child node of the code block variable of the node;

   If the type of the first node in the subtree is a function call, parse the name variable and the actual parameter variable of the first node to obtain the function name and parameter transfer information corresponding to the first node;

   In the function dictionary, query the function name corresponding to the first node and the target function corresponding to the parameter passing information as the calling function of the first function, and write the calling function into the first function Information.
9. The method according to claim 8, further comprising:

   If the second node in the subtree uses the first global resource, the information of the first global resource is written into the information of the first function; the first global resource includes texture resources, buffers At least one of resources and sampler resources;

   If the third node in the subtree uses the first global parameter passing variable, the information of the first global parameter passing variable is written into the information of the first function.
10. The method according to claim 9, further comprising:

    Determine the entry function from the function dictionary;

    Starting from the entry function, a depth-first search method is adopted to search for each function called by the entry function;

    Record the searched function called by the entry function into the target function set.
11. The method according to claim 10, wherein using the key variable to obtain the coloring language information of the first code file comprises:

    If the type keyword of the node is a structure definition, the name variable of the node and the child nodes of the class member declaration variable are parsed to obtain the name of the first structure corresponding to the node and the first structure Contains information about class members;

    The name of the first structure and the information of the class members contained in the first structure are stored in a global linked list.
12. The method according to claim 11, further comprising:

    Traverse the function dictionary to determine the entry function from the function dictionary;

    If the first structure body matches the return type of the entry function, it is determined that the first structure body is an output type structure body;

    If the first structure body matches the type of the formal parameter variable of the entry function, it is determined that the first structure body is an input type structure body.
13. The method according to claim 12, wherein the translation of the coloring language information of the first code file according to a set information mapping rule comprises:

    Obtaining the first structure from the global linked list;

    Translating the variables in the first structure according to the variable mapping rule to map the first structure into a second structure conforming to the grammar of the second shading language;

    If the first structure is a structure of the input type of the vertex shader, setting the attribute number of the variable in the second structure obtained by mapping to be consistent with the attribute number of the variable in the first structure;

    If the first structure is the structure of the output type of the vertex shader or the structure of the input type of the fragment shader, then the variable with the attribute SV_POSITION in the first structure is mapped to the first structure After the variables in the second structure, add [[position]] to the mapped variables;

    If the first structure is a structure of the output type of the fragment shader, after mapping the variable whose attribute is SV_Target in the first structure to the variable in the second structure, it is obtained by mapping Add the [[color]] mark to the variable, and synchronize the number of the variable with SV_Target as the attribute.
14. The method according to claim 12, characterized in that translating the shading language information of the first code file comprises:

    Map the global parameter variable in the variable dictionary to the member variable of the first target structure.
15. The method according to claim 14, wherein translating the shading language information of the first code file comprises:

    Obtaining the first function from the set of objective functions;

    Translating the first function according to the variable mapping rule and/or the function mapping rule to map the first function to a second function conforming to the grammar of the second shading language;

    If the first function is not an entry function, add the inline keyword before the return type of the second function;

    If a formal parameter variable with an out or inout attribute is recorded in the information of the first function, a third structure is generated in the second function; according to the parameter passing of the formal parameter variable with the out or inout attribute Sequence, define at least one formal parameter variable in the third structure; wherein the type of the at least one formal parameter variable is the same as the type of the formal parameter variable with the out or inout attribute, and the at least one The name of the formal parameter variable is set with the output parameter prefix;

    If it is determined according to the information of the first function that the return type of the first function is not empty, a return parameter variable is defined in the third structure; the return parameter variable is the same as the return type of the first function ；

    If it is determined according to the information of the first function that the first function uses the first global parameter variable, when generating the formal parameter information of the second function, the first target structure is used as the State the first parameter of the second function;

    If it is determined according to the information of the first function that the first function uses the first global resource, when generating the formal parameter information of the second function, the information of the first global resource is placed in the Before the other formal parameters except the first target structure;

    If the first function is an entry function, in the formal parameter variable of the entry function, declare the first target structure, the buffer resource in the resource dictionary, the texture resource in the resource dictionary, and The sampler resource in the resource dictionary; wherein a buffer mark is added after the first target structure and the buffer resource, a texture mark is added after the texture resource, and a texture mark is added after the sampler resource Sampler tag;

    In the formal parameter variables of the first function, the stage keyword is used to mark the formal parameters of the input type;

    If the first function corresponds to a vertex shader, add a keyword representing a vertex before the return type of the first function;

    If the first function corresponds to a fragment shader, a keyword representing the fragment is added before the return type of the first function.
16. The method according to any one of claims 13-15, wherein the first code file is a code file of the HLSL shading language; and the second code file is a code file corresponding to the Metal shading language.
17. The method according to claim 12, wherein translating the shading language information of the first code file comprises:

    Mapping the global parameter variable in the variable dictionary to the member variable of the second target structure;

    Define a uniform variable block, and store the second target structure in the uniform variable block;

    Traverse the abstract syntax tree, if the name of the current node traversed is the same as the name of any global parameter variable stored in the uniform variable block, add the name of the uniform variable block before the name of the current node Name identification.
18. The method according to claim 12, further comprising:

    Obtain the global parameter variable structure from the variable dictionary;

    Use layout to set the set modifier and binding modifier of the global parameter variable structure.
19. The method according to claim 12, wherein translating the shading language information of the first code file comprises:

    Obtain any resource to be translated from the resource dictionary;

    Use layout to set the binding modifier of the resource to be translated, and add a uniform keyword before the variable type of the resource to be translated;

    Wherein, the value of the binding modifier is determined according to the value of the register of the resource to be translated.
20. The method according to claim 12, wherein translating the shading language information of the first code file comprises:

    Obtaining the first structure from the global linked list;

    Translating the variables in the first structure according to the variable mapping rule to map the first structure into a second structure conforming to the grammar of the second shading language;

    Translate the input type and output type corresponding to the first structure into input variables and output variables of the second structure, respectively;

    If the first structure is the input type structure of the vertex shader, the layout keyword is used to define the location modifier for the input variables in the second structure, and the location modifier in the second structure is declared When inputting a variable, add the in keyword before the type of the variable in the second structure; wherein, the value of the location modifier is consistent with the attribute number of the variable in the first structure;

    If the first structure is a structure of the output type of the vertex shader, when translating the first structure, the reserved keyword gl_Positon is used to replace the variable whose attribute is SV_POSITION; and, when the second structure is declared When inputting variables in the body, add the out keyword before the type of the input variable in the second structure;

    If the first structure is the input type structure of the fragment shader, when translating the variable with the SV_POSITION attribute in the first structure, the origin_upper_left modifier is set in the layout, and the Add the in keyword before the variable type of the variable of the SV_POSITION attribute, and set the variable name to gl_FragCoord;

    If the first structure is the structure of the output type of the fragment shader, then the layout keyword is used to set the location modifier for the output variable in the second structure obtained by translation, and the location modifier of the location modifier is The value is consistent with the SV_Target attribute number of the corresponding variable in the first structure, and the out keyword is added before the type of the output variable in the second structure.
21. The method according to claim 20, wherein the translation of the first function according to the information of the first function and the function mapping rule comprises performing at least one of the following operations:

    Obtaining the first function from the set of objective functions;

    Translating the information of the first function according to the variable mapping rule and/or the function mapping rule to map the first function to a second function conforming to the grammar of the second shading language;

    If the first function is a resource reading function, in the second function obtained by translation, write the type of the resource to be read, the location of the resource to be read, and other parameters in the second function In the body of the function;

    If the first function is an entry function, the return value of the second function obtained by mapping the first function is set to void.
22. The method according to any one of claims 17-21, wherein the first code file is a code file of HLSL shading language; and the second code file is a code file corresponding to GLSL shading language.
23. A computer program comprising computer readable code, when the computer readable code runs on a server, causes the server to execute the website scanning method according to any one of claims 1-22.
24. A computer readable medium in which the computer program according to claim 23 is stored.

Images