Virtual scene texture generation system and method

Abstract

The invention discloses a virtual scene texture generation system and method. The system comprises a semantic retrieval module, a texture database and a texture generation module which are arranged in a cloud server; an interaction module and a rendering module are arranged in the local client; the cloud server is used for storing the texture database and executing semantic retrieval and texture generation calculation; the local client is used for interacting with a user and rendering a virtual scene; and the cloud server is connected with the local client through a network communication link. According to the method, simple and rapid virtual scene texture generation is realized through semantic retrieval and a texture database, rapid virtual scene texture generation and real-time rendering are realized through cloud computing and on-site rendering, and the method is more suitable for being used in studios and live broadcasting rooms.

Description

Technical Field

[0001] The present invention relates to the technical field of image generation and rendering, and in particular to a system and method for generating virtual scene texture. Background Art

[0002] Virtual scene texture generation technology is widely used in game development, film and television production, virtual studios, digital twins, and other fields. In games, realistic textures (such as metallic weapons and wood-grained floors) enhance player immersion. In film and television production, high-precision textures (such as cloth folds and rock textures) are key to scene realism. In virtual studios and live broadcast rooms, real-time virtual background textures (such as virtual stages and virtual audience seats) enable rapid scene switching and reduce the cost of physical set design. These applications place high demands on texture real-time performance, customization, and physical realism (such as compliance with PBR rendering rules), which directly impacts the visual quality and user experience of the scene.

[0003] In existing virtual scene texture generation technologies, manual texture drawing relies on designers using tools such as Photoshop to draw textures, and then importing them into engines (such as Unity and Unreal). This requires professional art skills and is inefficient. Texture replacement based on material libraries requires users to select materials from preset texture libraries (such as SubstanceLibrary) and apply them to the scene model through UV mapping. Although this simplifies the operation, the diversity of textures is limited, and there is a lack of efficient association methods (for example, it is impossible to directly retrieve the corresponding texture through "rusty metal"). Traditional AI generation technology uses GAN (generative adversarial network) to generate textures, but it has weak control over input conditions and is difficult to adapt to specific areas of the virtual scene (such as UV masks of irregular polygons). It also does not integrate PBR parameter generation, and requires additional manual adjustment of material properties.

