Methods, apparatus and electronic equipment for cloud and fog generation

Abstract

The application provides a cloud and mist generation method and device and electronic equipment, obtains a 2D noise map and a texture coordinate of each vertex of a plane model; samples the 2D noise map according to the texture coordinate of each vertex to determine an initial vertex offset corresponding to each vertex; obtains an offset factor changing with time for each vertex; further determines a first vertex offset changing with time for each vertex; and renders and generates a target cloud and mist corresponding to the plane model based on the first vertex offset. In this way, the initial vertex offset corresponding to each vertex in the plane model can be determined by sampling the 2D noise map, and the first vertex offset is determined in combination with the offset factor changing with time. Since the first vertex offset of each vertex changes with time, a more dynamic and flexible target cloud and mist can be obtained based on the first vertex offset to match flexible cloud and mist generation requirements.

Description

Technical Field

[0001] This invention relates to the field of game technology, and in particular to a method, apparatus and electronic device for generating clouds and fog. Background Technology

[0002] As the mobile game market matures, the development requirements for mobile games are becoming increasingly clear. These requirements demand high-quality production effects while minimizing performance overhead. Cloud and fog rendering effects are often necessary in some game scenes. Related technologies include parallax mapping and volumetric fog generation based on 3DTextures. However, parallax mapping is prone to errors when the height map changes drastically, and it only guarantees good results within a small area. It struggles to achieve satisfactory results when the viewpoint moves flexibly or is close to a plane. 3DTexture-based solutions require multi-pass rendering, and updating effects necessitates generating new 3DTexture samples, resulting in significant performance overhead. Therefore, current fog generation solutions are limited to choosing between fixing the viewpoint to reduce overhead or increasing performance and technical requirements, making it difficult to meet the flexible fog generation needs. Summary of the Invention

[0003] The purpose of this invention is to provide a cloud and fog generation method, apparatus and electronic device to provide a flexible cloud and fog solution to match flexible cloud and fog rendering needs.

[0004] This invention provides a method for generating clouds and fog, comprising: acquiring a preset planar model and a 2D noise map; wherein the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1; acquiring the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system; sampling the 2D noise map according to the texture coordinates of each vertex to obtain a first grayscale value corresponding to each vertex, and determining the first grayscale value corresponding to each vertex as an initial vertex offset; acquiring the offset factor of each vertex of the planar model as it changes over time; wherein the offset factor is a variable based on preset cloud and fog movement speed parameters; determining the first vertex offset of each vertex as it changes over time based on the initial vertex offset and the offset factor; and rendering and generating the target clouds and fog corresponding to the planar model based on the first vertex offset.

[0005] This invention provides a cloud and fog generation device, comprising: a first acquisition module for acquiring a preset planar model and a 2D noise map; wherein the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1; a second acquisition module for acquiring the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system; a first determination module for sampling the 2D noise map according to the texture coordinates of each vertex to obtain a first grayscale value corresponding to each vertex, and determining the first grayscale value corresponding to each vertex as an initial vertex offset; a fourth acquisition module for acquiring the offset factor of each vertex corresponding to the planar model over time; wherein the offset factor is a variable based on a preset cloud and fog movement speed parameter; a second determination module for determining the first vertex offset of each vertex over time based on the initial vertex offset and the offset factor; and a third determination module for rendering and generating target clouds and fog corresponding to the planar model based on the first vertex offset.

[0006] The present invention provides an electronic device, including a processor and a memory, wherein the memory stores machine-executable instructions that can be executed by the processor, and the processor executes the machine-executable instructions to implement the cloud generation method described above.

[0007] The present invention provides a machine-readable storage medium storing machine-executable instructions. When the machine-executable instructions are called and executed by a processor, the machine-executable instructions cause the processor to implement any of the above-mentioned cloud and fog generation methods.

[0008] The cloud and fog generation method, apparatus, and electronic device provided by this invention first acquire a preset planar model, a 2D noise map, and the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system. Based on the texture coordinates of each vertex, the 2D noise map is sampled to obtain a first grayscale value corresponding to each vertex, and this first grayscale value is determined as the initial vertex offset for each vertex. The offset factor of each vertex in the planar model as a function of time is obtained. Based on the initial vertex offset and the offset factor, the first vertex offset of each vertex as a function of time is determined. The target cloud and fog corresponding to the planar model is then rendered based on the first vertex offset. This method, by sampling the 2D noise map, can determine the initial vertex offset of each vertex in the planar model, and then combine this with the offset factor as a function of time to determine the first vertex offset. Since the first vertex offset of each vertex changes over time, a more dynamic and flexible target cloud and fog can be obtained based on the first vertex offset to match flexible cloud and fog generation requirements. Attached Figure Description

[0009] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0010] Figure 1 A flowchart of a cloud and fog generation method provided in an embodiment of the present invention;

[0011] Figure 2 A flowchart of a cloud and fog generation method provided in an embodiment of the present invention;

[0012] Figure 3 This is a schematic diagram of the cloud and fog effect before fluffing, provided as an embodiment of the present invention;

[0013] Figure 4 This is a schematic diagram illustrating the fluffy cloud effect provided in an embodiment of the present invention;

[0014] Figure 5 A schematic diagram of a surface result provided in an embodiment of the present invention;

[0015] Figure 6 A schematic diagram of a surface result provided in an embodiment of the present invention;

[0016] Figure 7 A flowchart of a cloud and fog generation method provided in an embodiment of the present invention;

[0017] Figure 8 A schematic diagram of a cloud and fog effect provided in an embodiment of the present invention;

[0018] Figure 9 A flowchart of a cloud and fog generation method provided in an embodiment of the present invention;

[0019] Figure 10 A schematic diagram of a cloud and fog effect provided in an embodiment of the present invention;

[0020] Figure 11 A schematic diagram of a cloud and fog effect provided in an embodiment of the present invention;

[0021] Figure 12 A schematic diagram of a cloud and fog effect provided in an embodiment of the present invention;

[0022] Figure 13 This is a schematic diagram of the cloud and mist on the surface of a real hot spring, provided as an embodiment of the present invention.

[0023] Figure 14 This is a schematic diagram of the structure of a cloud and fog generation device provided in an embodiment of the present invention;

[0024] Figure 15 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention. Detailed Implementation

[0025] The technical solution of the present invention will be clearly and completely described below with reference to the embodiments. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. 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.

[0026] In one embodiment of this disclosure, the cloud and fog generation method can run on a local terminal device or a server. When the cloud and fog generation method runs on a server, the method can be implemented and executed based on a cloud interaction system, wherein the cloud interaction system includes a server and a client device.

[0027] In an optional implementation, various cloud applications, such as cloud gaming, can run under the cloud interaction system. Taking cloud gaming as an example, cloud gaming refers to a gaming method based on cloud computing. In the cloud gaming operating mode, the game program and the game screen presentation are separated. The storage and execution of the cloud generation method are completed on the cloud gaming server. The client device is used for data reception, transmission, and game screen presentation. For example, the client device can be a display device with data transmission capabilities located close to the user, such as a mobile terminal, television, computer, or PDA; however, the information processing is performed by the cloud gaming server in the cloud. When playing the game, the player operates the client device to send operation commands to the cloud gaming server. The cloud gaming server runs the game according to the operation commands, encodes and compresses the game screen and other data, returns it to the client device via the network, and finally, the client device decodes and outputs the game screen.

[0028] In an optional implementation, taking a game as an example, the local terminal device stores the game program and is used to display the game screen. The local terminal device is used to interact with the player through a graphical user interface (GUI), i.e., conventionally by downloading, installing, and running the game program via an electronic device. The local terminal device can provide the GUI to the player in various ways, such as rendering it on the terminal's display screen or providing it to the player via holographic projection. For example, the local terminal device can include a display screen for displaying the GUI, which includes game screens, and a processor for running the game, generating the GUI, and controlling the display of the GUI on the display screen.

[0029] In one possible implementation, this application provides a cloud and fog generation method that provides a graphical user interface through a terminal device. The terminal device can be either the aforementioned local terminal device or a client device in the aforementioned cloud interaction system.

[0030] As the mobile game market matures, the development requirements for mobile games are becoming increasingly clear. These requirements include low performance consumption, high-quality visuals, and wide applicability. Cloud and fog rendering effects are often needed in some game scenes. Related technologies include parallax mapping or volumetric fog creation based on 3D Textures. These two methods will be introduced below:

[0031] Parallax mapping, also known as parallax mapping, is an improved bump mapping or normal mapping technique used in 3D rendering applications such as video games. The specific implementation of parallax mapping is as follows: Using a height map, the height H(T0) at the corresponding texture coordinate T0 is read. The height map is typically a grayscale image, storing rectangular arrays of values ​​that represent vertex heights. Normally, parallax mapping uses the values ​​in the height map as depth; here, it's used as height to simulate cloud protrusions. The intersection of the camera vector V and the height surface defined by the height map is calculated, and then offset according to the original texture coordinates. To achieve better results, offset methods include:

