A method of generating a static mesh model

Abstract

This invention proposes a method for generating static mesh models, comprising: Step 1, acquiring input model data; Step 2, when the input model data is valid, initializing the construction structure FMESHDescription; Step 3, setting the construction structure according to the input model data; Step 4, creating an empty static mesh object; the static mesh object is a UStaticMesh class object in Unreal Engine, used to store static mesh model data and rendering data; Step 5, generating empty collision data; Step 6, setting construction parameters; Step 7, calling the construction mesh description function, passing in the construction structure FMESHDescription data and the construction parameter structure, thereby constructing the static mesh object model data; the above method enables the direct generation of static mesh models at runtime using vertex-related information.

Description

Technical Field

[0001] This invention relates to the field of computer graphics rendering, and more specifically to a method for generating static mesh models. Background Technology

[0002] There are many ways to generate static mesh models, such as importing models from external sources or converting them using other components. However, these methods do not support modifying the static mesh model information after it has been generated.

[0003] Unreal Engine 4.25 supports updating static mesh models at runtime, making it possible to create models locally in real time when vertex information needs to be transferred from the server. However, Unreal Engine does not provide a method to directly generate static mesh models at runtime using vertex-related information. Summary of the Invention

[0004] To address the aforementioned constraints and limitations, this invention proposes a method for generating static mesh models.

[0005] To achieve the above objectives, the present invention adopts the following technical solution:

[0006] A method for generating a static mesh model, the method comprising the following steps:

[0007] Step 1: Obtain input model data; the input model data consists of a vertex array, a UV array, and a point sequence array;

[0008] Step 2: When the input model data is valid, initialize and construct the structure FMeshDescription;

[0009] Step 3: Set the construction structure according to the input model data;

[0010] Step 4: Create an empty static mesh object;

[0011] The static mesh object is a UStaticMesh class object in Unreal Engine, used to store static mesh model data and rendering data;

[0012] Step 5: Generate empty collision data;

[0013] Step 6: Set build parameters;

[0014] The construction parameters are the FBuildMeshDescriptionsParams structure in Unreal Engine;

[0015] Step 7: Call the mesh description construction function, passing in the construction structure FMeshDescription data and the construction parameter structure, to construct the static mesh object model data.

[0016] Compared with the prior art, the present invention has the following advantages:

[0017] (1) It can directly use vertex-related information to generate static mesh models at runtime;

[0018] (2) It does not go through the editor function, so the generation time is relatively short, the data complexity is low, and the method is efficient.

[0019] The above description is merely an overview of the technical solution of the present invention. In order to better understand the technical means of the present invention and to implement it in accordance with the contents of the specification, and to make the above and other objects, features and advantages of the present invention more apparent and understandable, preferred embodiments are described in detail below with reference to the accompanying drawings. Attached Figure Description

[0020] Figure 1 This is a step diagram illustrating a method for generating a static mesh model according to an embodiment of the present invention.

[0021] Figure 2 This is a step diagram illustrating a method for setting and constructing a structure according to an embodiment of the present invention. Detailed Implementation

[0022] The following specific embodiments illustrate the implementation of the present invention. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention. To further understand the present invention, the present invention will be further described in detail below with reference to the preferred embodiments.

[0023] The inventive point of this invention is to provide a method for generating static mesh models; see reference. Figure 1 The method includes the following steps:

[0024] Step 1: Obtain the input model data and determine whether the input model data is valid;

[0025] The input model data is model data exported from external modeling software (such as MAY / MAX), and the input model data consists of vertex array, UV array, and point sequence array;

[0026] Step 2: If the input model data is determined to be invalid, return a null pointer object and end the step; if the input model data is determined to be valid, initialize and construct the structure FMESHDescription.

[0027] The construction structure is a data structure required when constructing a static mesh, used to store FBX file parsing data;

[0028] Step 3: Set the construction structure according to the input model data;

[0029] Step 4: Create an empty static mesh object;