[0004] Therefore, existing technologies for virtual scene generation have a high barrier to entry and rely on specialized personnel. For example, manual rendering and library replacement require the work of artists or technicians. On-site staff (such as virtual studio directors) lack texture design skills, making it impossible to adjust scene textures in real time (e.g., temporarily changing the texture style of a background wall during a live broadcast). Existing AI generation technologies are mostly based on global generation (e.g., the entire texture image). This makes it difficult to precisely control the texture of a target area (e.g., a window in the scene) using semantic text (e.g., "light blue frosted glass"). They also cannot automatically adapt to the geometry of the area (e.g., irregular boundaries of UV masks). Even if a texture image is generated, manual setting of physical texture parameters such as metalness and roughness is still required. This results in poor compatibility with physical rendering engines (such as UE4's PBR material system), distorted reflections and shadows, and reduced scene realism. Texture generation is computationally intensive, and conventional equipment cannot meet the real-time rendering requirements of scenes such as virtual studios (e.g., completing texture updates and rendering within 50ms). Summary of the Invention

[0005] The embodiments of the present invention provide a system and method for generating virtual scene textures, which are used to solve the problems in the prior art of virtual scene generation, such as high threshold for operation, reliance on professionals, poor real-time performance, and inability of general equipment to quickly complete real-time rendering.

[0006] In one aspect, an embodiment of the present invention provides a system for generating a virtual scene texture, comprising: A cloud server, wherein the cloud server is provided with a semantic retrieval module, a texture database and a texture generation module; A local client, wherein the local client is provided with an interaction module and a rendering module; The cloud server is used to store the texture database, and the cloud server performs semantic retrieval and texture generation calculations; The semantic retrieval module is used to convert the semantic text input by the user into a feature vector, and the semantic retrieval module is used to match similar texture bases in the texture database; The texture generation module generates target texture data through the area parameters of the virtual scene and the texture base; The local client is used to interact with the user and render the virtual scene; The interaction module is used to receive semantic input from the user and locate the target area in the virtual scene; The rendering module is used to receive the target texture data generated by the cloud server and map it to the target area for real-time rendering; The cloud server is connected to the local client via a network communication link.

[0007] In a possible implementation, the semantic retrieval module further includes: A cross-modal feature alignment unit, which is used to construct a joint embedding space of text and texture images using a cross-modal model; A vector database unit is used to store feature vectors of texture images and corresponding metadata, and the vector database unit realizes fast matching of the texture base through cosine similarity calculation.

[0008] In a possible implementation, the texture generation module further includes: An AI generation unit is configured to generate a model based on ControlNet and StableDiffusion, and to generate a customized texture using the UV mask of the virtual scene and the texture base as conditions; A PBR parameter generation unit is used to synchronously generate physical rendering parameters that match the texture base.

[0009] In one possible implementation, the network communication link adopts the gRPC efficient transmission protocol to achieve compressed transmission and asynchronous processing of the target texture data.

[0010] In a possible implementation, the interaction module further includes: a semantic segmentation unit, configured to automatically identify semantic regions in the virtual scene; A mask drawing unit that allows the user to interactively define the area where a texture is applied.

[0011] On the other hand, an embodiment of the present invention provides a method for generating a virtual scene texture, comprising: Receiving semantic text input by the user and positioning of a target area in the virtual scene at the local client; Sending the semantic text to a cloud server; Converting the semantic text into a feature vector through a semantic retrieval module; Matching similar texture bases in a texture database; The cloud server generates customized texture data and PBR parameters based on the texture base and UV parameters of the target area; The cloud server transmits the generated texture data and PBR parameters to the local client; The local client maps the texture data and PBR parameters to the target area in combination with scene lighting for real-time rendering.

[0012] In a possible implementation, converting the semantic text into a feature vector by a semantic retrieval module includes: Mapping the semantic text and the texture image to the same feature space through the CLIP model; Calculating the cosine similarity between the semantic text and the texture image; The semantic text is matched to the texture basis according to the cosine similarity.

[0013] In a possible implementation, before the cloud server generates customized texture data and PBR parameters based on the texture base and the UV parameters of the target area, the process further includes: Controlling the geometric mapping of texture generation using UV masks through the ControlNet model; The texture data is adapted to the shape of the target area.

[0014] In one possible implementation, the cloud server and the local client use the gRPC protocol and the WebP compression algorithm for data transmission.

[0015] In a possible implementation, the local client performs PBR parameter fusion on the texture data before the real-time rendering; The local client calculates the reflection and shadow effects of the texture in real time in combination with the lighting probes in the scene.

[0016] The system and method for generating virtual scene textures in the present invention have the following advantages: (1) Simple and fast virtual scene texture generation is achieved through semantic retrieval and texture database, without the need for professional personnel to operate.

[0017] (2) Rapid virtual scene texture generation and real-time rendering are achieved through cloud computing and on-site rendering, which is more suitable for use in studios and live broadcast rooms. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0019] Figure 1 A schematic diagram of the structure of a virtual scene texture generation system provided in an embodiment of the present application; Figure 2 A flowchart of a method for generating a virtual scene texture provided in an embodiment of the present application. DETAILED DESCRIPTION

[0020] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0021] Figure 1 This is a structural diagram of a virtual scene texture generation system provided in an embodiment of the present application. The embodiment of the present invention provides a virtual scene texture generation system, comprising: A cloud server, wherein the cloud server is provided with a semantic retrieval module, a texture database and a texture generation module; A local client, wherein the local client is provided with an interaction module and a rendering module; The cloud server is used to store the texture database, and the cloud server performs semantic retrieval and texture generation calculations; The semantic retrieval module is used to convert the semantic text input by the user into a feature vector, and the semantic retrieval module is used to match similar texture bases in the texture database; The texture generation module generates target texture data through the area parameters of the virtual scene and the texture base; The local client is used to interact with the user and render the virtual scene; The interaction module is used to receive semantic input from the user and locate the target area in the virtual scene; The rendering module is used to receive the target texture data generated by the cloud server and map it to the target area for real-time rendering; The cloud server is connected to the local client via a network communication link.