[0032] (1) With parallax limit: Offset along the x and y directions of camera vector V to avoid erroneous results when the angle between camera vector V and normal vector N is too large; where, normal vector refers to a straight line that is always perpendicular to a plane. In geometry, normal refers to a line on a plane that is perpendicular to the tangent to a curve at a certain point.

[0033] (2) Steep Parallax Mapping (SPM): The surface height is divided into several equally spaced layers. Then, starting from the bottom layer, the height map is sampled, and the texture coordinates are offset along the V direction each time. If a point is already higher than the highest surface, the inspection stops and the texture coordinates of the last sample are used as the result. This results in a more accurate texture offset.

[0034] (3) Relief Parallax Mapping (RPM): Take the two nearest height layers above and below the intersection of the camera vector V and the height map. The results can be improved by using the texture offset coordinates corresponding to these two height layers in a binary search.

[0035] 3DTexture, or three-dimensional texture, is implemented as follows: In Unity Shaders, each Pass represents rendering one layer. Each layer offsets vertex positions along normals. For multi-layered effects, the current layer is used as the offset coefficient, so the later the layer in the Pass, the more outwards it is offset. Multiple Passes are used to simultaneously sample the noise map of the 3DTexture to achieve transparency perturbation for different layers. Here, Shader can be understood as a material editor or shader, a technique used to render 3D graphics. A Pass simply completes the graphics rendering process; multiple Passes require multiple Passes to work together to achieve the final effect for rendering a single frame.

[0036] Current solutions using parallax mapping are prone to errors when the height map changes drastically, and they only guarantee effectiveness within a limited range. They struggle to perform well when the viewpoint moves flexibly or is close to the plane. 3DTexture-based solutions require multi-pass rendering, and updating effects necessitates generating new 3DTexture samples, resulting in significant performance overhead. Therefore, this invention provides a cloud / fog generation method, apparatus, and electronic device. This technology can be applied to scenes requiring cloud / fog rendering in game environments.

[0037] To facilitate understanding of this embodiment, a cloud and fog generation method disclosed in this disclosure embodiment will be described first, such as... Figure 1 As shown, the method includes:

[0038] Step S102: Obtain a preset planar model and a 2D noise map; wherein, the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1.

[0039] The cloud and fog generation method in this embodiment can use Unity (an engine and game development tool) with editor version 2021.3.0f1 and rendering mode URP (a type of rendering pipeline, a programmable rendering pipeline mechanism based on the Unity game engine). Of course, other versions can also be selected, which are not limited here. First, a planar model needs to be created and assigned a material shader in this embodiment. The shape of the planar model can be set according to actual needs. The planar model usually has multiple vertices. For example, the planar model can be divided evenly, and multiple horizontal lines and multiple vertical lines can be drawn. The multiple intersections formed by the multiple horizontal lines and multiple vertical lines are used as vertices. The above-mentioned 2D noise map is usually an arbitrary noise map that is not very sharp. Considering that clouds and fog are relatively smoother, Gaussian blur and Burmester noise can be used. In the 2D noise map, the gray value of each pixel is between 0 and 1, where 0 is black and 1 is white.

[0040] Step S104: Obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system.

[0041] The texture coordinates mentioned above can be represented by UV, where U typically represents the distribution on the horizontal coordinate and V represents the distribution on the vertical coordinate. Texture coordinates allow each point on the 2D noise map to be precisely mapped to the surface of the planar model. In practical implementation, the texture coordinate system corresponding to the planar model can be obtained, and the texture coordinates of each vertex in the texture coordinate system can be determined. The texture coordinates typically range from 0 to 1.

[0042] Step S106: Based on the texture coordinates of each vertex, sample the 2D noise map to obtain the first gray value corresponding to each vertex, and determine the first gray value corresponding to each vertex as the initial vertex offset corresponding to each vertex.

[0043] This embodiment obtains different offsets for each vertex by sampling a 2D noise map. Specifically, the 2D noise map can be sampled according to the texture coordinates of each vertex to obtain the first gray value at the corresponding position of each vertex. Since the 2D noise map is usually an arbitrary noise map, the first gray value corresponding to each vertex is usually different. Each first gray value can be determined as the initial vertex offset corresponding to the vertex. The fixed vertex offset value refers to the sampling of the 2D noise map by UVs that do not change with time, using only the original UVs.

[0044] Step S108: Obtain the offset factor of each vertex of the planar model as it changes over time; wherein, the offset factor is a variable based on the preset cloud and fog movement speed parameter.

[0045] To obtain more dynamic and flexible clouds and fog, enabling them to change shape over time, an offset factor can be set. This offset factor is related to time and also to the user-defined speed parameter _Speed, which is typically the user-defined cloud and fog movement speed parameter.

[0046] Step S110: Based on the initial vertex offset and offset factor, determine the first vertex offset of each vertex as it changes over time.

[0047] In order to obtain clouds with richer and more flexible shapes, after obtaining the initial vertex offset and offset factor corresponding to each vertex, the corresponding initial vertex offset and offset factor can be calculated in a preset way, such as taking the average value or weighting according to preset weights, so as to obtain the first vertex offset that changes over time.

[0048] Step S112: Render the target cloud and fog corresponding to the planar model based on the offset of the first vertex.

[0049] The target cloud and fog corresponding to the planar model can be rendered based on the first vertex offset of each vertex as it changes over time. Typically, since the offset factor is related to time, each vertex usually has a different first vertex offset at different times. Therefore, at each time point, the position of each vertex can be determined according to the first vertex offset of each vertex, and then the target cloud and fog corresponding to that time point can be rendered. That is, the target cloud and fog usually exhibit different forms as time changes.

[0050] The aforementioned cloud generation method first acquires a preset planar model, a 2D noise map, and the texture coordinates of each vertex of the planar model in its corresponding texture coordinate system. Based on the texture coordinates of each vertex, the 2D noise map is sampled to obtain the first grayscale value corresponding to each vertex, and this first grayscale value is determined as the initial vertex offset for each vertex. The offset factor of each vertex in the planar model as a function of time is then obtained. Based on the initial vertex offset and the offset factor, the first vertex offset of each vertex as a function of time is determined. Finally, the target cloud corresponding to the planar model is generated by rendering based on the first vertex offset. This method, by sampling the 2D noise map, can determine the initial vertex offset of each vertex in the planar model, and then combine this with the offset factor as a function of time to determine the first vertex offset. Since the first vertex offset of each vertex changes over time, a more dynamic and flexible target cloud can be obtained based on the first vertex offset to match flexible cloud generation requirements.

[0051] In an optional implementation, the method is based on the method of the above embodiments; the method focuses on describing the specific process of determining the first vertex offset of each vertex over time based on the initial vertex offset and the offset factor, specifically corresponding to steps S210 to S216 below, as follows. Figure 2 As shown, the method includes the following steps:

[0052] Step S202: Obtain a preset planar model and a 2D noise map; wherein, the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1.

[0053] Step S204: Obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system.

[0054] Step S206: Based on the texture coordinates of each vertex, sample the 2D noise map to obtain the first gray value corresponding to each vertex, and determine the first gray value corresponding to each vertex as the initial vertex offset corresponding to each vertex.

[0055] Step S208: Obtain the offset factor of each vertex of the planar model as it changes over time; wherein the offset factor is a variable based on the preset cloud and fog movement speed parameter.

[0056] Step S210: For each vertex at each time point, calculate the sum of the initial vertex offset corresponding to that vertex and the offset factor corresponding to that time point to obtain the offset sum result.

[0057] In this embodiment, the sum of different offsets for each vertex can be obtained by sampling a 2D noise map. The effect of billowing clouds is achieved by offsetting the vertices in the vertex shader. Here, the vertex shader typically refers to a set of instruction code that is executed when the vertex is rendered. Vertex offset can be understood as the vertex shifting from its original position recorded in the model to a new position within the vertex shader. In other words, flexible cloud deformation can be controlled using a simple 2D noise map. The offset factor can be determined as follows: multiply the time coefficient _Time.x(_Time(t / 20, t, 2t, 3t), where t is the time elapsed since scene loading, and _Time.x is t / 20) by the user-adjustable speed parameter _Speed ​​to obtain the result of translating the texture coordinates over time. Sampling yields a smoothly transformed vertex offset. Here, t / 20 is the smallest term in Unity's built-in time.xyzw. Because the clouds move slowly, a minimum scale was used, but it was multiplied by the `_Speed` property, allowing for external adjustment of the movement speed. The `_Speed` parameter mentioned above is the user-defined cloud movement speed parameter. By multiplying `t / 20` by the `_Speed` parameter, the speed of cloud movement can be controlled. For each vertex at each time point, adding its corresponding time-varying offset factor to the initial vertex offset can simulate changes in different layers of cloud. This method allows for a simple, flexible, and cost-effective surface volume cloud solution in Unity.