[0030] The static mesh object is a UStaticMesh class object in Unreal Engine, used to store static mesh model data and rendering data;

[0031] Step 5: Generate empty collision data;

[0032] Step 6: Set build parameters;

[0033] The build parameters are the FBuildMeshDescriptionsParams structure in Unreal Engine, which defines the parameters passed to the build mesh description function (BuildFromMeshDescriptions);

[0034] Step 7: Call the mesh description construction function, passing in the construction structure FMeshDescription data and the construction parameter structure, thereby constructing the static mesh object model data;

[0035] Step 8: Output the static mesh object model data constructed in Step 7.

[0036] In step 1, the method for determining whether the input model data is valid is as follows:

[0037] The vertex array, UV array, and point sequence array in the input model data are all non-empty, and the number of elements in the vertex array is equal to the number of elements in the UV array.

[0038] refer to Figure 2 In step 3, the specific method for setting the construction structure based on the input model data includes:

[0039] Step 31: Read the input model data to obtain the input model parameter values, and create an empty construction structure FMeshDescriptin object MeshDescription;

[0040] The input model parameter values ​​include: vertex position array InVertexs, point number array InIndices, and vertex UV array InUVs;

[0041] Step 32: Extract the attributes from MeshDescription using the FStaticMeshAttributes utility class;

[0042] Step 33: Create a polygon group and specify the default material;

[0043] Step 34: Initialize the vertices, vertex instances, polygons, edges, and UV channels of MeshDescription;

[0044] Step 35: Copy the vertex position array data from the input model data into MeshDescription;

[0045] Step 36: Create a vertex instance for each vertex in the input model data based on the vertex index array;

[0046] The vertex instance stores the UV, normal, tangent, binormal, and vertex color information of the corresponding vertex. Each vertex instance corresponds to a vertex ID in the VertexPositions array of MeshDescription.

[0047] Step 37: Create polygons for the polygon group;

[0048] Step 38: Regenerate the normals, tangents, and binormals of all vertices and polygons; at this point, the MeshDescription is the completed construction structure FMeshDescription.

[0049] In step 4, the static mesh object contains two member variables: StaticMeshSourceModel (the original model data of the static mesh) and FStaticMeshRenderData (the rendering data of the static mesh).

[0050] The static mesh source model data StaticMeshSourceModel is used to store information such as vertices, UVs, normals, and point order. The data of this variable comes from the construction structure FMeshDescripion obtained in step 3.

[0051] The static mesh rendering data, StaticMeshRenderData, consists of an LOD resource array and a vertex factory array, used to store rendering information. The rendering information is the rendering information of each LOD layer of the UStaticMesh. The LOD resource array contains FStaticMeshLODResources (i.e., LOD resource data) for all LOD layers, and the LOD resource data contains vertex caches and several index arrays.

[0052] In the traditional approach, the static mesh rendering data, StaticMeshRenderData, is obtained through the following steps:

[0053] After obtaining the completed build structure FMESHDescription in step 3, the editor function UStaticMesh::Build is called to generate the static mesh rendering data StaticMeshRenderData from FMESHDescription.

[0054] However, the editor function UStaticMesh::Build is based on the editor state and will not be executed at runtime. Moreover, the generation process consumes a lot of computer performance, and the generation time becomes very long depending on the complexity of the asset data.

[0055] The solution of this invention does not go through the editor function UStaticMesh::Build, that is, there is no editor process, so it can achieve game packaging, that is, it can be used in the running state.

[0056] As one embodiment, step 5, generating empty collision data, is achieved in the following way:

[0057] Call the CreateBodySetup function of the static mesh object created in step 4 to generate the UBodySetup structure.

[0058] The UBodySetup is used to store static physical data, and generates actual physical data when it runs.

[0059] The main parameters and parameter values ​​of the UBodySetup structure are as follows:

[0060] (1) bGenerateMirroredCollision (Bool type) is used to indicate whether the necessary data is generated to support the collision of a mirrored version of the static mesh object. In this method, since mirrored meshes are not used, this parameter is set to false.

[0061] (2) bDoubleSidedGeometry (Bool type) is used to characterize whether the physical triangular mesh uses two sides when querying the scene. In this method, this parameter is set to true to prevent program errors when the model is planar or single-sided.

[0062] (3) BodySetupGuid, used to uniquely identify the current UBodySetup. This method calls the FGuid::NewGuid method to generate a GUID as the parameter value for this parameter.

[0063] (4) CollisionTraceFlag (enumeration value), used to characterize the collision detection type. In this method, this parameter is set to CTF_UseComplexAsSimple; this value indicates that only complex collisions are created, and complex collisions are used for all scene queries and collision tests.

[0064] As one embodiment, after generating empty collision data in step 5, the method further includes: calling the CreatePhysicsMeshes method of the static mesh object created in step 4 to generate PhysicsMeshe, in preparation for generating real physical data at runtime.

[0065] As one example, the main parameter setting method (i.e., the main method for setting the build parameters) of the FBuildMeshDescriptionsParams structure in step 6 is as follows:

[0066] (1) Whether to build quickly (Bool type): When this parameter is set to false, the editor code will be used, which will cause the packaging to fail; in this method, dynamic creation must be built quickly, so this parameter is set to true;

[0067] (2) Whether to construct simple collision parameters (Bool type): This method requires to construct simple collision, so this parameter is set to true;

[0068] (3) Whether to allow CPU access (Bool type): This method needs to create a static mesh model at runtime, so this parameter should be set to true;

[0069] Except for the parameter values ​​mentioned above, all other parameters of the FBuildMeshDescriptionsParams structure use default values.

[0070] As one embodiment, step 7 specifically includes the following steps:

[0071] Step 71: Create a temporary FMESHDescription array and call the Emplace function to add the construction structure obtained in Step 3 to the temporary FMESHDescription array.

[0072] Step 72: Pass the temporary FMEshDescription array and the construction parameters obtained in step 6 into the BuildFromMeshDescriptions method to obtain the constructed static mesh object model data.

[0073] As one example, the attributes extracted in step 32 from the MeshDescription include:

[0074] PolygonGroupNames (an array of polygon group names) represents the name of the material for each polygon group;

[0075] VertexPositions (an array of references to vertex positions) represents the position of each vertex;

[0076] Tangents (a reference to the array of tangents) represents the tangent vector for each vertex;

[0077] BinormalSigns (a reference to the binormal array) represents the binormal for each vertex;

[0078] Normals (a reference to the array of normals) represents the tangent vector for each vertex;

[0079] Colors (a reference to an array of vertex colors) represents the vertex color of each vertex;

[0080] UVs (a reference to the array of UVs of a vertex) represent the UVs of each vertex.

[0081] As one embodiment, in step 33, the specific method for creating a polygon group and specifying the default material is as follows:

[0082] Call the CreatePolygonGroup method of MeshDescription to create an empty polygon group, and save the group ID returned by the method into the NewPolygonGroup variable;

[0083] Obtain the Unreal default material using the UMaterial::GetDefaultMaterial method and save the name of the Unreal default material to PolygonGroupNames[NewPolygonGroup];

[0084] Where PolygonGroupNames[NewPolygonGroup] represents the element with index NewPolygonGroup in the PolygonGroupNames array; PolygonGroupNames is obtained through step 32.

[0085] As one embodiment, step 34 is specifically implemented as follows:

[0086] Save the number of elements in the vertex position array from the input model parameter values ​​into the VertexCount variable;

[0087] Save the number of elements in the vertex position array from the input model parameter values ​​into the VertexInstanceCount variable;

[0088] Divide the value of the VertexInstanceCount variable by 3 and save it to the PolygonCount variable;

[0089] Call the MeshDescription's ReserveNewVertices method, passing in VertexCount as the parameter, to set the initial vertex array size to VertexCount;