[0022] The semantic retrieval module also includes: A cross-modal feature alignment unit, which is used to construct a joint embedding space of text and texture images using a cross-modal model; A vector database unit is used to store feature vectors of texture images and corresponding metadata, and the vector database unit realizes fast matching of the texture base through cosine similarity calculation.

[0023] The texture generation module also includes: An AI generation unit is configured to generate a model based on ControlNet and StableDiffusion, and to generate a customized texture using the UV mask of the virtual scene and the texture base as conditions; A PBR parameter generation unit is used to synchronously generate physical rendering parameters that match the texture base.

[0024] The network communication link adopts the gRPC efficient transmission protocol to achieve compressed transmission and asynchronous processing of the target texture data.

[0025] The interaction module also includes: a semantic segmentation unit, configured to automatically identify semantic regions in the virtual scene; A mask drawing unit that allows the user to interactively define the area where a texture is applied.

[0026] For example, a "cloud-local" collaborative architecture is adopted, with the core functions divided into two parts: cloud server and local client, and efficient communication is achieved through the gRPC protocol.

[0027] The cloud server is responsible for computationally intensive tasks such as semantic retrieval and texture generation, and includes the following core modules: The semantic retrieval module has built-in: Cross-modal feature alignment unit, building a joint text-image embedding space based on the CLIP model; Vector database unit: stores texture feature vectors (including metadata) and quickly matches texture bases through cosine similarity.

[0028] Texture database, which stores massive texture images (JPEG / PNG format) and their corresponding feature vectors and PBR parameter templates (JSON format).

[0029] Texture generation module, built-in: AI generation unit: Based on ControlNet+StableDiffusion, it generates customized textures based on UV masks and texture bases; PBR parameter generation unit: It generates matching metalness, roughness and other parameters based on the color / roughness statistics of the texture base.

[0030] The local client is responsible for user interaction and real-time rendering, and includes the following core modules: The interactive module has built-in semantic segmentation unit: automatically identifies semantic regions (such as "wall" and "ground") in the virtual scene based on the U-Net model; Mask drawing unit: supports user hand-drawing / rectangular selection of texture application area (output UV mask).

[0031] Rendering module, used to receive texture data (WebP compression) and PBR parameters transmitted from the cloud; After fusing the PBR parameters, the reflection / shadow is calculated in conjunction with the scene light probe and mapped to the target area in real time.

[0032] The gRPC protocol is used to achieve low-latency transmission, supporting texture data compression (WebP algorithm, with a compression rate 25%-35% higher than PNG) and asynchronous processing (the client can continue to interact after sending a request without blocking the interface).

[0033] Figure 2 A flowchart of a method for generating a virtual scene texture provided in an embodiment of the present application; an embodiment of the present invention provides a method for generating a virtual scene texture, comprising: receiving semantic text input by a user and positioning a target area in a virtual scene at a local client; Sending the semantic text to a cloud server; Converting the semantic text into a feature vector through a semantic retrieval module; Matching similar texture bases in a texture database; The cloud server generates customized texture data and PBR parameters based on the texture base and UV parameters of the target area; The cloud server transmits the generated texture data and PBR parameters to the local client; The local client maps the texture data and PBR parameters to the target area in combination with scene lighting for real-time rendering.

[0034] Converting the semantic text into a feature vector by a semantic retrieval module includes: Mapping the semantic text and the texture image to the same feature space through the CLIP model; Calculating the cosine similarity between the semantic text and the texture image; The semantic text is matched to the texture basis according to the cosine similarity.

[0035] Before the cloud server generates customized texture data and PBR parameters based on the texture base and the UV parameters of the target area, the process further includes: Controlling the geometric mapping of texture generation using UV masks through the ControlNet model; The texture data is adapted to the shape of the target area.

[0036] The cloud server and the local client use the gRPC protocol and the WebP compression algorithm for data transmission.

[0037] The local client performs PBR parameter fusion on the texture data before the real-time rendering; The local client calculates the reflection and shadow effects of the texture in real time in combination with the lighting probes in the scene.

[0038] Exemplarily, the local client receives semantic text (such as "dark gray marble texture") input by the user through the interaction module, and locates the target area in the virtual scene (outputs UV mask) through the semantic segmentation unit / mask rendering unit.

[0039] The local client sends the semantic text, UV mask, and UV parameters (texture mapping coordinates) of the target area to the cloud server via gRPC.