[0058] Step S212: Average the sum of the offsets to obtain the average value, and use the average value as the first average offset of the vertex at that time point.

[0059] Step S214: The first average offset is controlled within a preset first range by a preset first function to obtain the second average offset of the vertex at that time point.

[0060] The aforementioned first preset function can be the `saturate` function. The `saturate(x)` function can set x values ​​greater than 1 to 1 and x values ​​less than 0 to 0. The aforementioned first range is usually [0, 1]. In actual implementation, after obtaining the sum of the aforementioned offsets, the average value can be calculated to obtain the first average offset. The `saturate` function is then used to control the first average offset within the range [0, 1] to obtain the second average offset for each vertex at each time point. The specific code implementation can be as follows:

[0061]

[0062] Where IN.uv represents the original UV texture coordinates; NoiseTex represents the 2D noise map; TRANSFORM_TEX represents the scaling and offset map values ​​obtained from the _NoiseTex 2D noise map, with the default scaling being 1 and the offset being 0; OUT.CloudUV01 represents offsetting the UV texture coordinates using a time factor and a speed parameter, and outputting the offset texture coordinates; _Time.x represents the time factor; _Speed ​​represents the speed parameter; OUT.CloudUV02 represents outputting an initial UV texture coordinate that has not undergone offset; tex2Dlod represents the texture sampling function; OUT.noisePos.x represents outputting noisePos. The first floating-point number in the os vector; OUT.noisePos.x is obtained by sampling the _NoiseTex 2D noise map using the UV texture coordinates offset by Out.CloudUV01; float4 represents a four-dimensional vector consisting of four floating-point numbers (float), which can be represented by XYZW or RGBA; r represents the first floating-point number of the value obtained after texture sampling, which can also be represented by X; OUT.noisePos.y represents the second floating-point number of the output noisePos vector; noisecount represents the first average offset; the saturate() function is used to set values ​​greater than 1 to equal 1 and values ​​less than 0 to equal 0. 。

[0063] Step S216: Based on each second average offset corresponding to the vertex at each time point, determine the first vertex offset that changes over time.

[0064] This step S216 can be achieved through the following steps one through three:

[0065] Step 1: By presetting the second function and the presetting exponent, adjust each second average offset to obtain the adjusted third average offset of the vertex at each time point.

[0066] The second function mentioned above can be the pow function, whose expression is pow(x,y)=x y The `pow` function can be used to adjust the second average offset of each vertex at each time point. Specifically, the second average offset can be used as the base, and the adjustable `_Fluffy` exposed by the external environment can be used as the exponent to obtain the corresponding adjusted third average offset, thereby achieving the fluffiness of the clouds. Figure 3 The illustration shows a cloud effect before it becomes fluffy, and Figure 4 The image shown illustrates a fluffy cloud / mist effect; the specific code implementation is as follows:

[0067] nosiecount=pow(noisecount,_Fluffy).

[0068] Here, noisecount represents the first average offset; the pow() function is used to calculate noisecount raised to the power of _Fluffy; _Fluffy represents the exponent. 。

[0069] Step two: Map the third average offset from the first range to the second range, and take the absolute value of the mapping result to obtain the fourth average offset of the vertex at each time point.

[0070] The second range mentioned above is usually a larger range than the first range; in actual implementation, the remap function can be used to map the third average offset noisecount of each vertex at each time point from [0, 1] to a larger, customizable new range [_ShapeAdjust1, _ShapeAdust2] to obtain something like this. Figure 5 The diagram shows a surface result, and then the absolute value of the result is taken to achieve the following. Figure 6 The diagram shows a surface result, which yields the fourth average offset for each vertex at each time point. This method allows for the generation of more undulating, cloud-like shapes. The `remap` function, with the form `remap(x, t1, t2, s1, s2)`, returns `(x-t1) / (t2-t1)*(s2-s1)+s1`, mapping `x` from the range (t1, t2) to (s1, s2).

[0071] Step 3: By using a preset third function to control the fourth average offset within the first range, the first vertex offset of the vertex as it changes over time is obtained.

[0072] The third function mentioned above can be the `smoothstep` function. In actual implementation, to prevent abrupt changes in vertex offsets and ensure sufficient cloud smoothness, the `smoothstep` function can be used to re-control the fourth average offset of each vertex at each time point within the first range, i.e., smoothing within the range [0, 1]. The function form of `smoothstep` is `smoothstep(min, max, x)`: it returns a value of -2*((x-min) / (max-min))³+3*((x-min) / (max-min))². The specific code implementation can be as follows:

[0073] noisecount=abs(remap(noisecount, 0.0f, 1.0f, _shapeAdjust1, _ShapeAdjust2));

[0074] noisecount=saturate(smoothstep(0.0f, 1.0f, noisecount));

[0075] Here, noisecount represents the first average offset; the abs() function takes the absolute value; the remap() function maps the first average offset from [0, 1] to a larger, customizable new range [_ShapeAdjust1, _ShapeAdjust2]; and the smoothstep() function generates a smooth transition value from 0 to 1.

[0076] Step S218: Render the target cloud and fog corresponding to the planar model based on the first vertex offset.

[0077] The aforementioned cloud generation method calculates the sum of the initial vertex offset and the offset factor corresponding to that vertex at each time point for each vertex, obtaining a summed offset result. The average of these summed offsets is then calculated, and this average is used as the first average offset for that vertex at that time point. The first average offset is controlled within a preset first range using a preset first function, resulting in a second average offset for that vertex at that time point. Based on each second average offset for that vertex at each time point, the first vertex offset that changes over time is determined, thereby determining the target cloud at each time point. This method calculates the first average offset by summing and averaging the initial vertex offset and the offset factor corresponding to that time point for each vertex. By controlling and adjusting the range of the first average offset, a first vertex offset that changes over time is obtained. Therefore, based on the first vertex offset, a more dynamic and flexible target cloud can be obtained to match flexible cloud generation requirements.

[0078] In an optional implementation, the method is based on the method of the above embodiments; the method focuses on describing the specific process of generating fused clouds and fog, such as... Figure 7 As shown, the method includes the following steps:

[0079] Step S702: Obtain a preset planar model and a 2D noise map; wherein, the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1.

[0080] Step S704: Obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system.

[0081] Step S706: Based on the texture coordinates of each vertex, sample the 2D noise map to obtain the first gray value corresponding to each vertex, and determine the first gray value corresponding to each vertex as the initial vertex offset corresponding to each vertex.

[0082] Step S708: Obtain the offset factor of each vertex of the planar model as it changes over time; wherein the offset factor is a variable based on the preset cloud and fog movement speed parameter.

[0083] Step S710: Based on the initial vertex offset and offset factor, determine the first vertex offset of each vertex as it changes over time.

[0084] Step S712: Render the target cloud and fog corresponding to the planar model based on the offset of the first vertex.

[0085] Step S714: In response to the scaling command for the 2D noise map, scale the 2D noise map by a preset scaling factor.

[0086] Step S716: Based on the texture coordinates of each vertex, sample the scaled 2D noise map to obtain the second grayscale value corresponding to each vertex.

[0087] The scaling factor mentioned above can also be understood as scaling the intensity of the clouds and fog. In order to simulate the actual effect of clouds and fog having large areas and details, the above 2D noise map can be resampled. Specifically, the scaling of the texture can be adjusted using _BaseScale to simulate scaling the size of the clouds. Specifically, the 2D noise map can be enlarged or reduced according to the preset scaling factor to obtain the enlarged or reduced 2D noise map. Then, it can be resampled according to the texture coordinates of each vertex. Since the 2D noise map has been enlarged or reduced, the second gray value corresponding to each vertex is usually different from the first gray value obtained before scaling the 2D noise map. The second gray value is the value in [0,1] obtained by sampling the enlarged or reduced 2D noise map.

[0088] Step S718: Multiply the second grayscale value corresponding to each vertex by the scaling factor to obtain the second vertex offset of each vertex; wherein, the second vertex offset of each vertex corresponds to the offset of the scaled fog; wherein, the scaled fog is rendered and generated based on the second vertex offset.

[0089] After obtaining the second grayscale value corresponding to each vertex, the second grayscale value of each sampled vertex can be multiplied by the intensity of the scaled fog to obtain the second vertex offset of each vertex, that is, the offset of the scaled fog. The specific calculation method is as follows: offset of scaled fog = noisebase (value in [0,1] obtained by sampling the black and white noise map) * _BaseStrength (intensity of scaled fog); the above scaled fog can be generated based on the second vertex offset. For the specific rendering process, please refer to the relevant description of the target fog generation above, which will not be repeated here.

[0090] Step S720: For each time point, the target fusion offset of each vertex at that time point is calculated based on the first vertex offset, the second vertex offset, and the scaling factor of each vertex at that time point.