[0090] Call the MeshDescription's ReserveNewVertexInstances method, passing in VertexInstanceCount as the parameter, to set the initial vertex instance array size to VertexInstanceCount;

[0091] Call the ReserveNewPolygons method of MeshDescription, passing in PolygonCount as the parameter, to set the number of polygons in the initial array to PolygonCount;

[0092] Call the ReserveNewEdges method of MeshDescription, passing in PolygonCount*2 as the parameter, thereby setting the number of edges in the initial array to PolygonCount*2;

[0093] Call the UVs.SetNumChannels method of MeshDescription, passing in 4 as the parameter, to initialize the UV channels to 4.

[0094] As one embodiment, the specific implementation method of copying the vertex position array into MeshDescription in step 35 includes the following steps:

[0095] Step 351: Call the CreateVertex method of MeshDescription to create an empty vertex and save the ID of the empty vertex to the variable VertexID;

[0096] Step 352: Assign the vertex data at this time to VertexPositions[VertexID] (representing the element at the VertexID position of the VertexPositions array of MeshDescription);

[0097] Step 353: Return to step 352 and assign the next vertex data to the element at the corresponding position in the VertexPositions array of MeshDescription, until all vertex data in the vertex position array has been copied into MeshDescription.

[0098] As one embodiment, step 35 further includes:

[0099] Create a map called VertexIndexToVertexID, which stores the correspondence between the vertex numbers in the InVertexs array and the vertex IDs created in MeshDescription.

[0100] As one embodiment, step 36 specifically includes the following steps:

[0101] Step 361: Obtain the vertex number of the current vertex and save it to the variable VertexIndex;

[0102] Step 362: Obtain the vertex ID corresponding to the vertex represented by VertexIndex in MeshDescription using the VertexIndexToVertexID mapping, and save it to the variable VertexID;

[0103] Step 362: Call the CreateVertexInstance function of MeshDescription, pass in VertexID, create an empty vertex instance and obtain the corresponding vertex instance ID, and save the vertex instance ID to the variable VertexInstanceID;

[0104] At this point, the normal array elements, tangent array elements, binormal array elements, vertex color array elements, and UV arrays for the corresponding vertex are created, namely Tangents[VertexInstanceID], Normals[VertexInstanceID], BinormalSigns[VertexInstanceID], Colors[VertexInstanceID], and UVs, respectively.

[0105] Step 363: Assign values ​​to the normal array elements, tangent array elements, binormal array elements, vertex color array elements, and UV array elements corresponding to the current vertex. The specific assignment method is as follows:

[0106] The Tangents[VertexInstanceID] value is assigned to (1.f, 0.f, 0.f), which is the default tangent.

[0107] Normals[VertexInstanceID] is assigned the value (0.f, 0.f, 1.f), meaning the normals are upward by default;

[0108] BinormalSigns[VertexInstanceID] is assigned the value 1.f;

[0109] The value of Colors[VertexInstanceID] is (255,255,255), which means the color is white;

[0110] All four channels of the UV array (UVs) are set to the value of InUVs[VertexIndex] (i.e., the value of the VertexIndex element in the vertex UV array);

[0111] Step 364: Return to step 361 until each vertex position (i.e., each vertex) in the vertex position array InVertexs has completed the creation of a corresponding vertex instance.

[0112] As one embodiment, step 36 further includes:

[0113] Create a map IndiceIndexToVertexInstanceID, which stores the indexes of the InIndices array elements and the corresponding vertex instance IDs created in the MeshDescription.

[0114] As one embodiment, step 37 specifically includes the following steps:

[0115] Step 371: Create an array VertexInstanceIDs of type FVertexInstanceID and initialize its count to 3;

[0116] Step 372: Save the current vertex instance ID and the next two consecutive vertex instance IDs to the array VertexInstanceIDs;

[0117] Step 373: Call the CreatePolygon method of MeshDescription, passing in the array VertexInstanceIDs to generate polygons;