[0040] The cloud-based semantic retrieval module calls the CLIP model to encode semantic text into a feature vector (dimension 512).

[0041] The vector database unit calculates the cosine similarity between the vector and all texture image feature vectors in the texture database.

[0042] The top 3 similarity textures are selected as candidate bases (users can make a second selection).

[0043] The AI generation unit takes the candidate texture base as input, combines it with the UV mask (conditional input of ControlNet), and generates a texture (resolution 1024×1024) that adapts to the shape of the target area through Stable Diffusion.

[0044] The PBR parameter generation unit analyzes the color mean (BaseColor), brightness variance (roughness), and metal reflectivity (metallicity) of the texture base, and outputs PBR parameters (such as {"metallic":0.1,"roughness":0.4,"baseColor":[0.8,0.8,0.8]}).

[0045] The cloud asynchronously transmits the generated texture (WebP compression) and PBR parameters (JSON format) to the local client via the gRPC protocol (transmission delay ≤ 200ms).

[0046] Local rendering module: Fusion of PBR parameters and texture data (e.g. associating a roughness map with the brightness channel of a texture); Combined with the scene lighting probe (recording the direction / intensity of ambient light), the PBR rendering equation is used to calculate the reflection and shadow effects of the texture, and finally mapped to the target area to complete the rendering.

[0047] In a possible embodiment, the code implementation example of the core module is as follows: Contains semantic retrieval, texture generation condition control and PBR parameter generation logic.

[0048] semantic_retrieval.py: implements cross-modal feature alignment between text and texture images based on the CLIP model, quickly retrieves similar texture bases through cosine similarity, and supports efficient matching of large-scale texture databases.

[0049] importtorch importclip fromPILimportImage import numpy asnp classSemanticRetrieval: def__init__(self,device='cuda'): self.device = device self.model,self.preprocess=clip.load("ViT-B / 32",device=device) self.texture_db=None# Feature vector loaded from texture database (shape:[N,512]) self.texture_metadata=None#Texture metadata (such as path, PBR template) defencode_text(self,text): """Encode semantic text into feature vectors""" withtorch.no_grad(): text_input=clip.tokenize([text]).to(self.device) text_features=self.model.encode_text(text_input) text_features / =text_features.norm(dim=-1,keepdim=True)#Normalization returntext_features.cpu().numpy()[0]#output shape:(512,) defencode_image(self,image_path): """Encode the texture image into a feature vector (pre-stored in the database)""" image=self.preprocess(Image.open(image_path)).unsqueeze(0).to(self.device) withtorch.no_grad(): image_features=self.model.encode_image(image) image_features / =image_features.norm(dim=-1,keepdim=True) returnimage_features.cpu().numpy()[0] defretrieve_texture(self,text,top_k=3): """Retrieve similar texture bases based on semantic text""" text_feature=self.encode_text(text) #Calculate cosine similarity (assuming texture_db is a numpy array) similarities=np.dot(self.texture_db,text_feature) top_indices=np.argsort(similarities)[-top_k:][::-1]#Descending order to get top_k return[self.texture_metadata[i]foriintop_indices] if__name__=="__main__": #Example: Initialize and retrieve a texture retriever=SemanticRetrieval() retriever.texture_db=np.random.rand(1000,512)#Simulate texture database features retriever.texture_metadata=[{'path':f'texture_{i}.png'}foriinrange(1000)] results=retriever.retrieve_texture("Dark Gray Marble Texture") print("Retrieved texture base:",results).

[0050] texture_generation.py: Uses ControlNet+StableDiffusion to generate custom textures that fit the UV mask, and automatically generates PBR parameters (metallicity, roughness, etc.) that conform to physical rendering rules by counting the color / brightness characteristics of the texture base.