[0091] This step S720 can be achieved through steps five through eight:

[0092] Step 5: For each vertex at each time point, calculate the sum of the offset of the second vertex and the offset of the first vertex to obtain the first sum result.

[0093] Compared to the scaled fog, the target fog corresponds to the detailed fog; the second vertex offset corresponds to the offset of the scaled fog; the first vertex offset corresponds to the offset of the detailed fog, i.e., the target fog. In specific implementation, the second vertex offset corresponding to each vertex at each time point can be added to the corresponding first vertex offset to obtain the first summation result corresponding to each vertex at each time point. The first summation result can be (the offset of the scaled fog + the offset of the detailed fog).

[0094] Step 6: Calculate the sum of the scaling factor and the preset fixed value to obtain the second summation result.

[0095] Step 7: Divide the first sum by the second sum to obtain the first calculation result.

[0096] The aforementioned preset fixed value can be 1, or other fixed values ​​can be selected according to actual needs; if the preset fixed value is 1, the second summation result can be (1+_BaseStrength), where _BaseStrength corresponds to the scaling factor, that is, the intensity of scaling the fog; the first calculation result can be: first calculation result = (offset of scaling fog + offset of detail fog) / (1+_BaseStrength).

[0097] Step 8: Control the first calculation result within a preset first range using a preset first function to obtain the target fusion offset corresponding to the vertex.

[0098] The aforementioned first preset function can be the saturate function. The saturate(x) function can set x values ​​greater than 1 to equal 1 and x values ​​less than 0 to equal 0. The aforementioned first range is usually the range [0, 1]. In actual implementation, after obtaining the aforementioned first calculation result, the saturate function can be used to control the first calculation result within the range [0, 1] to obtain the target fusion offset of each vertex at each time point.

[0099] Step S722: Determine the fused cloud and fog corresponding to the time point based on the target fusion offset of each vertex corresponding to the time point; wherein, the fused cloud and fog is the fusion of the scaled cloud and fog and the target cloud and fog corresponding to the time point.

[0100] In practical implementation, at each time point, the position of each vertex can be determined according to the target fusion offset corresponding to each vertex, and then the fused fog corresponding to that time point can be rendered to achieve the merging and blending of scaling fog and detail fog. If scaling fog is directly superimposed on fine target fog, it will have an strange look of simply the two overlapping. Therefore, if the sum of the two values ​​exceeds 1, it is replaced with 1, so that the two can be blended, and the fusion effect is more natural; for example... Figure 8 The image shown is a schematic diagram of a cloud / fog effect; the specific code implementation is as follows:

[0101] float2 baseuv=IN.uv*_BaseScale+_Time.x*_speed*0.5f;

[0102] float noisebase=tex2DIod(_NoiseTex, float4(baseuv, 0, 0)).r;

[0103] noisecount=saturate((noisebase*_BaseStrength+noisecount) / (1+_BaseStrength));

[0104] Wherein, baseuv represents a new UV texture coordinate, which is calculated from the original texture coordinate IN.UV (BaseScale is the scaling factor of the UV texture coordinate, and the UV texture coordinate is also offset by a time factor); BaseStrength corresponds to the scaling factor (i.e., scaling the intensity of the fog); noisebase represents the scaled fog obtained by sampling the 2D noise map NoiseTexz using the UV texture coordinate BaseUV; NoiseTex represents the 2D noise map; float4 represents a four-dimensional vector consisting of four floating-point numbers (foat), which can be represented by XYZW or RGBA; r represents the first floating-point number of the value obtained after sampling the texture, which can also be represented by X.

[0105] The aforementioned cloud generation method, in response to a scaling command for a 2D noise map, scales the 2D noise map according to a preset scaling factor. Based on the texture coordinates of each vertex, the scaled 2D noise map is sampled to obtain a second grayscale value corresponding to each vertex. The second grayscale value corresponding to each vertex is multiplied by the scaling factor to obtain the second vertex offset of each vertex; where the second vertex offset of each vertex corresponds to the offset of the scaled cloud. For each time point, based on the first vertex offset, the second vertex offset, and the scaling factor of each vertex at that time point, the target fusion offset of each vertex at that time point is calculated. Based on the target fusion offset of each vertex at that time point, the fused cloud is determined; where the fused cloud is a fusion of the scaled cloud and the target cloud at that time point. This method scales and resamples the 2D noise map to obtain the second vertex offset of each vertex corresponding to the scaled fog. By combining the first vertex offset of each vertex corresponding to the target fog and the scaling factor, the target fusion offset can be determined. The fused fog determined according to the target fusion offset achieves the effect that the scaled fog can swallow the previously formed detailed target fog, instead of directly superimposing the fine fog on the scaled fog, thus achieving the sense of stagger between the scaled fog and the detailed fog.

[0106] In an optional implementation, the method is based on the method of the above embodiments; the method focuses on describing the specific process of generating fused clouds and fog, such as... Figure 9 As shown, the method includes the following steps:

[0107] Step S902: Obtain a preset planar model and a 2D noise map; wherein, the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1.

[0108] Step S904: Obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system.

[0109] Step S906: Based on the texture coordinates of each vertex, sample the 2D noise map to obtain the first gray value corresponding to each vertex, and determine the first gray value corresponding to each vertex as the initial vertex offset corresponding to each vertex.

[0110] Step S908: Obtain the offset factor of each vertex of the planar model as it changes over time; wherein, the offset factor is a variable based on the preset cloud and fog movement speed parameter.

[0111] Step S910: Based on the initial vertex offset and offset factor, determine the first vertex offset of each vertex as it changes over time.

[0112] Step S912: For each time point, adjust the first vertex offset of each vertex corresponding to that time point to obtain the target vertex offset of each vertex; wherein, the vertex farther away from the center of the planar model has a larger upward target vertex offset.

[0113] After obtaining the first vertex offset, the final vertex offset can be controlled using a custom height parameter _Height. This allows for an overall adjustment of the first vertex offset for each vertex at each time point, deepening the overall depth to create a deeper bowl-shaped form. Figure 10 The diagram illustrates a cloud / fog effect. The distance between a vertex and the center of the planar model can be determined using the `distance` function, achieving a bowl-shaped effect where the further away from the center point, the greater the upward offset. This makes it easier for the camera to see things outside the plane while moving within the plane, improving flexibility. The `distance` function is defined as: `distance(float2(x1, y1), float2(x2, y2))`, which calculates the distance between points (x1, y1) and (x2, y2). The specific code implementation is as follows:

[0114] OUT.positionCS.y-=noisecount*_Height;

[0115] OUT.positionCS.y-=distance(float2(0,0), OUT.positionWS.xz)*_DcurvatureRadius;

[0116] Here, out.positionCS represents the vertex position in the final output clip space, and out.positionCS.y represents the second floating-point number of this vertex position; noisecount represents the offset of the first vertex; _Height is a custom height parameter; Out.positionWS represents the position of the model vertex in world space, and Out.positionWS.xz represents the first and third floating-point numbers of this position; distance is used to calculate the distance from (0,0) to OUT.positionWS.xz; _DcurvatureRadius indicates that the distance between the vertex and the center of the planar model is determined by the distance function, achieving a bowl-shaped effect where the further away from the center point, the greater the upward offset.

[0117] Step S914: Determine the target cloud / fog corresponding to the time point based on the target vertex offset corresponding to each vertex.

[0118] This step S914 can be specifically achieved through the following steps ten through fourteen:

[0119] Step 10: For each time point, determine the initial cloud and fog corresponding to that time point based on the target vertex offset of each vertex at that time point.

[0120] The initial cloud and fog mentioned above can be understood as cloud and fog that already has a cloud and fog shape, but has not yet had its material effects set. The color and transparency can be set in the fragment shader to simulate the effect. The fragment shader usually refers to a set of code instructions that can be used to perform a series of shading calculations such as lighting calculations.

[0121] Step 11: Control the target vertex offset of each vertex at the time point within the preset first range using a preset first function, and obtain the third vertex offset of each vertex.

[0122] Step 12: Determine the transparency coefficient based on the third vertex offset of each vertex; where the larger the third vertex offset, the higher the transparency coefficient.

[0123] Step 13: Adjust the transparency of the initial cloud based on the transparency coefficient of each vertex to obtain an initial cloud with gradient colors.

[0124] The first function mentioned above can be the `saturate` function. The `saturate(x)` function sets x values ​​greater than 1 to 1 and x values ​​less than 0 to 0. In actual implementation, the fragment shader can obtain the target vertex offset of each vertex in the vertex shader at each time point and use the `saturate` function to squeeze the target offset to the range [0, 1] as the `ColorMask`. Because a larger target vertex offset indicates a more convex position, and a smaller target vertex offset indicates a more concave position, this is used to draw the gradient color of the initial cloud from the top to the concave. Generally, the larger the target vertex offset, the lighter the color, i.e., the higher the opacity coefficient; the smaller the offset, the darker the color, i.e., the lower the opacity coefficient. The code implementation can be as follows:

[0125] float colormask=saturate(IN.noisePos.z);

[0126] float4 col=(_TopColor*colormask)+(_BottomColor*(1-colormask));

[0127] Here, `colormask` represents the value obtained after normalizing `IN.noisePos.z` (i.e., the `saturate(x)` function, which sets x values ​​greater than 1 to 1 and x values ​​less than 0 to 0); `IN.noisePos.z` represents the target vertex offset; `col` represents the final output color, currently `col` represents the gradient color of the initial cloud from the top to the bottom; `_TopColor` represents the top color; and `_BottomColor` represents the bottom color.

[0128] Step fourteen: Apply light coloring to the initial cloud and fog with gradient colors to obtain the target cloud and fog corresponding to that time point.

[0129] Step fourteen may specifically include the following steps A through E:

[0130] Step A: Apply light to the initial cloud and fog with gradient colors to obtain the colored initial cloud and fog.

[0131] The Fresnel effect can be used to create the effect of distant clouds being colored by sunlight. This effect, also known as Fresnel reflection, makes ordinary reflections appear rather coarse, while the Fresnel effect adds texture to object surfaces and creates an edge-lit effect. Figure 11The image shows a schematic diagram of a cloud / fog effect. This can be achieved using the following code. As you can understand, the result increases with the angle between the normal and the view direction, creating a gradient material. The `pow` function is then used to control the scaling of the gradient.

[0132]

[0133] Here, Half3 represents a 3D floating-point vector; N represents the normal; normalize means restricting the value of each floating-point of a multidimensional vector to between 0 and 1, with a value of 1 for values ​​greater than 1 and 0 for values ​​less than 0; IN.normalWS means obtaining the normal of the model; V represents the view direction; IN.viewDirWS means obtaining the view direction; NdotV means performing a dot product operation (dot product is dot) on the normal and the view direction, and then performing a normalization saturate operation to obtain an initial Fresnel effect calculation result; fresnel means the Fresnel effect calculation result, i.e., the edge lighting effect mentioned above, which is obtained by performing an exponential operation on NdotV (pow function), the pow function controls the amplification and scaling of the NdotV value, i.e., the gradient mentioned above; _FresnelColor means the color assigned to the fresnel edge lighting; col+ means adding the gradient color from the top to the bottom of the initial cloud to the edge lighting with the edge lighting, resulting in a gradient color from the top to the bottom with edge lighting.

[0134] Step B involves sampling the preset depth texture image to obtain the sampled depth value, and then converting the sampled depth value into depth information in the view space.

[0135] Step C: For each vertex, compare the depth information in the view space at that vertex with the depth information corresponding to that vertex to obtain a difference result; wherein, the difference result is used to indicate the degree of intersection between the virtual object corresponding to the specified depth information in the depth texture image and the initial cloud after shading.

[0136] Step D: Determine the transparency at the intersection of the virtual object and the initial cloud after coloring based on the difference result, and obtain the adjusted initial cloud.

[0137] In practical implementation, SampleSceneDepth can be used to sample the depth texture of a preset depth texture image. This depth texture is usually a rendering texture that stores high-precision sampled depth values. Then, LinearEyeDepth is used to convert the sampled depth values ​​into depth information in the view space buffer. This view space is usually the space centered on the camera and pointing towards the camera's shooting direction. For each vertex, the depth information in the view space at each vertex can be compared with the depth information screenPos.w corresponding to the current vertex. The smaller the difference between the two, the more the virtual object written to the depth texture image intersects with the cloud patch. Furthermore, the smaller the difference, the greater the overlap between the virtual object and the cloud patch; conversely, the greater the difference, the less the overlap. This difference can be used as the transparency of the cloud patch, i.e., the initial cloud after shading, to achieve the effect of transparency at the intersection of the virtual object and the initial cloud. Figure 12 The image shown is a schematic diagram of a cloud / fog effect; the range of transparency can be controlled by a custom function, DepthBiasFactor.

[0138] float depth=LinearEyeDepth(SampleSceneDepth(IN.screenPos.×y / IN.screenPos.w), _zBufferParams);

[0139] float wuDepth=IN.screenpos.w;

[0140] float borderLine=saturate((depth-wuDepth) / _DepthBiasFactor);

[0141] Here, `depth` represents the depth information in view space at the vertex; `LinearEyeDepth()` is used to convert the sampling result of the depth texture to depth information in view space; `SampleSceneDepth` is used to sample the depth texture from the depth texture image; `IN.screenPos.xy` represents the screen space position coordinates, and the operation ` / IN.screenPos.w` divides the value of `IN.screenPos.xy` by the information corresponding to the vertex; `ZBufferParams` represents the preset depth texture image; and the value of `wuDepth` is the same as the value of `IN.screenPos.w`. This represents the depth information corresponding to the vertex; borderLine indicates that the depth information in the view space at each vertex is compared with the current vertex's depth information screenPos.w. The smaller the difference between the two, the more the virtual object with the depth texture image intersects with the cloud patch. Furthermore, the smaller the difference, the greater the overlap between the virtual object and the cloud patch, and vice versa. This difference can be used as the transparency of the cloud patch, i.e., the initial cloud after the above coloring, to achieve the effect of transparency at the intersection of the virtual object and the initial cloud patch; _DepthBiasFactor indicates the range of transparency.

[0142] Step E: Adjust the transparency of the initial cloud and fog using a preset mask to obtain the target cloud and fog corresponding to that time point.

[0143] There can be multiple preset masks; for example, if there are two preset masks, the Alpha transparency value of the adjusted initial cloud can be further adjusted to control the edge shape of the cloud and the dissipation and condensation within the cloud, so as to obtain the target cloud corresponding to each time point.

[0144]

[0145] Here, `col.a` represents the fourth floating-point number of the final output color, `col`, used to represent the transparency of the volumetric cloud; `NdotV` represents the calculated value mentioned above, indicating that the normal and the view direction are multiplied by a dot (dot product), and then normalized by `saturate` to obtain an initial Fresnel effect calculation result. This initial Fresnel result uses `_OpacityScale` to control the intensity, thus affecting the transparency of the volumetric cloud; `maskAlpha` and `maskborderAlpha` represent the two preset masks mentioned above. These two values ​​are obtained by sampling the initial texture coordinates `IN.uv` from the two 2D texture maps `_Mask` and `_maskborder`. The function for sampling the texture map is `SAMPLE_TEXTURE2D`; `r` represents the first floating-point value of the sampled texture map value; `sampler_Mask` and `sampler_Maskborder` represent the texture setting parameters of the two 2D texture maps `_Mask` and `_maskborder`. Each texture automatically imported into Unity has its own texture setting parameters; `_MaskControl` and `MaskborderControl` represent the intensity of the two preset masks, respectively.

[0146] Step S916: Import the target clouds and fog corresponding to each time point into the preset game scene so as to display the target clouds and fog in the game scene.

[0147] See Figure 13 The diagram shows a real hot spring surface cloud and fog effect. To achieve the cloud and fog effect in a game scene, the target cloud and fog corresponding to each of the above time points can be imported into a preset game scene.

[0148] The aforementioned cloud generation method adjusts the first vertex offset of each vertex at each time point to obtain the target vertex offset for each vertex. Based on the target vertex offset, the target cloud at that time point is determined. The target cloud at each time point is then imported into a preset game scene for display. This method allows for setting gradient colors and lighting shading for the cloud, and also addresses the transparency issues at the intersection of virtual objects and the cloud, achieving a more realistic display effect.

[0149] Furthermore, this method addresses the challenge of balancing performance overhead, effect quality, and perspective variation in related technologies. It utilizes simple planar models and 2D noise maps to meet the requirements for surface volumetric cloud effects, allowing for greater perspective movement and flexible cloud deformation. In addition, this method significantly reduces the time, difficulty, and performance consumption required to create flat clouds. Obtaining dynamic and flexibly shaped planar clouds using simple planar models and 2D noise maps requires only 0.1 person-days or less, improving efficiency by over 200%. This significantly enhances the efficiency of generating clouds in game scenes. A person-day is a unit of measurement for workload; one person-day equals eight hours of work.

[0150] This disclosure provides a cloud and fog generation device, such as... Figure 14 As shown, the device includes:

[0151] The first acquisition module 140 is used to acquire a preset planar model and a 2D noise map; wherein, the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1;

[0152] The second acquisition module 141 is used to acquire the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system;

[0153] The first determining module 142 is used to sample the 2D noise map according to the texture coordinates of each vertex to obtain the first gray value corresponding to each vertex, and to determine the first gray value corresponding to each vertex as the initial vertex offset corresponding to each vertex.

[0154] The fourth acquisition module 143 is used to acquire the offset factor of each vertex of the planar model as it changes over time; wherein the offset factor is a variable based on a preset cloud and fog movement speed parameter.