[0118] Step 374: Return to step 371 until all polygons have been generated.

[0119] As one embodiment, in step 38, the normals, tangents, and binormals of all vertices and polygons are regenerated using the ComputeTriangleTangentsAndNormals method. The specific implementation method is a conventional technique in this technical field and will not be described in detail here.

[0120] As one embodiment, the method described in this invention can be implemented in software and / or a combination of software and hardware, for example, using an application-specific integrated circuit (ASIC), a general-purpose computer, or any other similar hardware device.

[0121] The method described in this invention can be implemented as a software program, which can be executed by a processor to achieve the steps or functions described above. Similarly, the software program (including associated data structures) can be stored in a computer-readable recording medium, such as RAM memory, magnetic or optical drives, floppy disks, and similar devices.

[0122] In addition, some steps or functions of the method described in this invention can be implemented in hardware, for example, as a circuit that works with a processor to perform the various steps or functions.

[0123] Furthermore, a portion of the methods described in this invention can be applied as a computer program product, such as computer program instructions, which, when executed by a computer, can invoke or provide the methods and / or technical solutions according to this application through the operation of the computer. The program instructions invoking the methods described in this invention can be stored in a fixed or removable recording medium, and / or transmitted via a data stream in a broadcast or other signal carrying medium, and / or stored in the working memory of a computer device operating according to the program instructions.

[0124] As one embodiment, the present invention also provides an apparatus comprising a memory for storing computer program instructions and a processor for executing the program instructions, wherein when the computer program instructions are executed by the processor, the apparatus is triggered to run a method and / or technical solution based on the foregoing plurality of embodiments.

[0125] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily essential to this application.

[0126] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.

[0127] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make some modifications or alterations to the above-disclosed technical content to create equivalent embodiments without departing from the scope of the present invention. Any simple modifications, equivalent changes, and alterations made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the scope of the present invention.

Claims

1. A method for generating a static mesh model, characterized in that, The method includes the following steps: Step 1: Obtain input model data; the input model data consists of a vertex array, a UV array, and a point sequence array; Step 2: When the input model data is valid, initialize and construct the structure FMeshDescription; Step 3: Set the construction structure according to the input model data; Step 4: Create an empty static mesh object; The static mesh object is a UStaticMesh class object in Unreal Engine, used to store static mesh model data and rendering data; Step 5: Generate empty collision data; Step 6: Set build parameters; The construction parameters are the FBuildMeshDescriptionsParams structure in Unreal Engine; Step 7: Call the mesh description construction function, passing in the construction structure FMeshDescription data and the construction parameter structure, thereby constructing the static mesh object model data; Specifically, step 7 includes the following steps: Step 71: Create a temporary FMeshDescription array and call the Emplace function to add the construction structure obtained in step 3 to the temporary FMeshDescription array; Step 72: Pass the temporary FMEshDescription array and the construction parameters obtained in step 6 into the BuildFromMeshDescriptions method to obtain the constructed static mesh object model data; In step 3, the specific method for setting the construction structure based on the input model data includes: Step 31: Read the input model data to obtain the input model parameter values, and create an empty construction structure FMeshDescriptin object MeshDescription; The input model parameter values ​​include: vertex position array InVertexs, point number array InIndices, and vertex UV array InUVs; Step 32: Extract the attributes from MeshDescription using the FStaticMeshAttributes utility class; Step 33: Create a polygon group and specify the default material; Step 34: Initialize the vertices, vertex instances, polygons, edges, and UV channels of MeshDescription; Step 35: Copy the vertex position array data from the input model data into MeshDescription; Step 36: Create a vertex instance for each vertex in the input model data based on the vertex index array; Step 37: Create polygons for the polygon group; Step 38: Regenerate the normals, tangents, and binormals of all vertices and polygons; at this point, the MeshDescription is the completed construction structure FMeshDescription.

