High-resolution map rendering method and device, computer equipment and storage medium

Abstract

The invention relates to a high-resolution map rendering method and device, computer equipment and a storage medium, and the high-resolution map rendering method comprises the following steps: obtaining a target file, and determining a renderer in Houdini based on the target file; constructing a resolver based on the USD standard; judging whether formatted files exist in the catalog of the target file or not based on the parser; if the formatted file does not exist, the analyzer judges whether the current first environment of the directory is true or not; if the current first environment is true, converting an original file in a directory where the target file is located into a formatted file based on the mipmap; performing variable configuration on the first environment based on the format file to obtain a second environment; the parser reads the formatted file based on the second environment, and meanwhile the renderer performs texture rendering on the target file. According to the method, through automatic conversion of Mipmap, dynamic path configuration and scene analysis based on USD, the production period of the visual file is shortened.

Description

Technical Field

[0001] The present invention relates to the technical field of image rendering, and particularly to a large-resolution texture map rendering method, device, computer device, and storage medium. Background Art

[0002] Rendering large-resolution texture maps is one of the important means to enhance visual effects. However, with the increase in the resolution of texture maps, the demand for memory and processing power during the rendering process also increases significantly. To optimize the rendering performance, Mipmap (Multilevel Image Pyramid or Multiresolution Texture) is widely used in texture rendering. It is a multilevel texture technology that pre-generates a series of textures with different resolutions, enabling the selection of an appropriate texture resolution based on the distance between the object and the camera during rendering, thereby reducing unnecessary calculations and memory occupancy. In production software, the renderer does not have the function of automatically converting the original texture file into the fragmented texture format processed by the Mipmap technology. When users perform large-resolution texture map rendering, they need to manually convert all texture files into the Mipmap format and change the texture paths in the scene one by one. However, the process of manual conversion and path change is time-consuming and increases the production cycle of visual files. Summary of the Invention

[0003] The purpose of the present invention is to overcome the deficiencies of the prior art and provide a large-resolution texture map rendering method, device, computer device, and storage medium.

[0004] To solve the above technical problems, the present invention adopts the following technical solutions:

[0005] The present invention is achieved through the following technical solutions:

[0006] In the first aspect, this embodiment provides a large-resolution texture map rendering method, including the following steps:

[0007] Obtain a target file, and determine a renderer in Houdini based on the target file;

[0008] Construct a parser based on the USD standard;

[0009] Based on the parser, determine whether there is a format file in the directory of the target file;

[0010] If the format file does not exist, the parser determines whether the current first environment of the directory is true;

[0011] If the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap;

[0012] Configure variables for the first environment based on the format file to obtain a second environment;

[0013] The parser reads the format file based on the second environment, and at the same time, the renderer performs texture rendering on the target file.

[0014] Further, after determining whether there is a format file in the directory of the target file based on the parser, the following steps are further included:

[0015] If there is the format file, the parser reads the format file, and at the same time, the renderer performs texture rendering on the target file.

[0016] Further, determining whether there is a format file in the directory of the target file based on the parser includes the following steps:

[0017] Read the configuration information of the target file;

[0018] The parser determines whether there is a format file in the directory of the target file based on the configuration information.

[0019] Further, determining whether there is a format file in the directory of the target file based on the parser includes the following steps:

[0020] The parser determines whether there is a target file with a preset suffix in the directory of the target file;

[0021] If there is, determine the target file as the format file.

[0022] Further, the parser determining whether the current first environment in the directory is true includes the following steps:

[0023] Based on a preset rule, the parser searches for a specific file storing the first environment in the directory and generates a text type value based on the specific file;

[0024] Convert the text type value into a boolean value;

[0025] Judge whether the first environment is true based on the boolean value.

[0026] Further, converting the original file in the directory where the target file is located into a format file based on mipmap includes the following steps:

[0027] Determine the original file that needs to be format-converted in the directory;

[0028] Read the original file based on the mipmap and generate a layer-by-layer image set of the original file;

[0029] Convert the layer-by-layer image set into a format file.

[0030] Furthermore, the configuring variables of the first environment based on the format file to obtain a second environment includes the following steps:

[0031] Parse the format file to obtain the basic metadata of the file;

[0032] Enumerate the existing global variables in the first environment to determine the configuration variables;

[0033] Create global variables in the first environment based on the basic metadata and the configuration variables;

[0034] Update the first environment based on the global variables to obtain a second environment.

[0035] In a second aspect, the present embodiment provides a resolution map format conversion device, including: an acquisition unit, a construction unit, an identification unit, a judgment unit, a conversion unit, a modification unit, and an execution unit;

[0036] The acquisition unit is configured to acquire a target file and determine a renderer in Houdini based on the target file;

[0037] The construction unit is configured to construct a parser based on the USD standard;

[0038] The identification unit is configured to determine whether a format file exists in the directory of the target file based on the parser;

[0039] The judgment unit is configured to, if the format file does not exist, determine whether the current first environment of the directory is true by the parser;

[0040] The conversion unit is configured to, if the current first environment is true, convert the original file in the directory of the target file into a format file based on mipmap;

[0041] The modification unit is configured to configure variables of the first environment based on the format file to obtain a second environment;

[0042] The execution unit is configured to read the format file by the parser based on the second environment, and at the same time, the renderer performs texture rendering on the target file.

[0043] In a third aspect, the present embodiment provides a computer device, which includes a memory and a processor. A computer program is stored on the processor, and when the processor executes the computer program, the above-mentioned high-resolution map rendering method is implemented.

[0044] In a fourth aspect, this embodiment provides a storage medium storing a computer program, where the computer program includes program instructions that, when executed by a processor, can implement the large-resolution texture map rendering method described above.

[0045] The beneficial effects of the present invention compared with the prior art are as follows: The parser automatically detects whether a Mipmap format file already exists in the directory. If not, it triggers the automatic generation of mipmap through environment variables, avoiding manual conversion one by one. Secondly, through the configuration of environment variables, the texture map path is automatically updated to the newly generated format file, eliminating the need for users to modify the path scene by scene, improving the production efficiency of visual files and shortening the production cycle of visual files.

[0046] The above description is only an overview of the technical solution of the present invention. In order to understand the technical means of the present invention more clearly, it can be implemented according to the content of the specification. And in order to make the above and other purposes, features and advantages of the present invention more obvious and understandable, the following preferred embodiments are specifically described in detail as follows. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 It is a flowchart showing the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0048] Figure 2 It is a flowchart showing the execution of step S3 in the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0049] Figure 3 It is a flowchart showing the execution of step S32 in the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0050] Figure 4 It is a flowchart showing the execution of step S4 in the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0051] Figure 5 It is a flowchart showing the execution of step S5 in the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0052] Figure 6 It is a flowchart showing the execution of step S6 in the large-resolution texture map rendering method provided by an embodiment of the present invention;

[0053] Figure 7 It is a schematic block diagram of a large-resolution texture map rendering device provided by an embodiment of the present invention;

[0054] Figure 8 It is a schematic block diagram of a computer device provided by an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0055] The following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0056] It should be understood that when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, wholes, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, wholes, steps, operations, elements, components, and / or their combinations.

[0057] It should also be understood that the terms used in this specification of the present invention are only for the purpose of describing specific embodiments and are not intended to limit the present invention. As used in this specification of the present invention and the appended claims, unless the context clearly indicates otherwise, the singular forms "a", "an", and "the" are intended to include the plural forms.

[0058] It should be further understood that the term " / and" used in this specification of the present invention and the appended claims refers to any combination and all possible combinations of one or more of the related listed items, and includes these combinations.

[0059] Please refer to Figure 1 the specific embodiments shown. The present invention discloses a large-resolution texture map rendering method, including the following steps:

[0060] Step S1, obtain a target file, and determine a renderer in Houdini based on the target file;

[0061] It can be understood that as a tool for visual file production, the selection of the renderer in Houdini directly affects the texture map processing efficiency. By automatically adapting the renderer based on the target file, manual repeated debugging is avoided, ensuring the unity of the process; at the same time, for large-resolution texture maps, different renderers have differences in memory management, Mipmap technology, and multithreaded optimization, and it is necessary to dynamically match the optimal renderer to improve the production efficiency of visual files.