[0155] The second determining module 144 is used to determine the first vertex offset of each vertex over time based on the initial vertex offset and the offset factor;

[0156] The third determining module 145 is used to render and generate the target cloud and fog corresponding to the planar model based on the first vertex offset.

[0157] The aforementioned cloud and fog generation device first acquires a preset planar model, a 2D noise map, and the texture coordinates of each vertex of the planar model in its corresponding texture coordinate system. Based on the texture coordinates of each vertex, the 2D noise map is sampled to obtain the first grayscale value corresponding to each vertex, and this first grayscale value is determined as the initial vertex offset for each vertex. The device then acquires the time-varying offset factor for each vertex of the planar model. Based on the initial vertex offset and the offset factor, the time-varying first vertex offset for each vertex is determined. Finally, the device renders and generates the target cloud and fog corresponding to the planar model based on the first vertex offset. This device can determine the initial vertex offset for each vertex in the planar model by sampling the 2D noise map, and then determine the first vertex offset by combining it with the time-varying offset factor. Since the first vertex offset for each vertex changes over time, a more dynamic and flexible target cloud and fog can be obtained based on the first vertex offset to match flexible cloud and fog generation requirements.

[0158] In an optional implementation, the second determining module 144 is further configured to: for each vertex at each time point, calculate the sum of the initial vertex offset corresponding to the vertex and the offset factor corresponding to the time point to obtain an offset sum result; average the offset sum result to obtain an average value, and use the average value as the first average offset of the vertex at the time point; control the first average offset within a preset first range by a preset first function to obtain the second average offset of the vertex at the time point; and determine the first vertex offset that changes with time based on each second average offset of the vertex at each time point.

[0159] In an optional implementation, the second determining module 144 is further configured to: adjust each of the second average offsets by using a preset second function and a preset exponent to obtain the adjusted third average offset corresponding to the vertex at each time point; map the third average offset from the first range to the second range, and take the absolute value of the mapping result to obtain the fourth average offset corresponding to the vertex at each time point; control the fourth average offset within the first range by using a preset third function to obtain the first vertex offset that changes with time.

[0160] In an optional embodiment, the device is further configured to: scale the 2D noise map according to a preset scaling factor in response to a scaling command for the 2D noise map; sample the scaled 2D noise map according to the texture coordinates of each vertex to obtain a second grayscale value corresponding to each vertex; multiply the second grayscale value corresponding to each vertex by the scaling factor to obtain a second vertex offset of each vertex; wherein the second vertex offset of each vertex corresponds to the offset of the scaled fog; wherein the scaled fog is generated based on the second vertex offset; for each time point, calculate the target fusion offset of each vertex corresponding to the time point based on the first vertex offset, each second vertex offset, and the scaling factor; determine the fused fog corresponding to the time point based on the target fusion offset of each vertex corresponding to the time point; wherein the fused fog is a fusion of the scaled fog and the target fog corresponding to the time point.

[0161] In an optional implementation, the device is further configured to: for each vertex at each time point, calculate the sum of the second vertex offset and the first vertex offset corresponding to the vertex to obtain a first summing result; calculate the sum of the scaling factor and a preset fixed value to obtain a second summing result; divide the first summing result by the second summing result to obtain a first calculation result; and control the first calculation result within a preset first range through a preset first function to obtain the target fusion offset corresponding to the vertex.

[0162] In an optional implementation, the third determining module 145 is further configured to: for each time point, adjust the first vertex offset of each vertex corresponding to that time point to obtain the target vertex offset corresponding to each vertex; wherein, the vertex farther away from the center of the planar model has a larger upward target vertex offset; and determine the target cloud / fog corresponding to that time point based on the target vertex offset corresponding to each vertex.

[0163] In an optional implementation, the third determining module 145 is further configured to: for each time point, determine the initial cloud / fog corresponding to that time point based on the target vertex offset of each vertex corresponding to that time point; control the target vertex offset of each vertex corresponding to that time point within a preset first range using a preset first function to obtain the third vertex offset of each vertex; determine a transparency coefficient based on the third vertex offset of each vertex; wherein, the larger the third vertex offset, the higher the transparency coefficient; adjust the transparency of the initial cloud / fog based on the transparency coefficient of each vertex to obtain an initial cloud / fog with a gradient color; and perform illumination shading on the initial cloud / fog with the gradient color to obtain the target cloud / fog corresponding to that time point.

[0164] In an optional implementation, the third determining module 145 is further configured to: perform illumination coloring on the initial cloud with gradient colors to obtain colored initial cloud; sample a preset depth texture image to obtain a sampled depth value, and convert the sampled depth value into depth information in the view space; for each vertex, compare the depth information in the view space at that vertex with the depth information corresponding to that vertex to obtain a difference result; wherein the difference result is used to indicate the degree of intersection between the virtual object corresponding to the specified depth information in the depth texture image and the colored initial cloud; determine the transparency at the intersection of the virtual object and the colored initial cloud based on the difference result to obtain the adjusted initial cloud; and adjust the transparency of the adjusted initial cloud using a preset mask to obtain the target cloud corresponding to that time point.

[0165] The cloud and fog generation device provided in this embodiment of the invention has the same implementation principle and technical effect as the aforementioned cloud and fog generation method embodiment. For the sake of brevity, any parts not mentioned in the cloud and fog generation device embodiment can be referred to the corresponding content in the aforementioned cloud and fog generation method embodiment.

[0166] This disclosure also provides an electronic device, see [link to relevant documentation] Figure 15 As shown, the electronic device includes a processor 160 and a memory 161. The memory 161 stores machine-executable instructions that can be executed by the processor 160. The processor 160 executes the machine-executable instructions to implement the above-described cloud generation method.

[0167] Furthermore, Figure 15 The electronic device shown also includes a bus 162 and a communication interface 163, with the processor 160, the communication interface 163 and the memory 161 connected via the bus 162.

[0168] The memory 161 may include high-speed random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 163 (which can be wired or wireless), such as the Internet, wide area network, local area network, or metropolitan area network. The bus 162 may be an ISA bus, PCI bus, or EISA bus, etc. The bus can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 15 The symbol is represented by a single double-headed arrow, but this does not mean that there is only one bus or one type of bus.

[0169] Processor 160 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of processor 160 or by instructions in software form. Processor 160 can be a general-purpose processor, including a Central Processing Unit (CPU), a Network Processor (NP), etc.; it can also be a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field-Programmable Gate Array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this disclosure. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this disclosure can be directly manifested as execution by a hardware decoding processor, or execution by a combination of hardware and software modules in the decoding processor. The software module can reside in a mature storage medium in the art, such as random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, or registers. This storage medium is located in memory 161. The processor 160 reads the information in memory 161 and, in conjunction with its hardware, completes the steps of the method described in the foregoing embodiment, specifically executing the following steps:

[0170] Obtain a preset planar model and a 2D noise map; the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1; obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system; sample the 2D noise map according to the texture coordinates of each vertex to obtain the first grayscale value corresponding to each vertex, and determine the first grayscale value corresponding to each vertex as the initial vertex offset; obtain the offset factor of each vertex of the planar model as it changes over time; the offset factor is a variable based on preset cloud and fog movement speed parameters; determine the first vertex offset of each vertex as it changes over time based on the initial vertex offset and the offset factor; render and generate the target cloud and fog corresponding to the planar model based on the first vertex offset.

[0171] The specific implementation methods and working processes can be referred to the corresponding processes in the above method embodiments, and will not be repeated here.

[0172] In an optional implementation, when the processor executes the process of determining the first vertex offset of each vertex over time based on the initial vertex offset and the offset factor, it specifically performs the following steps: for each vertex at each time point, calculates the sum of the initial vertex offset corresponding to the vertex and the offset factor corresponding to the time point to obtain the offset sum result; averages the offset sum result to obtain the average value, and uses the average value as the first average offset of the vertex at that time point; controls the first average offset within a preset first range through a preset first function to obtain the second average offset of the vertex at that time point; and determines the first vertex offset of the vertex over time based on each second average offset of the vertex at each time point.

[0173] In an optional implementation, when the processor determines the first vertex offset that changes over time based on each second average offset corresponding to the vertex at each time point, it specifically performs the following steps: adjusting each second average offset using a preset second function and a preset power exponent to obtain an adjusted third average offset corresponding to the vertex at each time point; mapping the third average offset from a first range to a second range and taking the absolute value of the mapping result to obtain a fourth average offset corresponding to the vertex at each time point; and controlling the fourth average offset within a first range using a preset third function to obtain the first vertex offset that changes over time.