2. The method according to claim 1, characterized in that, Step 5, generating empty collision data, is achieved in the following way: Call the CreateBodySetup function of the static mesh object created in step 4 to generate the UBodySetup structure; the UBodySetup is used to store static physical data. After generating empty collision data in step 5, the process also includes calling the CreatePhysicsMeshes method of the static mesh object created in step 4 to generate a PhysicsMeshe.

3. The method according to claim 1, characterized in that, In step 33, the specific method for creating a polygon group and specifying the default material is as follows: Call the CreatePolygonGroup method of MeshDescription to create an empty polygon group, and save the group ID returned by the method into the NewPolygonGroup variable; Obtain the Unreal default material using the UMaterial::GetDefaultMaterial method and save the name of the Unreal default material to PolygonGroupNames[NewPolygonGroup]; Where PolygonGroupNames[NewPolygonGroup] represents the element with index NewPolygonGroup in the PolygonGroupNames array; PolygonGroupNames is obtained through step 32.

4. The method according to claim 1, characterized in that, The specific implementation method of step 34 is as follows: Save the number of elements in the vertex position array from the input model parameter values ​​into the VertexCount variable; Save the number of elements in the vertex position array from the input model parameter values ​​into the VertexInstanceCount variable; Divide the value of the VertexInstanceCount variable by 3 and save it to the PolygonCount variable; Call the MeshDescription's ReserveNewVertices method, passing in VertexCount as the parameter, to set the initial vertex array size to VertexCount; Call the MeshDescription's ReserveNewVertexInstances method, passing in VertexInstanceCount as the parameter, to set the initial vertex instance array size to VertexInstanceCount; Call the ReserveNewPolygons method of MeshDescription, passing in PolygonCount as the parameter, to set the number of polygons in the initial array to PolygonCount; Call the ReserveNewEdges method of MeshDescription, passing in PolygonCount*2 as the parameter, thereby setting the number of edges in the initial array to PolygonCount*2; Call the UVs.SetNumChannels method of MeshDescription, passing in 4 as the parameter, to initialize the UV channels to 4.

5. The method according to claim 1, characterized in that, Step 35 includes the following steps: Step 351: Call the CreateVertex method of MeshDescription to create an empty vertex and save the ID of the empty vertex to the variable VertexID; Step 352: Assign the vertex data at this time to the element at the VertexID position of the VertexPositions array of MeshDescription; Step 353: Return to step 352 and assign the next vertex data to the element at the corresponding position in the VertexPositions array of MeshDescription, until all vertex data in the vertex position array has been copied into MeshDescription.

6. The method according to claim 1, characterized in that, Step 36 specifically includes the following steps: Step 361: Obtain the vertex number of the current vertex and save it to the variable VertexIndex; Step 362: Obtain the vertex ID corresponding to the vertex represented by VertexIndex in MeshDescription and save it to the variable VertexID; Step 362: Call the CreateVertexInstance function of MeshDescription, pass in VertexID, create an empty vertex instance and obtain the corresponding vertex instance ID, and save the vertex instance ID to the variable VertexInstanceID; Step 363: Assign values ​​to the normal array element, tangent array element, binormal array element, vertex color array element, and UV array corresponding to the current vertex; Step 364: Return to step 361 until each vertex position in the vertex position array InVertexs has had its corresponding vertex instance created.

7. The method according to claim 1, characterized in that, Step 37 specifically includes the following steps: Step 371: Create an array VertexInstanceIDs of type FVertexInstanceID and initialize its count to 3; Step 372: Save the current vertex instance ID and the next two consecutive vertex instance IDs to the array VertexInstanceIDs; Step 373: Call the CreatePolygon method of MeshDescription, passing in the array VertexInstanceIDs to generate polygons; Step 374: Return to step 371 until all polygons have been generated.

8. The method according to claim 1, characterized in that... , In step 38, the normals, tangents, and binormals of all vertices and polygons are regenerated using the ComputeTriangleTangentsAndNormals method.

Images