[0062] Through the above steps, the renderer is dynamically selected according to the texture map parameters embedded in the target file, which not only improves the rendering quality of the visual file but also shortens the rendering time.

[0063] Step S2, construct a parser based on the USD standard;

[0064] It is understandable that USD (Universal Scene Description) can seamlessly integrate the resources and scene data of multiple software (such as Houdini, Maya, Katana, etc.). Building a parser based on the USD standard can eliminate data inconsistency problems caused by different file formats, ensuring the unity and cross-platform compatibility of the rendering process; at the same time, USD can organize and manage large-scale scene data, and can directly parse and extract the texture data required in the target file without manual import or conversion, reducing redundant steps in data processing; in the production of complex visual file special effects, the scene usually contains a large number of high-resolution texture maps and complex material data. The parser based on USD can parse this data and optimize it through the rendering pipeline of Houdini, reducing the workload of manual adjustment.

[0065] Through the above steps, the texture data in the target file can be directly read and format-converted, avoiding the time consumption of manual import and adjustment. At the same time, the USD parser can automatically adjust the configuration of the renderer according to the metadata in the file to ensure the consistency of the rendering results.

[0066] Step S3, based on the parser, determine whether there is a format file in the directory of the target file;

[0067] It is understandable that in the scenario of large-resolution texture map rendering, the target file usually contains multiple sub-resources. By automatically judging whether there is a format file (such as a texture file in Mipmap format) through the parser, manual checking one by one can be avoided, reducing the risk of rendering failure caused by missing resources or incorrect formats. There is already a format file in the target file; and in large-scale texture map rendering tasks (such as film and television special effects or game development), the target file may contain thousands of texture maps. The parser can quickly judge whether there is a format file for each texture map and automatically trigger the conversion process for the missing files, thereby improving the production efficiency of visual files.

[0068] Through the above steps, the format files are automatically processed, reducing the number of times users manually process texture files and improving the production efficiency of visual files.

[0069] Step S4, if the format file does not exist, the parser determines whether the current first environment of the directory is true;

[0070] It is understandable that the format conversion of resolution texture maps consumes a large amount of computing resources. Deciding whether to start the conversion through the environment control of the document can avoid forced execution of high-load operations in scenarios where resources are scarce or users explicitly require manual intervention.

[0071] Through the above steps, the linkage between the document environment and the system state realizes on-demand allocation of computing power. In scenarios where the storage space is insufficient, if the environment variable is false, the parser can issue a warning (such as "Mipmap generation is disabled, please handle the file manually") to avoid process crashes or data corruption caused by forced conversion.

[0072] Step S5, if the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap;