[0174] In an optional implementation, the processor further executes a scaling instruction for the 2D noise map in response to a preset scaling factor; samples the scaled 2D noise map according to the texture coordinates of each vertex to obtain a second grayscale value corresponding to each vertex; multiplies the second grayscale value corresponding to each vertex by the scaling factor to obtain a second vertex offset for each vertex; wherein the second vertex offset for each vertex corresponds to the offset of the scaled fog; wherein the scaled fog is rendered and generated based on the second vertex offset; for each time point, the target fusion offset for each vertex at that time point is calculated based on the first vertex offset, the second vertex offset, and the scaling factor; the fused fog at that time point is determined based on the target fusion offset for each vertex at that time point; wherein the fused fog is a fusion of the scaled fog and the target fog at that time point.

[0175] In an optional implementation, when the processor calculates the target fusion offset of each vertex at each time point based on the first vertex offset, each second vertex offset, and the scaling factor for each vertex at that time point, the processor specifically performs the following steps: for each vertex at each time point, calculates the sum of the second vertex offset and the first vertex offset corresponding to that vertex to obtain a first summing result; calculates the sum of the scaling factor and a preset fixed value to obtain a second summing result; divides the first summing result by the second summing result to obtain a first calculation result; and controls the first calculation result within a preset first range using a preset first function to obtain the target fusion offset corresponding to that vertex.

[0176] In an optional implementation, when the processor executes the rendering of the target cloud and fog corresponding to the planar model based on the first vertex offset, it specifically performs the following: for each time point, adjusts the first vertex offset of each vertex corresponding to that time point to obtain the target vertex offset corresponding to each vertex; wherein, the vertex farther away from the center of the planar model has a larger upward target vertex offset; and determines the target cloud and fog corresponding to that time point based on the target vertex offset corresponding to each vertex.

[0177] In an optional implementation, when the processor determines the target cloud / fog corresponding to a given time point based on the target vertex offset corresponding to each vertex, it specifically performs the following steps: for each time point, based on the target vertex offset of each vertex corresponding to that time point, determines the initial cloud / fog corresponding to that time point; controls the target vertex offset of each vertex corresponding to that time point within a preset first range using a preset first function to obtain the third vertex offset of each vertex; determines a transparency coefficient based on the third vertex offset of each vertex; wherein, the larger the third vertex offset, the higher the transparency coefficient; adjusts the transparency of the initial cloud / fog based on the transparency coefficient of each vertex to obtain an initial cloud / fog with a gradient color; and applies lighting shading to the initial cloud / fog with the gradient color to obtain the target cloud / fog corresponding to that time point.

[0178] In an optional implementation, when the processor performs illumination shading on the initial cloud with gradient colors to obtain the target cloud at that time point, it specifically performs the following: illumination shading on the initial cloud with gradient colors to obtain the shading initial cloud; sampling a preset depth texture image to obtain a sampled depth value, and converting the sampled depth value into depth information in the view space; for each vertex, comparing the depth information in the view space at that vertex with the depth information corresponding to that vertex to obtain a difference result; wherein, the difference result is used to indicate the degree of intersection between the virtual object corresponding to the specified depth information in the depth texture image and the shading initial cloud; determining the transparency at the intersection of the virtual object and the shading initial cloud based on the difference result to obtain the adjusted initial cloud; and adjusting the transparency of the adjusted initial cloud using a preset mask to obtain the target cloud at that time point.

[0179] The above method first obtains a preset planar model, a 2D noise map, and the texture coordinates of each vertex of the planar model in its corresponding texture coordinate system. Based on the texture coordinates of each vertex, the 2D noise map is sampled to obtain the first grayscale value corresponding to each vertex, and this first grayscale value is determined as the initial vertex offset for each vertex. The offset factor of each vertex in the planar model over time is obtained. Based on the initial vertex offset and the offset factor, the first vertex offset of each vertex over time is determined. The target fog corresponding to the planar model is then rendered based on the first vertex offset. This method, by sampling the 2D noise map, can determine the initial vertex offset of each vertex in the planar model, and then combine this with the offset factor over time to determine the first vertex offset. Since the first vertex offset of each vertex changes over time, a more dynamic and flexible target fog can be obtained based on the first vertex offset to match flexible fog generation requirements.

[0180] This disclosure also provides a machine-readable storage medium storing machine-executable instructions that, when invoked and executed by a processor, cause the processor to perform the following steps:

[0181] Obtain a preset planar model and a 2D noise map; the planar model has multiple preset vertices; the 2D noise map is a grayscale image of each pixel with a grayscale value in the range of 0-1; obtain the texture coordinates of each vertex of the planar model in the corresponding texture coordinate system; sample the 2D noise map according to the texture coordinates of each vertex to obtain the first grayscale value corresponding to each vertex, and determine the first grayscale value corresponding to each vertex as the initial vertex offset; obtain the offset factor of each vertex of the planar model as it changes over time; the offset factor is a variable based on preset cloud and fog movement speed parameters; determine the first vertex offset of each vertex as it changes over time based on the initial vertex offset and the offset factor; render and generate the target cloud and fog corresponding to the planar model based on the first vertex offset.

[0182] The specific implementation methods and working processes can be referred to the corresponding processes in the above method embodiments, and will not be repeated here.

[0183] In an optional implementation, when the processor executes the process of determining the first vertex offset of each vertex over time based on the initial vertex offset and the offset factor, it specifically performs the following steps: for each vertex at each time point, calculates the sum of the initial vertex offset corresponding to the vertex and the offset factor corresponding to the time point to obtain the offset sum result; averages the offset sum result to obtain the average value, and uses the average value as the first average offset of the vertex at that time point; controls the first average offset within a preset first range through a preset first function to obtain the second average offset of the vertex at that time point; and determines the first vertex offset of the vertex over time based on each second average offset of the vertex at each time point.

[0184] In an optional implementation, when the processor determines the first vertex offset that changes over time based on each second average offset corresponding to the vertex at each time point, it specifically performs the following steps: adjusting each second average offset using a preset second function and a preset power exponent to obtain an adjusted third average offset corresponding to the vertex at each time point; mapping the third average offset from a first range to a second range and taking the absolute value of the mapping result to obtain a fourth average offset corresponding to the vertex at each time point; and controlling the fourth average offset within a first range using a preset third function to obtain the first vertex offset that changes over time.

[0185] In an optional implementation, the processor further executes a scaling instruction for the 2D noise map in response to a preset scaling factor; samples the scaled 2D noise map according to the texture coordinates of each vertex to obtain a second grayscale value corresponding to each vertex; multiplies the second grayscale value corresponding to each vertex by the scaling factor to obtain a second vertex offset for each vertex; wherein the second vertex offset for each vertex corresponds to the offset of the scaled fog; wherein the scaled fog is rendered and generated based on the second vertex offset; for each time point, the target fusion offset for each vertex at that time point is calculated based on the first vertex offset, the second vertex offset, and the scaling factor; the fused fog at that time point is determined based on the target fusion offset for each vertex at that time point; wherein the fused fog is a fusion of the scaled fog and the target fog at that time point.

[0186] In an optional implementation, when the processor calculates the target fusion offset of each vertex at each time point based on the first vertex offset, each second vertex offset, and the scaling factor for each vertex at that time point, the processor specifically performs the following steps: for each vertex at each time point, calculates the sum of the second vertex offset and the first vertex offset corresponding to that vertex to obtain a first summing result; calculates the sum of the scaling factor and a preset fixed value to obtain a second summing result; divides the first summing result by the second summing result to obtain a first calculation result; and controls the first calculation result within a preset first range using a preset first function to obtain the target fusion offset corresponding to that vertex.

[0187] In an optional implementation, when the processor executes the rendering of the target cloud and fog corresponding to the planar model based on the first vertex offset, it specifically performs the following: for each time point, adjusts the first vertex offset of each vertex corresponding to that time point to obtain the target vertex offset corresponding to each vertex; wherein, the vertex farther away from the center of the planar model has a larger upward target vertex offset; and determines the target cloud and fog corresponding to that time point based on the target vertex offset corresponding to each vertex.

[0188] In an optional implementation, when the processor determines the target cloud / fog corresponding to a given time point based on the target vertex offset corresponding to each vertex, it specifically performs the following steps: for each time point, based on the target vertex offset of each vertex corresponding to that time point, determines the initial cloud / fog corresponding to that time point; controls the target vertex offset of each vertex corresponding to that time point within a preset first range using a preset first function to obtain the third vertex offset of each vertex; determines a transparency coefficient based on the third vertex offset of each vertex; wherein, the larger the third vertex offset, the higher the transparency coefficient; adjusts the transparency of the initial cloud / fog based on the transparency coefficient of each vertex to obtain an initial cloud / fog with a gradient color; and applies lighting shading to the initial cloud / fog with the gradient color to obtain the target cloud / fog corresponding to that time point.