[0051] importtorch fromdiffusersimportStableDiffusionControlNetPipeline,ControlNetModel fromPILimportImage import numpy asnp classTextureGenerator: def__init__(self,device='cuda'): self.device = device #Load the ControlNet+StableDiffusion model (weights need to be downloaded in advance) self.controlnet = ControlNetModel.from_pretrained( "lllyasviel / sd-controlnet-scribble", torch_dtype = torch.float16 ) self.pipe = StableDiffusionControlNetPipeline.from_pretrained( "runwayml / stable-diffusion-v1-5", controlnet = self.controlnet, torch_dtype = torch.float16 ).to(device) self.pipe.enable_attention_slicing() # Optimize VRAM def generate_texture(self, base_texture_path, uv_mask_path, prompt, width = 1024, height = 1024): """Generate customized texture based on ControlNet""" base_texture = Image.open(base_texture_path).convert("RGB").resize((width, height)) uv_mask = Image.open(uv_mask_path).convert("L").resize((width, height)) # UV mask (grayscale image) with torch.no_grad(): image = self.pipe( prompt = prompt, image = base_texture, control_image = uv_mask, width = width, height = height, num_inference_steps = 30 ).images[0] return image defgenerate_pbr_params(self,base_texture_path): """Generate PBR parameters based on texture base""" image=Image.open(base_texture_path).convert("RGB") img_array=np.array(image).astype(np.float32) / 255.0 #Calculate BaseColor (color mean) base_color=np.mean(img_array,axis=(0,1))#shape:(3,) #Calculate Roughness (brightness variance, the larger the variance, the rougher it is) gray=0.299*img_array[...,0]+0.587*img_array[...,1]+0.114*img_array[...,2] roughness=np.clip(np.var(gray)*2,0,1)#Scale to [0,1] #Calculate Metallic (assuming the metal area is a high saturation color) saturation = np.std(img_array,axis=2)#Saturation (the larger the standard deviation, the brighter it is) metallic=np.clip(np.mean(saturation)*1.5,0,1)#Experience value return { "baseColor":base_color.tolist(), "roughness":float(roughness), "metallic":float(metallic) } if__name__=="__main__": generator = TextureGenerator() #Example: Generate texture and PBR parameters texture=generator.generate_texture( base_texture_path="base_marble.png", uv_mask_path="uv_mask.png", prompt="Dark grey marble texture with fine cracks on the surface" ) texture.save("generated_texture.png") pbr_params=generator.generate_pbr_params("base_marble.png") print("Generated PBR parameters:",pbr_params) grpc_transport.py: defines the gRPC service interface to achieve low-latency data transmission between the cloud and the local, and supports efficient communication of texture data (WebP compression) and PBR parameters (JSON format).

[0052] #You need to install grpcio and protobuf first: pip install grpcio protobuf #1. Define the .proto file (texture_service.proto) """ syntax="proto3"; packagetexture; messageTextureRequest{ stringsemantic_text=1; bytesuv_mask=2;#WebP compressed UV mask bytesuv_params=3;#Target area UV parameters (after serialization) } messageTextureResponse{ bytestexture_data=1;#WebP compressed texture stringpbr_params=2;#PBR parameters in JSON format } serviceTextureService{ rpcGenerateTexture(TextureRequest)returns(TextureResponse){}} """ #2 Generate gRPC code (command: python -mgrpc_tools.protoc -I . --python_out=. --grpc_python_out=.texture_service.proto) #3. Server implementation (cloud_server.py) importgrpc importtexture_service_pb2aspb2 importtexture_service_pb2_grpcaspb2_grpc fromconcurrentimportfutures classTextureService(pb2_grpc.TextureServiceServicer): defGenerateTexture(self,request,context): #Call semantic retrieval and texture generation modules semantic_text=request.semantic_text uv_mask=Image.open(io.BytesIO(request.uv_mask))#Analyze UV mask #... (Omit the specific generation logic) #Return compressed texture and PBR parameters returnpb2.TextureResponse( texture_data=texture_bytes, pbr_params=json.dumps(pbr_params) ) defrun_server(): server=grpc.server(futures.ThreadPoolExecutor(max_workers=10)) pb2_grpc.add_TextureServiceServicer_to_server(TextureService(),server) server.add_insecure_port('[::]:50051') server.start() server.wait_for_termination() #4. Client implementation (local_client.py) importgrpc importtexture_service_pb2aspb2 importtexture_service_pb2_grpcaspb2_grpc defclient_request(semantic_text,uv_mask_path,uv_params): withgrpc.insecure_channel('localhost:50051')aschannel: stub=pb2_grpc.TextureServiceStub(channel) withopen(uv_mask_path,'rb')asf: uv_mask_bytes=f.read() request=pb2.TextureRequest( semantic_text=semantic_text, uv_mask=uv_mask_bytes, uv_params=uv_params.SerializeToString() #Assuming uv_params is a protobuf message ) response=stub.GenerateTexture(request) returnresponse.texture_data,response.pbr_params Although the preferred embodiments of the present invention have been described, those skilled in the art may make additional changes and modifications to these embodiments once they have learned the basic creative concept. Therefore, the appended claims are intended to be interpreted as including all changes and modifications that fall within the scope of the present invention and the preferred embodiments.