[0073] It can be understood that by calling a renderer (such as the Texture Manager of Houdini) or a low-level API (such as OpenImageIO), the original file can be automatically converted into an optimized format with a Mipmap chain, eliminating the tediousness of manual operations one by one. At the same time, by controlling whether to trigger the conversion through environment variables, forced execution in low-configured devices or high-load scenarios can be avoided to prevent system overload; it is required that the converted files follow a unified naming rule (such as (texture_name>tx) and directory structure to ensure that the subsequent renderer can read them unambiguously and avoid rendering interruptions caused by path or format errors.

[0074] Through the above steps, the time required to convert the original file into the Mipmap format is shortened, and the Mipmap format can automatically select an appropriate texture resolution according to the distance between the camera and the object during the rendering process, reducing the computational amount of texture sampling, thereby improving the rendering performance.

[0075] Step S6, perform variable configuration on the first environment based on the format file to obtain a second environment;

[0076] It can be understood that different format files require different environment configurations to achieve the best rendering effect. The first environment may be a general default environment and cannot be optimized for specific format files. Therefore, performing variable configuration on the first environment based on the format file to obtain a second environment can make the rendering environment match the characteristics of the format file, thereby meeting the rendering requirements of different format files. At the same time, associating the environment configuration process with the format file to achieve automated variable configuration can reduce manual intervention and improve the visual file production efficiency.

[0077] Through the above steps, appropriate environment configurations are customized for different format files, improving the rendering quality based on the characteristics of visual files. At the same time, the rendering result of visual files is improved by adjusting the environment variables.

[0078] Step S7, the parser reads the format file based on the second environment, and at the same time, the renderer performs texture rendering on the target file.

[0079] It is understandable that the parser reads the format file and the renderer performs texture rendering simultaneously, which reduces the time required for the visual file rendering process. At the same time, the second environment is obtained by configuring variables for the first environment according to the characteristics of the format file, which provides operating conditions adapted to the format file for rendering. In this specific environment, the parser can accurately obtain the texture information in the file when reading the format file, and the renderer performs texture rendering on the target file based on this accurate information, which can ensure that the rendering result is consistent with the expectation and avoid rendering deviations caused by environment mismatch or incorrect information reading.

[0080] Through the above steps, the parser reads the format file and the renderer performs texture rendering simultaneously, reducing the time required for the rendering process and shortening the production cycle of the visual file.

[0081] Through steps S1 to S7, the parser automatically detects whether a Mipmap format file already exists in the directory. If not, it triggers the automatic generation of mipmap through environment variables, avoiding manual conversion one by one. Secondly, through the configuration of environment variables, the texture path is automatically updated to the newly generated format file, eliminating the need for users to modify the path scene by scene, improving the production efficiency of visual files and shortening the production cycle of visual files.

[0082] Please refer to Figure 1 , after the parser determines whether a format file exists in the directory of the target file based on the above, the following steps are further included:

[0083] Step S8, if the format file exists, the parser reads the format file, and at the same time the renderer performs texture rendering on the target file.

[0084] It is understandable that if the target file already contains the required format file (such as the Mipmap format), the preprocessed target file can be directly used, avoiding the repeated conversion process. At the same time, the renderer directly performs texture rendering on the target file according to the information provided by the parser. Since the format file is already the required format file, the memory occupancy and computational burden are reduced, thereby improving the rendering efficiency of visual files.

[0085] Through the above steps, the preprocessed format file is directly used, saving the time and computing resources for repeated conversion and improving the processing efficiency of visual files.

[0086] In an embodiment, please refer to Figure 2 , the determination of whether a format file exists in the directory of the target file based on the parser includes the following steps:

[0087] Step S31, read the configuration information of the target file;

[0088] Step S32: The parser determines whether there is a format file in the directory of the target file based on the configuration information.

[0089] Through steps S31 to S32, the existence of the format file is determined, avoiding errors and failures caused by the lack of the format file during the rendering process, improving the stability of the entire rendering process. The rendering work can be carried out more stably, avoiding the phenomenon of rendering interruption or rework caused by unexpected situations, improving the stability of visual file production, and at the same time avoiding the rendering process without the format file, saving the computing resources of the system.

[0090] In one embodiment, refer to Figure 3 , the parser determines whether there is a format file in the directory of the target file based on the configuration information, including the following steps:

[0091] Step S321: The parser determines whether there is a target file with a preset suffix in the directory of the target file based on the configuration information;

[0092] Step S322: If it exists, the target file is determined as the format file.

[0093] Through steps S321 to S322, based on the file suffix name judgment, the parser can quickly determine the format file, avoiding complex content analysis of a large number of files, shortening the file recognition time, and improving the rendering efficiency of visual files.

[0094] In one embodiment, refer to Figure 4 , the parser determines whether the current first environment of the directory is true, including the following steps:

[0095] Step S41: The parser searches for a specific file storing the first environment in the directory based on a preset rule;

[0096] Step S42: Generate a text type value based on the specific file;

[0097] Step S43: Convert the text type value into a boolean value;

[0098] Step S44: Determine whether the first environment is true based on the boolean value.

[0099] Through steps S41 to S44, based on the rendering of the first environmental control visual file, the user can adjust the rendering strategy according to the characteristics of the visual file without the need for large-scale modification of the entire rendering system. At the same time, the automated environmental variable judgment and configuration process reduces manual intervention, avoiding the cumbersome and error-prone manual configuration. The user only needs to modify the environmental variable values in specific files, and the system can automatically adjust the rendering process according to these values, improving work efficiency.

[0100] In one embodiment, please refer to Figure 5 , the conversion of the original file in the directory where the target file is located into a format file based on mipmap includes the following steps:

[0101] Step S51, determining the original files in the directory that need to be format-converted;

[0102] Step S52, reading the original file based on the mipmap and generating a layer-by-layer image set of the original file;

[0103] Step S53, converting the layer-by-layer image set into a format file.

[0104] Through steps S51 to S53, using the texture in Mipmap format, the renderer can select the texture with an appropriate resolution for rendering according to the visual file, reducing unnecessary texture sampling calculations, thereby improving the rendering speed of the visual file. And since Mipmap contains texture images with different resolutions, low-resolution textures can be used when rendering distant objects, thus reducing memory occupancy.

[0105] In one embodiment, please refer to Figure 6 , the configuration of variables in the first environment based on the format file to obtain a second environment includes the following steps:

[0106] Step S61, parsing the format file to obtain the basic metadata of the file;

[0107] Step S62, enumerating the existing global variables in the first environment to determine the configuration variables;

[0108] Step S63, creating global variables in the first environment based on the basic metadata and the configuration variables;

[0109] Step S64, updating the first environment based on the global variables to obtain a second environment.

[0110] Through steps S61 to S64, based on the characteristics of the format file, the environment is configured, and the renderer can accurately process the data in the file, thereby improving the rendering quality of the visual file, and optimizing the environment configuration according to the characteristics of the format file, reducing unnecessary calculations and resource consumption, and improving the rendering efficiency of the visual file.

[0111] Please refer to Figure 7 , the present invention also discloses a resolution map format conversion device, including: an acquisition unit 10, a construction unit 20, an identification unit 30, a judgment unit 40, a conversion unit 50, a modification unit 60, and an execution unit 70;

[0112] The acquisition unit 10 is used to acquire a target file and determine a renderer in Houdini based on the target file;

[0113] The construction unit 20 is used to construct a parser based on the USD standard;

[0114] The identification unit 30 is used to judge whether a format file exists in the directory of the target file based on the parser;

[0115] The judgment unit 40 is used to, if the format file does not exist, the parser judges whether the current first environment of the directory is true;

[0116] The conversion unit 50 is used to, if the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap;

[0117] The modification unit 60 is used to perform variable configuration on the first environment based on the format file to obtain a second environment;

[0118] The execution unit 70 is used for the parser to read the format file based on the second environment, and at the same time the renderer performs texture rendering on the target file.

[0119] It should be noted that those skilled in the art can clearly understand that the specific implementation processes of the above resolution map format conversion device and each unit can refer to the corresponding descriptions in the foregoing method embodiments. For the sake of convenience and conciseness of description, they will not be repeated here.

[0120] The above can be implemented in the form of a computer program, and the computer program can run on a computer device as shown in Figure 8 shown.

[0121] Please refer to Figure 8 , Figure 8It is a schematic block diagram of a computer device provided by an embodiment of the present application; the computer device 500 can be a terminal or a server. Among them, the terminal can be an electronic device with communication functions such as a smart phone, a tablet computer, a notebook computer, a desktop computer, a personal digital assistant, and a wearable device. The server can be an independent server or a server cluster composed of multiple servers.

[0122] Referring to Figure 8 , the computer device 500 includes a processor 502, a memory, and a network interface 505 connected through a system bus 501. Among them, the memory can include a non-volatile storage medium 503 and an internal memory 504.

[0123] The non-volatile storage medium 503 can store an operating system 5031 and a computer program 5032. The computer program 5032 includes program instructions. When the program instructions are executed, the processor 502 can be made to execute a large-resolution texture map rendering method, including the following steps: obtaining a target file, determining a renderer in Houdini based on the target file; constructing a parser based on the USD standard; judging whether there is a format file in the directory of the target file based on the parser; if there is no such format file, the parser judges whether the current first environment of the directory is true; if the current first environment is true, converting the original file in the directory where the target file is located into a format file based on mipmap; performing variable configuration on the first environment based on the format file to obtain a second environment; the parser reads the format file based on the second environment, and at the same time the renderer performs texture rendering on the target file.

[0124] The processor 502 is used to provide computing and control capabilities to support the operation of the entire computer device 500.

[0125] The internal memory 504 provides an environment for the operation of the computer program 5032 in the non-volatile storage medium 503. When the computer program 5032 is executed by the processor 502, the processor 502 can be made to execute a large-resolution texture map rendering method.

[0126] The network interface 505 is used for network communication with other devices. Those skilled in the art can understand that Figure 8 the structure shown in

[0127] only represents a block diagram of some structures related to the solution of the present application, and does not constitute a limitation on the computer device 500 to which the solution of the present application is applied. The specific computer device 500 may include more or fewer components than those shown in the figure, or combine some components, or have different component arrangements.

[0127] Among them, the processor 502 is used to run the computer program 5032 stored in the memory to implement the following steps:

[0128] Step S1: Obtain a target file and determine a renderer in Houdini based on the target file.

[0129] Step S2: Construct a parser based on the USD standard.

[0130] Step S3: Based on the parser, determine whether there is a format file in the directory of the target file.

[0131] Step S4: If the format file does not exist, the parser determines whether the current first environment of the directory is true.

[0132] Step S5: If the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap.

[0133] Step S6: Perform variable configuration on the first environment based on the format file to obtain a second environment.

[0134] Step S7: The parser reads the format file based on the second environment, and at the same time, the renderer performs texture rendering on the target file.

[0135] It should be understood that in the embodiments of the present application, the processor 502 may be a central processing unit (CPU), and the processor 502 may also be other general-purpose processors, digital signal processors (DSPs), application specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among them, the general-purpose processor may be a microprocessor or the processor may also be any conventional processor, etc.

[0136] Those of ordinary skill in the art can understand that all or part of the processes of the methods in the above embodiments can be completed by instructing relevant hardware through a computer program. The computer program includes program instructions, and the computer program can be stored in a storage medium, and the storage medium is a computer-readable storage medium. The program instructions are executed by at least one processor in the computer system to implement the process steps of the embodiments of the above methods.

[0137] Therefore, the present invention also provides a storage medium. The storage medium can be a computer-readable storage medium. The storage medium stores a computer program, wherein the computer program includes program instructions, and when the program instructions are executed by a processor, the above-mentioned high-resolution texture map rendering method can be implemented. The storage medium stores a computer program, the computer program includes program instructions, and when the program instructions are executed by a processor, the above-mentioned method can be implemented. The program instructions include the following steps:

[0138] Step S1: Obtain a target file and determine a renderer in Houdini based on the target file;

[0139] Step S2: Construct a parser based on the USD standard;

[0140] Step S3: Based on the parser, determine whether there is a format file in the directory of the target file;

[0141] Step S4: If the format file does not exist, the parser determines whether the current first environment of the directory is true;

[0142] Step S5: If the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap;

[0143] Step S6: Perform variable configuration on the first environment based on the format file to obtain a second environment;

[0144] Step S7: The parser reads the format file based on the second environment, and at the same time, the renderer performs texture rendering on the target file.

[0145] The storage medium can be a variety of computer-readable storage media such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a magnetic disk, or an optical disc, etc., which can store program codes.

[0146] Those of ordinary skill in the art can realize that the units and algorithm steps of the examples described in combination with the embodiments disclosed herein can be implemented by electronic hardware, computer software, or a combination of the two. To clearly illustrate the interchangeability of hardware and software, the components and steps of the examples have been generally described according to their functions in the above description. Whether these functions are executed in a hardware or software manner depends on the specific application and design constraints of the technical solution. Professional technicians can use different methods to implement the described functions for each specific application, but such implementation should not be considered to exceed the scope of the present invention.

[0147] In several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of each unit is only a logical function division, and there may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed.

[0148] The steps in the method embodiments of the present invention can be adjusted, combined, and deleted according to actual needs. The units in the device embodiments of the present invention can be combined, divided, and deleted according to actual needs. In addition, the functional units in each embodiment of the present invention can be integrated in a processing unit, or each unit can exist physically alone, or two or more units can be integrated in one unit.

[0149] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a storage medium. Based on such an understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for causing a computer device (which can be a personal computer, a terminal, or a network device, etc.) to execute all or part of the steps of the methods described in each embodiment of the present invention.

[0150] The above embodiments are preferred implementation solutions of the present invention. In addition, the present invention can be implemented in other ways. Any obvious replacement without departing from the concept of the present technical solution is within the protection scope of the present invention.

Claims

1. A large-resolution texture rendering method, characterized in that: The following steps are involved: Obtaining a target file, and determining a renderer in Houdini based on the target file; Build a parser based on the USD standard; Determine whether there is a format file in the directory of the target file based on the parser; If the format file does not exist, the parser determines whether the current first environment of the directory is true; If the current first environment is true, convert the original file in the directory where the target file is located into a format file based on mipmap; Based on the format file, configure the variables of the first environment to obtain the second environment; The parser reads the format file based on the second environment, and the renderer performs texture rendering on the target file.

2. The high-resolution texture rendering method according to claim 1, characterized in that: After the parser determines whether there is a format file in the directory of the target file, the following steps are also included: If the format file exists, the parser reads the format file, and the renderer performs texture rendering on the target file.

3. The high-resolution texture rendering method according to claim 1, characterized in that: The determining whether there is a format file in the directory of the target file based on the parser comprises the following steps: Read the configuration information of the target file; The parser determines whether there is a format file in the directory of the target file based on the configuration information.

4. The high-resolution texture rendering method according to claim 3, characterized in that: The parser determines whether there is a format file in the directory of the target file based on the configuration information, including the following steps: The parser determines whether there is a target file with a preset suffix in the directory of the target file based on the configuration information; If it exists, the target file is determined as a format file.

5. The high-resolution texture rendering method according to claim 1, characterized in that: The parser determines whether the current first environment of the directory is true by the following steps: The parser searches the directory for a specific file storing the first environment based on a preset rule. generating a text type value based on the specific file; Convert the text type value into a Boolean value; A determination is made based on the Boolean value as to whether the first environment is true.

6. The high-resolution texture rendering method according to claim 1, characterized in that: The converting of the original file in the directory where the target file is located into a format file based on mipmap comprises the following steps: Determine the original files in the directory that need to be converted into different formats; Read the original file based on the mipmap and generate a layer-by-layer image set of the original file; The layer-by-layer image set is converted into a format file.

7. The high-resolution texture rendering method according to claim 1, characterized in that: The step of configuring the first environment variables based on the format file to obtain the second environment comprises the following steps: Parsing the format file to obtain basic metadata of the file; Enumerate existing global variables in the first environment to determine configuration variables; a global variable created in the first environment based on the basic metadata and the configuration variables; The first environment is updated based on the global variable to obtain a second environment.

8. A resolution map format conversion device, characterized in that: include: Acquisition unit, construction unit, identification unit, judgment unit, conversion unit, modification unit and execution unit; The acquisition unit is used to acquire a target file and determine a renderer in Houdini based on the target file; The construction unit is used to construct a parser based on the USD standard; The identification unit is used to determine whether there is a format file in the directory of the target file based on the parser; The judging unit is configured to judge, by the parser, whether the current first environment of the directory is true if the format file does not exist; The conversion unit is used to convert the original file in the directory where the target file is located into a format file based on mipmap if the current first environment is true; The modification unit is used to configure variables of the first environment based on the format file to obtain a second environment; The execution unit is used for the parser to read the format file based on the second environment, and the renderer to perform texture rendering on the target file.

9. A computer device, characterized in that: The computer device includes a memory and a processor, a computer program is stored on the processor, and when the processor executes the computer program, the high-resolution texture rendering method according to any one of claims 1 to 7 is implemented.

10. A storage medium, characterized in that: The storage medium stores a computer program, which includes program instructions. When the program instructions are executed by a processor, the high-resolution texture rendering method according to any one of claims 1 to 7 can be implemented.

Images