[0189] In an optional implementation, when the processor performs illumination shading on the initial cloud with gradient colors to obtain the target cloud at that time point, it specifically performs the following: illumination shading on the initial cloud with gradient colors to obtain the shading initial cloud; sampling a preset depth texture image to obtain a sampled depth value, and converting the sampled depth value into depth information in the view space; for each vertex, comparing the depth information in the view space at that vertex with the depth information corresponding to that vertex to obtain a difference result; wherein, the difference result is used to indicate the degree of intersection between the virtual object corresponding to the specified depth information in the depth texture image and the shading initial cloud; determining the transparency at the intersection of the virtual object and the shading initial cloud based on the difference result to obtain the adjusted initial cloud; and adjusting the transparency of the adjusted initial cloud using a preset mask to obtain the target cloud at that time point.

[0190] The above method first obtains a preset planar model, a 2D noise map, and the texture coordinates of each vertex of the planar model in its corresponding texture coordinate system. Based on the texture coordinates of each vertex, the 2D noise map is sampled to obtain the first grayscale value corresponding to each vertex, and this first grayscale value is determined as the initial vertex offset for each vertex. The offset factor of each vertex in the planar model over time is obtained. Based on the initial vertex offset and the offset factor, the first vertex offset of each vertex over time is determined. The target fog corresponding to the planar model is then rendered based on the first vertex offset. This method, by sampling the 2D noise map, can determine the initial vertex offset of each vertex in the planar model, and then combine this with the offset factor over time to determine the first vertex offset. Since the first vertex offset of each vertex changes over time, a more dynamic and flexible target fog can be obtained based on the first vertex offset to match flexible fog generation requirements.

[0191] The computer program products of the cloud and fog generation method, apparatus and electronic device provided in this disclosure include a computer-readable storage medium storing program code. The instructions included in the program code can be used to execute the methods described in the preceding method embodiments. For specific implementation, please refer to the method embodiments, which will not be repeated here.

[0192] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this disclosure, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this disclosure. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0193] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method of generating a cloud, characterized by, The method comprises: acquiring a preset plane model and a 2D noise map; wherein a plurality of vertices are preset in the plane model; the 2D noise map is a gray image with a gray value of each pixel point in the range of 0-1; acquiring a texture coordinate of each vertex of the plane model in a corresponding texture coordinate system; sampling the 2D noise map according to the texture coordinate of each vertex to obtain a first gray value corresponding to each vertex, and determining the first gray value corresponding to each vertex as an initial vertex offset corresponding to each vertex; acquiring an offset factor of each vertex of the plane model changing over time; wherein the offset factor is a variable based on a preset cloud and fog movement speed parameter; for each vertex at each time point, calculating a sum of the initial vertex offset corresponding to the vertex and the offset factor corresponding to the time point to obtain an offset sum result; averaging the offset sum result to obtain an average value, and taking the average value as a first average offset corresponding to the vertex at the time point; controlling the first average offset in a preset first range by a preset first function to obtain a second average offset corresponding to the vertex at the time point; determining a first vertex offset of the vertex changing over time based on each second average offset corresponding to the vertex at each time point; rendering and generating a target cloud and fog corresponding to the plane model based on the first vertex offset.

2. The method of claim 1, wherein, The step of determining the first vertex offset of the vertex changing over time based on each second average offset corresponding to the vertex at each time point comprises: adjusting each second average offset by a preset second function and a preset power index to obtain an adjusted third average offset corresponding to the vertex at each time point; mapping the third average offset from the first range to a second range, and taking an absolute value of the mapping result to obtain a fourth average offset corresponding to the vertex at each time point; controlling the fourth average offset in the first range by a preset third function to obtain the first vertex offset of the vertex changing over time.

3. The method of claim 1, wherein, The method further comprises: in response to a scaling instruction for the 2D noise map, scaling the 2D noise map by a preset scaling coefficient; sampling the scaled 2D noise map according to the texture coordinate of each vertex to obtain a second gray value corresponding to each vertex; multiplying the second gray value corresponding to each vertex by the scaling coefficient to obtain a second vertex offset of each vertex; wherein the second vertex offset of each vertex corresponds to an offset of a scaled cloud and fog; wherein the scaled cloud and fog is rendered and generated based on the second vertex offset; for each time point, calculating a target fusion offset of each vertex at the time point based on the first vertex offset of each vertex at the time point, each second vertex offset, and the scaling coefficient; determining a fusion cloud and fog corresponding to the time point based on the target fusion offset of each vertex at the time point; wherein the fusion cloud and fog is a fusion of the scaled cloud and fog and the target cloud and fog corresponding to the time point.

4. The method of claim 3, wherein, The step of calculating, for each vertex of each time point, a target fusion offset of the vertex corresponding to the time point based on the first vertex offset, the second vertex offset and the scaling factor of the vertex corresponding to the time point comprises: For each vertex of each time point, a second vertex offset and a first vertex offset corresponding to the vertex are calculated to obtain a first sum result; A second sum result is calculated by summing the scaling factor and a preset fixed value; The first sum result is divided by the second sum result to obtain a first calculation result; The first calculation result is controlled within a preset first range by a preset first function to obtain a target fusion offset corresponding to the vertex.

5. The method of claim 1, wherein, The step of rendering the target cloud and mist corresponding to the plane model based on the first vertex offset comprises: For each time point, the first vertex offset of each vertex corresponding to the time point is adjusted to obtain a target vertex offset corresponding to each vertex; wherein the farther the vertex is from the center of the plane model, the greater the target vertex offset of the vertex upward is; A target cloud and mist corresponding to the time point is determined based on the target vertex offset of each vertex.

6. The method of claim 5, wherein, The step of determining a target cloud and mist corresponding to the time point based on the target vertex offset of each vertex corresponding to the time point comprises: For each time point, an initial cloud and mist corresponding to the time point is determined based on the target vertex offset of each vertex corresponding to the time point; A third vertex offset of each vertex is obtained by controlling the target vertex offset of each vertex corresponding to the time point within a preset first range by a preset first function; A transparency coefficient of each vertex is determined based on the third vertex offset of the vertex; wherein the greater the third vertex offset is, the higher the transparency coefficient is; The transparency of the initial cloud and mist is adjusted based on the transparency coefficient of each vertex to obtain an initial cloud and mist with a gradient color; The initial cloud and mist with a gradient color is subjected to light shading to obtain a target cloud and mist corresponding to the time point.

7. The method of claim 6, wherein, The step of shading the initial cloud and mist with a gradient color to obtain a target cloud and mist corresponding to the time point comprises: The initial cloud and mist with a gradient color is subjected to light shading to obtain a shaded initial cloud and mist; A preset depth texture image is sampled to obtain a sampling depth value, and the sampling depth value is converted into depth information in a perspective space; For each vertex, the depth information in the perspective space at the vertex is compared with the depth information corresponding to the vertex to obtain a difference result; wherein the difference result is used to indicate the intersection degree of a virtual object corresponding to specified depth information in the depth texture image and the shaded initial cloud and mist; The transparency of the intersection of the virtual object and the shaded initial cloud and mist is determined based on the difference result to obtain an adjusted initial cloud and mist; The transparency of the adjusted initial cloud and mist is adjusted by a preset mask to obtain a target cloud and mist corresponding to the time point.

8. A cloud generating apparatus, characterized by comprising: The device comprises: The first obtaining module is configured to obtain a preset plane model and a 2D noise map; wherein the plane model is preset with a plurality of vertices; and the 2D noise map is a gray scale image with a gray scale value of each pixel point in a range of 0-1. The second obtaining module is configured to obtain a texture coordinate of each vertex of the plane model in a corresponding texture coordinate system. The first determining module is configured to sample the 2D noise map according to the texture coordinate of each vertex to obtain a first gray scale value corresponding to each vertex, and determine the first gray scale value corresponding to each vertex as an initial vertex offset corresponding to each vertex. The fourth obtaining module is configured to obtain an offset factor of each vertex of the plane model corresponding to a change over time; wherein the offset factor is a variable based on a preset cloud and fog movement speed parameter. The second determining module is configured to, for each vertex at each time point, calculate a sum of the initial vertex offset corresponding to the vertex and the offset factor corresponding to the time point to obtain a sum result of offsets, average the sum result of offsets to obtain an average value, take the average value as a first average offset corresponding to the vertex at the time point, control the first average offset in a preset first range through a preset first function to obtain a second average offset corresponding to the vertex at the time point, and determine a first vertex offset of the vertex corresponding to a change over time based on each second average offset corresponding to each time point of the vertex. The third determining module is configured to render and generate a target cloud and fog corresponding to the plane model based on the first vertex offset.

9. An electronic device, comprising: The processor and the memory are included, the memory stores machine executable instructions capable of being executed by the processor, and the processor executes the machine executable instructions to implement the cloud and fog generation method in any one of claims 1-7.

10. A machine-readable storage medium, characterized in that, The machine readable storage medium stores machine executable instructions, and when the machine executable instructions are called and executed by the processor, the machine executable instructions cause the processor to implement the cloud and fog generation method in any one of claims 1-7.

Images