[0053] Obviously, those skilled in the art may make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. Thus, if such changes and modifications fall within the scope of the claims and their equivalents, the present invention is intended to include such changes and modifications.

Claims

1. A system for generating virtual scene texture, characterized in that: include: A cloud server, wherein the cloud server is provided with a semantic retrieval module, a texture database and a texture generation module; A local client, wherein the local client is provided with an interaction module and a rendering module; The cloud server is used to store the texture database, and the cloud server performs semantic retrieval and texture generation calculations; The semantic retrieval module is used to convert the semantic text input by the user into a feature vector, and the semantic retrieval module is used to match similar texture bases in the texture database; The texture generation module generates target texture data through the area parameters of the virtual scene and the texture base; The local client is used to interact with the user and render the virtual scene; The interaction module is used to receive semantic input from the user and locate the target area in the virtual scene; The rendering module is used to receive the target texture data generated by the cloud server and map it to the target area for real-time rendering; The cloud server is connected to the local client via a network communication link.

2. A virtual scene texture generation system according to claim 1, characterized in that: The semantic retrieval module also includes: A cross-modal feature alignment unit, which is used to construct a joint embedding space of text and texture images using a cross-modal model; A vector database unit is used to store feature vectors of texture images and corresponding metadata, and the vector database unit realizes fast matching of the texture base through cosine similarity calculation.

3. A system for generating virtual scene texture according to claim 1, characterized in that: The texture generation module also includes: An AI generation unit is configured to generate a model based on ControlNet and StableDiffusion, and to generate a customized texture using the UV mask of the virtual scene and the texture base as conditions; A PBR parameter generation unit is used to synchronously generate physical rendering parameters that match the texture base.

4. A system for generating virtual scene texture according to claim 1, characterized in that: The network communication link adopts the gRPC efficient transmission protocol to achieve compressed transmission and asynchronous processing of the target texture data.

5. The system for generating virtual scene texture according to claim 1, characterized in that: The interaction module also includes: a semantic segmentation unit, configured to automatically identify semantic regions in the virtual scene; A mask drawing unit that allows the user to interactively define the area where a texture is applied.

6. A method for generating virtual scene texture, characterized in that: include: Receiving semantic text input by the user and positioning of a target area in the virtual scene at the local client; Sending the semantic text to a cloud server; Converting the semantic text into a feature vector through a semantic retrieval module; Matching similar texture bases in a texture database; The cloud server generates customized texture data and PBR parameters based on the texture base and UV parameters of the target area; The cloud server transmits the generated texture data and PBR parameters to the local client; The local client maps the texture data and PBR parameters to the target area in combination with scene lighting for real-time rendering.

7. A virtual scene texture generation method according to claim 6, characterized in that: Converting the semantic text into a feature vector by a semantic retrieval module includes: Mapping the semantic text and the texture image to the same feature space through the CLIP model; Calculating the cosine similarity between the semantic text and the texture image; The semantic text is matched to the texture basis according to the cosine similarity.

8. A virtual scene texture generation method according to claim 6, characterized in that: Before the cloud server generates customized texture data and PBR parameters based on the texture base and the UV parameters of the target area, the process further includes: Controlling the geometric mapping of texture generation using UV masks through the ControlNet model; The texture data is adapted to the shape of the target area.

9. A virtual scene texture generation method according to claim 6, characterized in that: The cloud server and the local client use the gRPC protocol and the WebP compression algorithm for data transmission.

10. The method for generating virtual scene texture according to claim 6, wherein: The local client performs PBR parameter fusion on the texture data before the real-time rendering; The local client calculates the reflection and shadow effects of the texture in real time in combination with the lighting probes in the scene.

Images