Scene visual effect interaction method and device, equipment and medium

Abstract

The invention relates to a scene visual effect interaction method and device, equipment and a medium. The method comprises the following steps: determining a target effect identifier corresponding to a visual effect updating event in response to the visual effect updating event triggered by a specific skill played by a player character in a current game scene; obtaining an effect identifier set which is currently in an effective state, and matching the effect identifier set with the target effect identifier based on a preset effect fusion rule, so as to generate corresponding rendering configuration information according to a matching result; and calling an effect rendering resource matched with the rendering configuration information so as to carry out real-time rendering on a specified scene environment of the game scene according to the effect rendering resource. According to the method and the device, the problems of disordered state management, huge rendering performance overhead and inconsistent visual performance of multiple clients during dynamic global environment effect superposition in the open world game are solved.

Description

Technical Field

[0001] This application relates to the field of game interaction technology, and in particular to a scene visual effects interaction method, device, equipment, and medium thereof. Background Technology

[0002] In current video game development, especially in large open-world games, to enhance user immersion, developers design character abilities or interactive events that dynamically change the overall visual environment of the virtual scene, such as the sky's appearance, global illumination, and atmospheric effects. A typical traditional implementation is that when such an ability or event is triggered, the game engine's rendering module directly receives the instruction and immediately replaces or interpolates the relevant environment textures and shader parameters to generate a new visual output. However, while this direct-driven traditional approach is relatively intuitive for implementing single visual changes, its technical principles have inherent limitations when dealing with dynamic interaction requirements.

[0003] First, when continuous or concurrent environmental modification requests occur in a scene, the contention of multiple requests for the same set of underlying rendering state variables can easily lead to chaos in state management. This can result in unexpected flickering, abrupt changes, or overlays in the final visual presentation, disrupting the coherence and controllability of the visual performance and making it difficult to stably implement complex pre-set visual narratives or feedback logic. On the other hand, in pursuit of high-quality visual changes, such as transforming high-resolution environment maps covering a large area of ​​the game scene and simultaneously adjusting multiple lighting and post-processing parameters, the process itself places a significant burden on the graphics system in terms of real-time computation and data throughput. Simply executing such operations directly can also easily cause frame rate fluctuations and increased input latency, thereby impairing the application's real-time interactive performance and smoothness.

[0004] This shows that the existing technology in the field of games for visual effects and interactive elements still needs further improvement. Summary of the Invention

[0005] The purpose of this application is to solve the above-mentioned problems by providing a scene visual effects interaction method and its corresponding device, equipment, non-volatile readable storage medium, and computer program product.

[0006] According to one aspect of this application, a scene visual effects interaction method is provided, comprising: In response to a visual effect update event triggered by a player character casting a specific skill in the current game scene, determine the target effect identifier corresponding to the visual effect update event; Obtain the set of effect identifiers that are currently in effect, and match the set of effect identifiers and the target effect identifiers based on preset effect fusion rules, so as to generate corresponding rendering configuration information according to the matching results; Invoke the effect rendering resource that matches the rendering configuration information, so as to render the specified scene environment of the game scene in real time according to the effect rendering resource.

[0007] According to another aspect of this application, a scene visual effects interactive device is provided, comprising: The event response module is set to respond to visual effect update events triggered by a player character casting a specific skill in the current game scene, and to determine the target effect identifier corresponding to the visual effect update event; The information matching module is configured to obtain a set of effect identifiers that are currently in effect, and match the set of effect identifiers and the target effect identifiers based on preset effect fusion rules, so as to generate corresponding rendering configuration information based on the matching results; The screen rendering module is configured to call effect rendering resources that match the rendering configuration information, so as to perform real-time rendering of the specified scene environment of the game scene according to the effect rendering resources.

[0008] According to another aspect of this application, a scene visual effects interactive device is provided, including a central processing unit and a memory, wherein the central processing unit is used to call and run a computer program stored in the memory to perform the steps of the method described in this application.

[0009] According to another aspect of this application, a non-volatile readable storage medium is provided, which stores a computer program implemented according to the scene visual effects interaction method in the form of computer-readable instructions, wherein the computer program, when invoked by a computer, executes the steps included in the method.

[0010] According to another aspect of this application, a computer program product is provided, comprising a computer program / instructions that, when executed by a processor, implement the steps of the method.

[0011] This application first introduces a state abstraction layer centered on effect identifiers and an effect fusion mechanism based on preset rules. This enables centralized coordination and unified judgment of multiple dynamic visual update requests that may occur in a game scene. When different visual effect update events triggered by character skills occur continuously or concurrently, this method generates unique and definite rendering configuration information by matching the currently effective set of effect identifiers with the target effect identifier according to predefined logical rules. This clearly specifies the final visual state that the scene environment should present at the next moment at the logical level. This avoids direct contention and disorderly overwriting of underlying rendering state variables by multiple events, and solves problems such as screen flickering, sudden changes, or visual logic contradictions caused by chaotic state management. It ensures the orderliness, coherence, and controllability of visual changes in complex environments in large-scale open worlds, and enables the stable and accurate realization of ingeniously designed visual narratives and multi-layered interactive feedback.

[0012] Secondly, this application improves the efficiency of graphics rendering and reduces system performance overhead by separating runtime logic decision-making from heavy rendering resource scheduling. After determining the final visual state, it does not need to perform high-consumption computational operations such as dynamically mixing multiple sets of high-resolution environment textures, interpolating complex global illumination parameters in real time, or regenerating atmospheric effects in real time. Instead, it directly calls the corresponding pre-prepared or optimized baked effect rendering resource package based on the generated rendering configuration information. This reduces the pixel filling burden, shader computational complexity, and memory bandwidth occupation in the real-time rendering pipeline, thereby effectively alleviating the frame rate fluctuation and input latency problems caused by directly driving high-quality, large-scale scene environment changes in the traditional method, and ensuring the smoothness of the game's operation and real-time interactive response capabilities under high visual fidelity.

[0013] Furthermore, the effect identification management and rule-driven framework constructed in this application also enhances the scalability and maintainability of the entire scene visual effects interaction system. Since the logical combination relationship of visual effects is abstracted into configurable fusion rules, and the specific presentation depends on the associated pre-rendered resources, when it is necessary to add skill effects or adjust the interaction behavior between visual effects, developers can mainly achieve this by updating the rule configuration and resource library without making in-depth modifications to the core rendering loop or event handling code. This data-driven design can reduce the coupling between modules, simplify the development iteration process, and provide flexible and robust technical support for the continuous enrichment and optimization of visual content in large-scale game projects. Attached Figure Description

[0014] Figure 1 This application provides an exemplary network architecture; Figure 2 This is a flowchart illustrating one embodiment of the scene visual effects interaction method of this application; Figure 3 This is a schematic diagram of the scene visual effects interactive device of this application; Figure 4 This is a schematic diagram of the structure of a scene visual effects interactive device used in this application. Detailed Implementation

[0015] The technical solution presented in this application can be deployed in various network architectures. Figure 1 An exemplary network architecture is illustrated. In this architecture, the player's client electronic device 80 connects to a service cluster 81 consisting of multiple server nodes via a network. This service cluster 81 can adopt a distributed or microservice architecture, where different service instances are responsible for the core logic and global state management of the virtual environment, respectively. It centrally stores and manages the relationships between effect identifiers, effect blending rules, and rendering configuration information used to define the visual performance of different scenes, forming a unified visual logic judgment and resource scheduling hub. When a visual effect update event reported by the client and triggered by the player character casting a specific skill is detected, the service cluster 81 matches and judges the currently effective set of effect identifiers with the target effect identifier corresponding to the event according to preset effect blending rules, generates definite rendering configuration information, and sends it to the relevant client electronic device 80. In addition, the service cluster 81 is also responsible for synchronizing the determined authoritative visual state to all clients in the same game scene, ensuring the consistency of the global scene environment performance in a distributed environment. The client electronic device 80 runs a computer program that implements the scene visual effects interaction method of this application. This program communicates with the service cluster 81 via a network. It is capable of rendering game scenes, generating graphical user interfaces, and receiving local input operations from players, and uploading these interactive instructions, such as skill casting, to the service cluster 81. Players can control their characters to cast specific skills in the game world by operating the input device, thereby triggering dynamic modification and interaction of the global visual state of the vast virtual environment.

[0016] The technical solution presented in this application can be deployed in various interactive application systems with dynamic scene environment rendering requirements, and is particularly suitable for scenarios such as large-scale open-world games, multiplayer online virtual platforms, and highly immersive simulation training environments. In a typical system architecture, it can be implemented collaboratively by a client and a server. The client is mainly responsible for presenting the graphical interface, processing user input commands, executing local rendering logic, and interacting with the graphics hardware of the user's device; the server is responsible for maintaining the global state of the virtual world, determining key game logic events, and ensuring the consistency and synchronization of key visual states among multiple clients. When a user performs a specific interactive operation in the virtual scene through their controlled player character, such as casting a skill with global visual impact, a complete processing flow from interactive event parsing to final screen update is triggered. This flow involves the collaborative work of multiple functional modules, including the game logic layer, resource management layer, and graphics rendering layer.

[0017] In one exemplary implementation framework of this application, the overall visual environment of the virtual scene, such as the sky appearance, atmospheric effects, and global illumination, can be defined and controlled through a series of configurable rendering parameters and resources. These visual configurations and resources can be organized and managed as data assets, making them independent of specific scene instances, thereby supporting flexible combination and reuse. When an interactive event occurs that may change the scene environment, the game system determines the visual state to be presented based on predefined logic, and then drives the rendering pipeline to call the corresponding resources and parameters, achieving efficient and dynamic updates to the specified scene environment.

[0018] To facilitate understanding of the subsequent implementation methods, the basic concepts involved in this application are briefly explained here. In this application, a visual effect update event can be triggered by a specific in-game interactive action, marking a request to modify the scene's visual environment; an effect identifier, as an abstract data representation, can be used to uniquely identify a specific, predefined scene visual state or effect combination; the effect blending rule defines how, when multiple visual modification requests coexist, a single visual state that should ultimately take effect is determined through predetermined logic to ensure the consistency of the image; rendering configuration information, as a bridge connecting logical determination and graphics rendering, carries the specific instructions or resource location information necessary to drive the rendering pipeline; the effect rendering resource is a pre-processed and optimized data set, containing textures, shader parameters, and lighting data required to achieve specific visual effects, and can be efficiently invoked through preloading and indexing mechanisms.

[0019] In one specific embodiment of this application, it can be applied to an open-world game framework supporting multiplayer cooperation. This game allows players to explore a vast map and interact with the environment and enemies using various character skills. The interactive gameplay described in this application can be integrated as an enhancement system into the aforementioned basic process. Within this framework, the game world possesses an adjustable sky system as a core environmental element. Players can control different player characters, each possessing unique skills that can influence the overall environment. For example, player character A can cast the skill "Wrath of the Sun," while another character B can cast the skill "Summoning the Moon." In the corresponding basic game interaction process, players can control their character alone to face challenges in the open world, or they can cooperate with other players, each controlling their own character, to face challenges together.

[0020] When player character A casts the "Wrath of the Sun" skill in the game scene, the client generates a "Blazing Sun" effect identifier bound to the skill and sends it to the game server as an environment update request. Upon receiving this, the server records the "Blazing Sun" identifier as an active state for the current area. Simultaneously, the server determines, according to predefined rules, that the sky state corresponding to the "Blazing Sun" identifier should be clear daylight. Subsequently, the server synchronizes this state determination result, such as a command pointing to "clear daylight" resources, to all player clients in that area. Upon receiving the command, each client can directly invoke a complete set of rendering resources pre-loaded into its local memory for the "clear daylight" state, including the corresponding skybox texture, sunlight parameters, and atmospheric colors. By having the graphics engine apply these resources, the entire game world's sky is then transformed into a bright daylight scene.

[0021] Subsequently, if another player, controlling character B, casts the "Summoning the Moon" skill at this time, the client will also generate a "Moonlight" effect marker and report it to the server. The server will then detect that a valid "Sunlight" marker already exists in the current area. The server will then determine the appropriate action based on preset combination rules. If the rules define that the coexistence of "Sunlight" and "Moonlight" markers should trigger a composite sky state called "Sun and Moon in Harmony," the server will update the current area's effective state to "Sun and Moon in Harmony" and broadcast this new state command to all clients. Each client, based on the "Sun and Moon in Harmony" command, will invoke a pre-made rendering resource package specifically designed for this composite scene. This resource package contains a complete set of parameters capable of simultaneously displaying the sun and moon and adjusting the light and shadow contrast to adapt to this special celestial phenomenon. Thus, the sky observed by all players will smoothly transition from a single daytime state to a spectacular sight where the sun and moon are clearly visible in the sky simultaneously. Therefore, by centrally managing an environment state machine based on effect identifiers on the server, the concurrent skill interaction behaviors of players can be transformed into a definite predefined sequence of environment states; the client, as an efficient presentation layer, precisely triggers pre-defined resource switching through state commands, thereby realizing the superposition and combination of complex environment effects and ensuring strict synchronization and high-performance operation of visual performance under the perspective of multiple players.

[0022] After providing a general overview of the exemplary network architecture and application scenarios of this application, as well as some basic concepts, the following will continue to describe several specific embodiments of this application.

[0023] Please see Figure 2 The scene visual effects interaction method of this application, in some embodiments, includes the following steps: Step S3100: In response to a visual effect update event triggered by a player character casting a specific skill in the current game scene, determine the target effect identifier corresponding to the visual effect update event.

[0024] During game operation, the game system continuously monitors the event flow of the game logic layer. When a player executes an operation command through an input device to control their character to cast a specific skill in the virtual game scene, the game logic module identifies the skill casting action and verifies its validity. After the skill is successfully cast, the logic module generates a structured data object, which can be configured as a visual effects update event. This event can be a specific technical signal containing information about the triggering source, such as the skill's unique identifier, the caster's character identifier, and the event's timestamp. The game system's event scheduler or message bus immediately captures this visual effects update event and routes it to the processing module specifically responsible for scene visual effects management, thus serving as a clear trigger condition for initiating the environment update process.

[0025] The process of determining the target effect identifier is a technical operation based on data querying and rule calculation. Upon receiving a visual effect update event, the visual effects management module first parses the event data packet to extract key information such as the skill ID of the cast skill. It then accesses a pre-configured data storage area, which maintains the association mapping between skill identifiers and visual effect identifiers. This mapping can be a hash table stored in memory or a database table loaded from a configuration file. By querying using the skill ID as the key, an initial effect identifier bound to that skill can be obtained. This initial effect identifier can be a string or an enumeration value, uniquely representing a preset visual state concept such as "clear daylight" or "storm approaching" within the system. The calculated or queried target effect identifier can then be stored in a designated memory variable or event context object to provide explicit data. As a key logical node in the entire visual effect update pipeline, it drives the corresponding resource matching and rendering configuration.

[0026] In one implementation, determining the target effect identifier requires logical calculation based on the real-time state of the current game scene. First, a series of dynamic scene state parameters need to be obtained from the game world state management system. These parameters include, but are not limited to, the virtual world's day / night cycle, the current state of the weather system, the specific geographical region code of the character, or the currently activated global game mode. The game system takes the initial effect identifier and these scene state parameters as input and feeds them into a preset parameter mapping rule engine. This rule engine consists of a series of conditional statements or a state transition matrix. For example, a rule can be defined as: if the initial effect identifier is "scorching sun" and the current scene state parameter indicates "night," then the output target effect identifier is corrected to "night and scorching sun."

[0027] In another implementation, the target effect identifier can also be determined by using a multidimensional lookup table, with the initial effect identifier and key scene state parameters as composite keys, to directly retrieve the corresponding target effect identifier. This ensures that the determined target effect identifier not only reflects the visual intent of the skill, but also fits into the current context of the game world, thus guaranteeing the rationality and consistency of the visual performance.

[0028] Step S3200: Obtain the set of effect identifiers that are currently in effect, and match the set of effect identifiers and the target effect identifiers based on the preset effect fusion rules, so as to generate corresponding rendering configuration information according to the matching results.

[0029] A container can be maintained in the game's memory to record all active visual effect identifiers within the current game scene. This container can be a list, a set, or an array, and its contents are authoritatively maintained by the service or module responsible for global state management. The data structure corresponding to this container can be viewed as a set of effect identifiers. Therefore, after determining the target effect identifier, to handle the relationship between this identifier and other active visual effects in the current environment, whenever a visual effect is activated—for example, through a previous skill cast—and begins to affect the scene, its corresponding unique identifier is added to this set. When the visual effect becomes invalid due to the end of its duration or being overridden by a higher-level rule, its identifier is removed from the set. By querying the state management module, a complete snapshot of the identifiers reflecting all active visual effects at the current moment—that is, the set of effect identifiers—can be obtained.

[0030] After obtaining the set of effect identifiers, the next step is to determine the interaction result between the new target effect identifier and the existing set based on a predefined logic, which is the preset effect fusion rule. The effect fusion rule mentioned in this application can solve the priority, coverage, and combination relationships when multiple visual effects are effective simultaneously. Its essence is a decision function or a query mapping table, which allows the current set of effect identifiers and the newly generated target effect identifiers to be used as input and submitted to the effect fusion rule for processing.

[0031] One approach is to use an effect fusion mapping table, a key-value data structure. The key can be a combined state key consisting of a set of effect identifiers and a target effect identifier. For example, it could be a string formed by sorting all identifiers in the set and concatenating them with the target identifier. The value is one or more result identifiers that should be output in this combined state, called the output effect identifier. By calculating the combination key of the current state and performing an exact lookup in the fusion mapping table, the matching result can be obtained. For example, if the effect identifier set contains "Blazing Sun" and the target effect identifier is "Bright Moon," the combination key can be constructed as "Blazing Sun" plus "Bright Moon," and a lookup in the table will yield the output effect identifier "Sun and Moon Shining Together."

[0032] Another approach is to implement the effect fusion rules as a rule engine. This engine consists of a series of conditional statements evaluated sequentially or by priority. Each rule checks whether the effect identifier set contains certain specific identifier combinations and whether the target effect identifier meets specific conditions. When all conditions are met, the rule is triggered and specifies an output effect identifier. For example, a rule could be defined as: if the effect identifier set contains identifier "A" and the target effect identifier is "B", then trigger and output identifier "C". By evaluating these rules sequentially, the identifier output by the first triggered rule becomes the matching result.

[0033] Therefore, the output effect identifier generated by the corresponding matching process is the logical code of the visual state that should ultimately be presented in the scene, determined after the fusion rules are applied. Based on this output effect identifier, the corresponding rendering configuration information can be generated. Rendering configuration information can refer to a set of specific data instructions or resource references that can be directly understood and executed by the graphics rendering pipeline. The process of generating rendering configuration information can be accomplished through a configuration mapping library. This library stores the association between each possible output effect identifier and its corresponding set of rendering parameters. These parameters may include the file path of the skybox cube map to be loaded, the intensity and color value of global illumination, the density and attenuation coefficient of fog effects, and the on / off state and intensity of post-processing effects, etc. Using the output effect identifier as an index, all relevant parameters are retrieved from this configuration mapping library and assembled into a structured data package. This data package is the rendering configuration information.

[0034] In one implementation, the rendering configuration information itself is a complex object containing resource pointers and parameter values, which can act as a bridge connecting logical state and graphics rendering to directly drive rendering resource calls and screen updates.

[0035] Step S3300: Call the effect rendering resource that matches the rendering configuration information, so as to render the specified scene environment of the game scene in real time according to the effect rendering resource.

[0036] Based on the rendering configuration information, the game system can then perform resource calls and graphics rendering accordingly. Since the rendering configuration information contains explicit resource location data or parameter instructions, this information must first be parsed to locate the specific effect rendering resources. Effect rendering resources can be a collection of digital assets that have been pre-made, optimized, and stored on storage media. Their content is specifically used to define and present a specific scene visual state. They may include, but are not limited to, cube map texture files for the skybox, a set of parameters defining fog density and color gradients, light source data controlling the direction and intensity of global illumination, and shader code and configuration parameters such as color correction and halo effects used to achieve specific post-processing effects. By using the resource identifier or file path provided in the rendering configuration information, a call request can be initiated to the resource management subsystem.

[0037] In one implementation, the effect rendering resources exist in the form of resource packages. The resource management subsystem searches for these packages in memory cache or local storage based on the requested identifier. If the resource package is not yet loaded into memory, a loading process is initiated to read the necessary texture data and configuration parameters from disk or network into a specific area of ​​memory, such as the video memory of the graphics processing unit, to ensure fast access. If the effect rendering resources are already in memory according to a preloading strategy, their address pointers or references in memory can be obtained directly. The invocation process is the formal association of these in-memory texture objects, parameter buffers, and other data with the current rendering task.

[0038] After acquiring the rendering resources, the game system also needs to apply these resources to the specified scene environment of the game scene. The specified scene environment mentioned in this application refers to the specific components in the virtual world that are affected by the global visual state. The most common ones are the sky and atmospheric system, whose visual representation is composed of elements such as skybox, ambient light, and fog effects. Real-time rendering means that the graphics rendering pipeline uses the latest resource data to calculate the pixel color when drawing the picture in each frame, so as to immediately reflect the changes on the picture. The game system can submit update instructions to the rendering pipeline through the graphics application programming interface.

[0039] In one implementation, the game system calls the graphics API to set the corresponding rendering state. For skybox updates, the newly called cubemap texture is bound to the corresponding texture sampler unit in the rendering pipeline, and uniform variables such as sky color and sun position in the shader can be updated simultaneously. For fog updates, parameters such as new fog density, start and end distances, and color are passed to the shader program or fixed rendering pipeline function responsible for calculating fog effects. For global illumination updates, the system can update the ambient light map in the scene or adjust the data of the environment probe, thereby ensuring that the rendering pipeline can use new resource data to calculate the appearance of the specified scene environment at the start of the next rendering loop.

[0040] In another implementation, the rendering configuration information can directly contain a complete set of rendering parameter values, rather than external resource references. In this case, the process of calling the effect rendering resources is manifested as generating or filling a parameter structure in memory according to the configuration information, and then setting the data of this structure directly into the various global constant buffers of the rendering pipeline through the graphics API. For example, according to the RGB value of "sky color" in the configuration information, the relevant interface is directly called to push the data to the computer's image processing chip.

[0041] Once all rendering states and resources related to the specified scene environment are bound, the rendering pipeline continues to execute subsequent drawing commands. During the process of drawing scene geometry, applying lighting models, and performing post-processing, the rendering pipeline automatically samples newly set skybox textures, adopts newly configured fog equations, and lighting parameters, thereby generating an updated overall scene visual environment that meets the requirements in real time on the output screen. In actual development, the corresponding game scene update can be completed within one frame of the game, thus achieving smooth and instantaneous switching of visual effects. Furthermore, by directly applying pre-built resources, it avoids expensive real-time hybrid computations at runtime.

[0042] As can be seen from the above embodiments, the technical solution of this application can constitute an efficient and controllable scene visual effect interaction process. By introducing an effect identifier abstraction layer and a rule-driven fusion judgment mechanism, it effectively solves the state management problem when multiple dynamic visual modification requests are concurrent. This application maps skill trigger events to logical identifiers and arbitrates the current effective identifier set and target identifiers according to preset rules to generate a unique and definite rendering configuration. This avoids direct contention and disordered overwriting of the underlying rendering state by multiple events, ensuring the continuity of the screen and the consistency of visual logic when complex visual effects are superimposed. Furthermore, this application can decouple runtime logical judgment from heavy graphics calculations, and directly call pre-made effect rendering resources according to the final configuration. It does not need to mix multiple sets of high-resolution environment textures or interpolate complex lighting parameters in real time at runtime. This significantly reduces the real-time computing load and memory bandwidth pressure of the graphics processing unit, and ensures the smoothness and frame rate stability of the application while achieving high-quality and large-scale dynamic changes in the scene environment.

[0043] Based on any embodiment of the method in this application, in response to a visual effect update event triggered by a player character casting a specific skill in the current game scene, the target effect identifier corresponding to the visual effect update event is determined, including: Step S3110: When the visual effect update event is detected to be triggered, the visual effect update data associated with the specific skill cast by the player character is obtained.

[0044] In this embodiment, the triggering of a visual effect update event can begin with a player action recognized as valid by the game rules. Specifically, this can be manifested as the player successfully driving the virtual character they control to complete a predefined and currently executable skill action by clicking the mouse, touching the screen, or pressing a specific keyboard key in the graphical user interface. When the skill animation starts playing, the resources consumed by the skill are deducted, and the system interface displays visual feedback that the skill has entered the cooldown period, this operation can constitute a clear event triggering condition.

[0045] At this point, the game client's input processing module and logic layer work together to transform this front-end interaction into a precise internal event. The logic layer first verifies the legality of the operation, confirming the successful skill casting. Then, it instantiates a data structure—the visual effects update data. This visual effects update data is generated through a query process. The game system uses the globally unique identifier of the cast skill as the key to retrieve data from a configuration table loaded into memory during game initialization. This configuration table, pre-exported by the game development tools, strictly defines a series of visual effect parameters associated with each skill identifier. The query result is a complete data object containing fields such as effect identifier, duration, and intensity level. The backend system obtains this structured object already populated with specific values ​​and immediately uses it as the core payload of the visual effects update event, passing it to the corresponding processing module responsible for environment management.

[0046] Step S3120: Obtain the pre-configured initial effect identifier contained in the visual effect update data, and determine the target effect identifier based on the initial effect identifier and the scene state parameters associated with the current game scene.

[0047] After receiving the visual effects update data, the game system parses out a field called the pre-configured initial effect identifier. This identifier can be a symbol determined and written into the configuration during the game resource compilation stage. It is directly associated with the core visual theme that the skill is expected to express, such as "sunny daytime" or "rainy weather." The game system can directly read this identifier string by accessing the corresponding property of the data object. The process of determining the target effect identifier can incorporate consideration of the current operating environment of the game world. The game system synchronously obtains a set of real-time changing scene state parameters from the global state manager. These parameters are environmental variables that exist independently of skill release, such as whether it is currently nighttime calculated based on the in-game simulated time, or whether there is rain or snow as determined by the world weather controller.

[0048] The game system then executes a matching and decision-making logic, implemented by a parameter mapping rule module. This module takes as input an initial effect identifier and a set of scene state parameters as input, and outputs a context-adapted target effect identifier. One implementation could be a multi-layered conditional decision tree. First, the initial effect identifier is checked. Then, based on different identifier branches, specific scene parameter conditions are verified. For example, if the initial effect identifier is "desert," the decision tree outputs a target identifier of "sandstorm"; if the parameter value is "plain," the target identifier is output as the corresponding "plain rainstorm."

[0049] Another implementation method uses a composite key lookup table. The game system concatenates the initial effect identifier with the key scene state parameter value to form a lookup key, and then looks up the key in a pre-loaded transformation table that stores the corresponding target effect identifier. In this way, a general visual intention can be efficiently transformed into a specific visual state instruction that accurately fits the current game world situation, thereby ensuring the rationality of environmental changes and immersion.

[0050] Through the above implementation methods, this application can establish a structured data transmission and decision-making mechanism, transforming front-end player interaction behaviors into precise and context-aware visual control commands. By obtaining structured visual effect update data from a pre-configuration table, it ensures that the data source for skill visual performance has high configurability and consistency, avoiding the maintenance difficulties caused by hard-coded logic. Furthermore, by combining the inherent initial effect identifier of a skill with real-time dynamic scene state parameters, and making intelligent decisions through parameter mapping rules, this application can generate the most reasonable target effect identifier for the same skill under different environmental conditions. This not only improves the accuracy and immersion of visual feedback, but also ensures the rationality of environmental changes from the logical source, preventing contradictions between visual performance and the game world state, and providing reliable and semantically clear input for corresponding fusion judgment and rendering scheduling.

[0051] Based on any embodiment of the method in this application, the target effect identifier is determined according to the initial effect identifier and scene state parameters associated with the current game scene, including: Step S3210: Based on the triggering of the visual effect update event, obtain at least one of the scene state parameters in the current game scene in real time.

[0052] Simultaneously with the visual effects update event, the game system initiates a parallel data acquisition process to capture a snapshot of the game world's environment at that moment. The core of this process is the real-time acquisition of one or more scene state parameters. These parameters are dynamic variables, independent of player skills and continuously maintained by the game world simulation engine. These parameters can be obtained by accessing a dedicated environment state service. This service acts as a central data source, continuously integrating outputs from various simulation systems within the game. For example, the game's time system calculates the current virtual clock every frame and provides it as a floating-point parameter; the weather simulation module encodes the current weather conditions into an enumeration value; and the geomanagement system determines the player character's location within a predefined area based on their coordinates and returns a corresponding string.

[0053] The corresponding technical path for obtaining these parameters can be either a direct function call, whereby the module handling visual effect update events directly initiates a synchronization request to the aforementioned environment state service when it needs scene state parameters, and the service interface then returns the current value of the requested parameter; or it can be based on event subscription, where the environment state service actively broadcasts events when its internal data changes, such as during day-night cycles or sudden weather changes. The visual effects management module subscribes to these events during initialization and caches the latest parameter values ​​in local memory. When a visual effect update event is triggered, it directly reads the instantaneous value of the required parameter from the cache to reduce the corresponding read latency.

[0054] Thus, the game system can obtain a set of accurate data describing the macro state of the game world within the same logical frame when a skill is triggered. These parameters will become the key basis for contextualizing and arbitrating the visual intent of the skill in subsequent steps, ensuring that the generated visual changes are synchronized with the operating logic of the world.

[0055] Step S3220: Match and map the initial effect identifier with at least one scene state parameter according to the preset parameter mapping rules, so as to obtain the corresponding target effect identifier based on the mapping result.

[0056] After obtaining the initial effect identifier and real-time scene state parameters, a crucial transformation step is required: combining the two according to a set of pre-defined deterministic logic to generate the final target effect identifier guiding rendering. This process can be handled by a separate parameter mapping rule module. This module encapsulates all the business logic regarding how visual representation adapts to the environmental state. Its operation can be understood as a state transition function that takes the initial effect identifier and scene state parameters as input, calculates a target effect identifier based on internal rules, and outputs the target effect identifier. These rules are defined during the game development phase.

[0057] One specific implementation involves iterating through a list of rules. This is achieved by maintaining an ordered set of rules, each containing a conditional statement and a result. The conditional statement checks whether the initial effect identifier equals a certain value and whether one or more scene state parameters meet a specific range. The game system sequentially compares the currently input identifier and parameters with the conditions of each rule. It stops iterating when it finds the first rule that perfectly matches, and outputs the effect identifier indicated by the result. For example, a rule could be: if the initial identifier is "scorching sun" and the "time" parameter is greater than 18.0, indicating it's evening, then the target identifier would be "sunset." Another implementation relies on a pre-compiled mapping data structure, such as a nested dictionary or hash table. It uses the initial effect identifier as the first-level key to retrieve a sub-dictionary, and a scene state parameter (e.g., a weather code) as the second-level key to directly extract the target effect identifier. This transforms logical judgments into one or more efficient data structure accesses, making it particularly suitable for situations where parameter combinations are relatively fixed and execution speed does not increase linearly with the number of rules. This results in a clear and unique target effect identifier. This identifier is no longer the original visual concept of the skill itself, but the visual state code that is most suitable for presentation in the current frame after being corrected by the environmental context, thus ensuring the intelligence and consistency of environmental changes.

[0058] The above embodiments, by acquiring dynamic scene state parameters in real time and mapping them to generate target effect identifiers, add crucial context awareness to the core environment state determination mechanism. This helps resolve visual logic contradictions and visual chaos caused by the disconnect between environmental change requests and the current world state. By synchronizing data from the world simulation engine, this embodiment ensures that the visual effect intent of each skill trigger is instantly verified and calibrated against the current environmental context. This avoids conflicts between visual presentation and the game world's fundamental rules, thus transforming the complex state management requirements of the open world into a real-time reading of a set of lightweight parameters and a deterministic rule matching. This replaces the heavy calculations that might have required complex conditional branch judgments or real-time physics simulations, achieving intelligent and reasonable visual effect switching while maintaining the overall rendering efficiency and stability of the game system.

[0059] Based on any embodiment of the method in this application, a set of effect identifiers that are currently in effect is obtained, and the set of effect identifiers and the target effect identifiers are matched according to a preset effect fusion rule to generate corresponding rendering configuration information based on the matching result, including: Step S3310: Combine the effect identifier set and the target effect identifier into a combined status key, and query the effect fusion mapping table corresponding to the effect fusion rule using the combined status key as the query key. The effect fusion mapping table includes the mapping relationship between the combined status key and its corresponding output effect identifier.

[0060] In this embodiment, the effect identifier set, as a data structure, can be used to record the codes of all visual effects that have been activated and are continuously effective in the current game scene. For example, if the two identifiers of gale and drizzle generated by the player character releasing a skill exist at the same time, they will constitute the current set; while the target effect identifier is the code of the visual effect that is determined by the skill that has just been triggered and is expected to be applied to the scene in the next step.

[0061] Combining these two elements into a composite status key creates a unique and unambiguous index that describes the relationship between all currently active visual effects and newly triggered requests. A specific method involves sorting all identifiers in the effect identifier set according to a predetermined rule, such as alphabetical order, to form an ordered list string. This list string is then concatenated with the target effect identifier string using a specific delimiter. For example, if the current set contains "Gale" and "Rain," and the target effect identifier is "Thunder," the sorted set string would be "Gale, Rain." After concatenation with the target effect identifier, the resulting composite status key would be "Gale, Rain + Thunder." Therefore, this composite status key serves as an index string for precise lookup.

[0062] The effect fusion mapping table is a concrete and efficient data-driven implementation of preset effect fusion rules. Essentially, it's a lookup table stored in memory, whose contents are predefined and populated according to the design logic during game development. Each record in the table clearly defines a mapping relationship: the left side is the combination state key, and the right side is the unique output effect identifier corresponding to that combination. This table directly reflects the effect fusion rules. For example, logic such as "when A and B coexist, effect C should be displayed" is represented in the table as a record with the key "A,B" or "B,A" and the value "C".

[0063] When performing a query, the previously generated combined state key can be used as the query key to directly perform a lookup operation on the effect blending mapping table. This process is equivalent to looking up the definition of a complete word in a dictionary. The system inputs this string key into the data interface of the mapping table, and the mapping table returns the output effect identifier string that is exactly associated with that key. If a corresponding entry is found, the output identifier is the final visual state after rule-based judgment; if not found, a default processing flow can be triggered, such as directly using the target effect identifier or keeping the existing state unchanged.

[0064] Step S3320: Use the output effect identifier obtained from the query as the matching result, and generate the rendering configuration information based on the matching result.

[0065] The game system can perform a query operation in the effect fusion mapping table by combining status keys. This operation is essentially a retrieval in a hash data structure based on a specific string key. After receiving the key, the mapping table searches for the key name that is exactly the same in its internal entries and returns the stored value associated with that key name, i.e., the output effect identifier, as the result. This output effect identifier is the required matching result.

[0066] Once the matching result of the output effect identifier is obtained, the rendering configuration information can be generated based on this. The generation process is a data conversion and assembly operation. The game system maintains an independent rendering configuration database, which stores a complete set of specific parameters required to drive rendering for each valid output effect identifier. By sending a request to the database using the obtained output effect identifier as an index, the database returns a structured data block, which is the rendering configuration information. Its content is directly related to the interface requirements of the graphics rendering pipeline.

[0067] In one implementation, the data block contains a series of direct instructions and references. It may include a file path string pointing to a specific skybox texture set on disk, a set of RGB floating-point numbers for setting the ambient light color, a floating-point parameter controlling the fog density, and a Boolean flag indicating whether a specific post-processing screen effect is enabled. When generating rendering configuration information, these predefined parameter values ​​stored as is in the database are retrieved and encapsulated into a rendering instruction object. This object is the final carrier connecting the logic decision layer and the graphics execution layer, enabling an abstract identifier to be transformed into a set of specific numerical values ​​and resource addresses that the graphics processor can directly understand and execute to draw the corresponding celestial phenomena.

[0068] The synergistic effect of the above embodiments integrates all currently active visual effect identifiers and newly triggered target identifiers into a unique combined state key, and uses a pre-built effect fusion mapping table for a one-time query to obtain the corresponding matching result. This solves the management chaos and screen flickering problems caused by multiple environment modification requests directly competing for the underlying rendering state. Specifically, by replacing real-time logical judgment with table lookup, it can ensure the determinism and consistency of the visual output state under any concurrent conditions, and achieve stable and controllable complex visual effect overlay. At the same time, this embodiment can transform the runtime effect fusion decision into a high-efficiency memory query operation, and directly associate the query result with the pre-built rendering configuration. This avoids the real-time high-consumption graphics resource mixing calculation for processing effect overlay, reduces the system rendering load, and alleviates frame rate fluctuations and latency while ensuring the accuracy of visual performance.

[0069] Based on any embodiment of the method in this application, an effect rendering resource matching the rendering configuration information is invoked to perform real-time rendering of a specified scene environment of the game scene according to the effect rendering resource, including: Step S3410: Based on the output effect identifier contained in the rendering configuration information, query the corresponding rendering resource storage address from the preset rendering resource index, and obtain the rendering resource data block based on the rendering resource storage address, wherein the rendering resource data block contains a set of pre-loaded pre-configured rendering parameters.

[0070] In this implementation, the output effect identifier in the rendering configuration information is the sole basis for locating specific graphic assets. The game system maintains a preset rendering resource index, which is a lookup table established when the application starts or the scene loads. This index records the correspondence between each valid output effect identifier and one or more specific resource storage locations. This index can be in the form of a key-value database, where the key is the output effect identifier string and the value is the corresponding resource storage address. The resource storage address can be a pointer or offset to a loaded resource package in memory, or it can be a path string in the file system to a specific resource file, such as an asset package containing textures and parameters.

[0071] When performing a query, a request is sent to the rendering resource index using the output effect identifier in the rendering configuration information as the input key. The index service can then match the key and return the strictly associated rendering resource storage address. If the address is a memory pointer, it can be accessed directly; if it is a file path, the file must be read through the file I / O interface. Based on the obtained rendering resource storage address, a retrieval operation can be performed to obtain the complete rendering resource data block. If the resource is already resident in memory according to the preloading strategy, this operation retrieves the corresponding data block object from the memory pool based on the address. If the resource has not yet been loaded, a synchronous or asynchronous loading process will be initiated based on the file path to read the file content from the storage medium into memory, parse its format, and convert it into a structured data block that can be understood by the rendering pipeline. This data block is the rendering resource data block, which is a data set containing all the pre-configured rendering parameters necessary to achieve the visual effect.

[0072] In one implementation, pre-configured rendering parameters can be a set of values ​​and instructions pre-processed by the developers. These parameters are organized within the data block and directly correspond to various controllable variables of the graphics rendering engine. Examples include image data of six textures for a replacement skybox, a set of three-dimensional vectors for adjusting ambient light color and intensity, floating-point numbers controlling fog initiation distance and density, and switches and parameters determining whether specific post-processing effects such as color correction or depth of field are enabled and their intensity. All these parameters are stored in the data block in a format that the rendering engine can directly consume, such as binary blocks or serialized data structures, without requiring any runtime generation or calculation, thus enabling extremely rapid delivery of rendering instructions.

[0073] Step S3420: Submit the rendering parameters contained in the rendering resource data block to the environment configuration interface of the graphics rendering pipeline to drive the interface to draw the rendering state of the specified scene environment in real time.

[0074] The graphics rendering pipeline in this application is a standardized process of hardware and software working together. It is responsible for synthesizing 3D scene data and associated visual parameters into a 2D pixel image on the screen. In the game engine, it consists of a series of programmable shader stages and fixed functional units. It has an application programming interface for upper-level logic to call. The environment configuration interface is a set of specific functions or data channels used to control the global scene visual performance.

[0075] After acquiring rendering resource data blocks, the game system needs to pass the pre-configured rendering parameters encapsulated within them to the rendering pipeline. This submission process is accomplished by calling the graphics API or the encapsulated interfaces provided by the engine. The game system iterates through each parameter segment in the data block and precisely sets it to the corresponding state of the pipeline based on the type and semantics of each parameter. The driver interface's real-time rendering of the specified scene environment means that after the system completes the above parameter submission, the rendering pipeline immediately performs rendering calculations based on these newly set states. In the next frame or subsequent rendering passes of the current frame, when the pipeline executes rendering instructions related to the scene environment, such as drawing the geometry of the skybox or calculating the ambient lighting contribution of each pixel, it will automatically use the newly submitted textures, color values, and fog effect equations for calculation. This process drives the real-time update of the screen content.

[0076] In one implementation, after submitting a "starry sky" texture and corresponding dark blue ambient light parameters, the pipeline samples the new starry sky texture and uses the new ambient light value to color scene objects when drawing the sky, thereby presenting the transition from daytime to starry night in real time on the screen. The entire submission and driving process is deterministic and directly controlled by the data block content, thus ensuring the accuracy and real-time nature of the visual changes.

[0077] Through the above embodiments and steps of this application, the system establishes an efficient and deterministic rendering resource delivery mechanism, directly alleviating the performance burden problem caused by directly driving high-quality environment transformations in the background technology. This method, through pre-set indexes and data blocks, transforms the runtime graphics resource preparation process into direct addressing of memory addresses and data copying, completely avoiding the heavy computations such as real-time texture blending and parameter interpolation required to generate new visual effects. This significantly reduces the instantaneous load and memory bandwidth pressure on the graphics processing unit, thereby effectively suppressing frame rate fluctuations. Simultaneously, the atomic submission of encapsulated rendering parameters to the rendering pipeline interface ensures the integrity and consistency of environment state updates, eliminates potential screen anomalies caused by multiple rendering command intersections or resource contention, and guarantees the smoothness and stability of scene environment switching under high visual fidelity.

[0078] Based on any embodiment of the method in this application, prior to the step of responding to a visual effect update event triggered by a player character casting a specific skill in the current game scene, the method further includes: Step S3510: Based on the player character information configured by the user in the current game scene, preload multiple effect rendering resource packages associated with the player character information to local memory, wherein the player character information includes skill information corresponding to a specific skill that can trigger the visual effect update event.

[0079] Based on the user's configuration actions before entering the game scene or when adjusting character formation, the game system acquires and parses the player's character information. This information is a structured dataset that records the specific list of virtual characters selected and enabled by the user in the current game scene or team, as well as the static attributes and dynamic skill configurations associated with each character. For example, in a team formation interface, if the user selects character A, character B, and character C from the character library to form a team, this selection result is recorded by the system as the current player's character information. The game system then performs a deep scan of this information, paying particular attention to the skill list possessed by each character, and identifying those specific skills marked as capable of triggering visual effect update events, such as character A's skill A and character C's skill C. The configuration data corresponding to these skills, such as skill IDs and effect identifiers, can serve as a key basis for resource processing.

[0080] Once a relevant skill is identified, a resource preloading process is initiated. For each identified specific skill, the game system uses its configuration data to locate one or more pre-made and packaged effect rendering resource packs. These resource packs can be independent asset files stored in the game's installation directory. Each file encapsulates all the data required to achieve the corresponding visual effect, such as specific skybox texture sets, global illumination parameters, fog simulation data, and possible particle effect references. Based on the resource pack's identifier, its physical storage path is located in the game's resource index. Then, an asynchronous loading thread is scheduled to read these resource packs from the hard drive or solid-state drive into video memory or high-speed system memory. For example, the resource pack loaded for skill A might contain a set of six sky textures representing a clear morning light and a parameter block defining warm-toned lighting; the resource pack loaded for skill C would contain a night sky texture and shader parameters for twinkling starlight.

[0081] The preloading process can occur before actual gameplay or scene interaction begins, such as during loading screens, after character selection confirmation, or during scene transitions. Its direct purpose is to pre-place frequently used heavy graphics resources in fast-access memory areas, thereby avoiding screen stuttering or frame rate drops caused by waiting for disk I / O when skills are cast or when visual effects need to be switched instantly. After loading, the game system establishes and maintains an internal mapping table in memory, associating the unique identifier of a skill or its corresponding output effect identifier with the starting address or reference handle of these loaded resource packages in memory, laying the foundation for possible instant resource call needs.

[0082] Step S3520: Establish an index relationship between the output effect identifier associated with the skill information and the storage address of the effect rendering resource package in local memory, so as to obtain the rendering parameters corresponding to the resource package.

[0083] After preloading the effect rendering resource package, a fast lookup table can be built in memory to achieve instantaneous location from logical identifiers to physical resources; this process is called establishing an index relationship. The game system can extract the final associated output effect identifier for each specific skill from the loaded skill configuration information. This output effect identifier is a code representing the final visual state that may be generated after the effect fusion rules are determined. For example, after all rules are determined, the output effect identifier corresponding to skill A can be defined as a1. Simultaneously, the system obtains the starting storage address of the effect rendering resource package corresponding to the skill after it has been loaded into local memory from the resource manager. This address can be a pointer or a handle to a memory pool.

[0084] Once the index is built, when subsequent rendering processes need to retrieve rendering parameters corresponding to a specific output effect identifier, they only need to send a single query to the index manager. The index manager uses the same identifier string as the query key, performs a lookup in the hash map, and returns the previously registered memory address. This address allows direct access to the ready-to-use rendering resource data block in memory, from which all pre-configured rendering parameters such as textures, colors, and intensities can be read, thus completing a zero-latency conversion from abstract identifiers to concrete rendering data. Furthermore, the entire index building and querying process can be independent of the real-time rendering loop, providing underlying data access guarantees for instant screen transitions.

[0085] In one implementation, creating an index can involve registering a key-value pair record with a global index manager. During registration, the string representing the output effect is used as the key, and the aforementioned memory starting address is used as the value to perform an insertion operation. Furthermore, before registration, it is necessary to verify the validity of the resource address and handle exceptions such as key name conflicts.

[0086] The embodiments described above, by placing potentially heavy graphics resources in fast memory before interaction occurs and establishing an efficient address lookup table, can better solve the significant performance overhead caused by real-time replacement or computational environment effects. By moving resource loading operations from the critical rendering moment to the preparation stage, it avoids screen stuttering and frame rate drops caused by waiting for disk input / output during skill triggering. Simultaneously, the precise indexing relationship established in this embodiment allows the rendering pipeline to directly obtain parameters through a single memory address when needed, avoiding the computational overhead of real-time resource parsing and location, ensuring the instantaneity and smoothness of complex visual effect switching, and further improving the game system's response speed and operating efficiency from a resource scheduling perspective.

[0087] Based on any embodiment of the method in this application, after the step of real-time rendering of the specified scene environment of the game scene according to the effect rendering resource, the method further includes: Step S3610: Encapsulate the output effect identifier corresponding to the matching result and its associated rendering configuration information into state synchronization information, and send the state synchronization information to the game server.

[0088] In this embodiment, after the game system obtains the matching result used to match the rendering configuration information, it will package the corresponding output effect identifier and rendering configuration information and send them to the server. The output effect identifier is the code that defines the final visual state, such as a string that represents the skybox of the game scene being updated to the "sun and moon shining together" state; while the rendering configuration information is a data set containing specific rendering instructions, such as the skybox texture number and light source brightness parameters.

[0089] The encapsulation process involves creating a state synchronization message corresponding to a network message packet that conforms to a predetermined format. The game system creates a new message structure containing standard header fields such as message type and timestamp, as well as a content body to carry the specific data. The string representing the output effect is directly filled into a designated field of the content body. Simultaneously, the structured rendering configuration information is serialized, converting it into a continuous byte stream. This converted byte stream is then filled into another designated field of the content body. Thus, the corresponding logical identifier and rendering parameters are integrated into a single, complete state synchronization message entity. Finally, this prepared state synchronization message is sent to the game server's network address via the underlying network transmission module, completing the client's authoritative state reporting.

[0090] Step S3620: The game client receives the rendering synchronization instruction sent by the game server based on the status synchronization information, so that the game client calls the corresponding effect rendering resource package pre-loaded locally to perform real-time rendering of the specified scene environment based on the rendering synchronization instruction, wherein the game client is the client corresponding to the online player character in the current game scene.

[0091] Because while one user is controlling a player character in the game, other real users may also be controlling corresponding player characters within their respective game clients, playing in the same game scene, when one user's character triggers a rendering update event that requires synchronous updates to a specific scene environment, the rendering synchronization command corresponding to this state synchronization information needs to be quickly received and responded to by the game clients of other users in the same game scene. Other game clients in the current game scene can refer to all player terminal devices connected to the same game server via the network and interacting within the same virtual area. These devices run the same game client program. When the game server receives state synchronization information from one client, it verifies and forwards it, broadcasting it to all relevant other clients.

[0092] Meanwhile, other game clients on the same game server will receive network packets from the game server in real time through their continuously running network listening modules. When a data packet marked as a rendering synchronization instruction corresponding to the state synchronization information is received, the client's network layer will unpack and verify it to confirm that its source is legitimate and the sequence is correct. Subsequently, the instruction will be delivered to the client's main game logic thread or a dedicated event handling queue.

[0093] The response process begins with parsing the rendering synchronization command. The client extracts two key pieces of information from the data body associated with the command: an output effect identifier, a string code representing visual states such as the sun and moon shining together; and a serialized rendering configuration information byte stream. The client deserializes this byte stream to restore a structured rendering configuration information object, containing specific values ​​such as texture indexes and lighting parameters. Next, based on the parsed output effect identifier, the client searches its local memory for a matching, pre-loaded effect rendering resource package. This search is accomplished by querying established local index relationships, quickly locating the resource package's memory location. The client can then retrieve all necessary pre-configured rendering parameters from this resource package. Finally, the client immediately drives its graphics rendering pipeline to submit the acquired rendering parameters to environment configuration interfaces such as sky, lighting, and fog. In the next frame's rendering cycle, the pipeline uses these new resources and parameters to render the environment of the entire scene, ensuring that the specified scene environment displayed on the client's screen is completely consistent with the visual effect seen by the client that initially triggered the skill, achieving real-time screen synchronization between multiple clients.

[0094] Through the aforementioned state synchronization and response mechanism, this application effectively solves the problem of inconsistent visual performance that may be caused by changes in the independent computing environment of multiple clients. By determining and broadcasting the final visual state on the server side, it ensures that the global effects such as the sky and atmosphere observed by all players are strictly synchronized, avoiding visual contradictions and disjointedness that may be caused by network latency or local computing differences. At the same time, this embodiment compresses the amount of data that needs to be synchronized into lightweight state identifiers and configuration parameters, and performs actual rendering through resource packages pre-loaded locally on each client. This avoids the huge network bandwidth pressure caused by real-time transmission of massive texture or graphics data, thereby maintaining a high degree of consistency in visual performance in multi-player scenarios while also ensuring the overall system's operating efficiency and scalability.

[0095] Please see Figure 3 According to one aspect of this application, a scene visual effects interaction device includes an event response module 4100, an information matching module 4200, and a screen rendering module 4300. The event response module 4100 is configured to respond to a visual effects update event triggered by a player character casting a specific skill in the current game scene, and determine the target effect identifier corresponding to the visual effects update event. The information matching module 4200 is configured to obtain a set of effect identifiers currently in effect, and match the set of effect identifiers with the target effect identifier based on a preset effect fusion rule, so as to generate corresponding rendering configuration information based on the matching result. The screen rendering module 4300 is configured to call an effect rendering resource that matches the rendering configuration information, so as to perform real-time rendering of a specified scene environment of the game scene based on the effect rendering resource.

[0096] Based on any embodiment of the device in this application, the event response module 4100 includes: a data acquisition unit, configured to acquire visual effect update data associated with a specific skill cast by the player character when the visual effect update event is detected; and an identifier determination unit, configured to acquire a pre-configured initial effect identifier contained in the visual effect update data, and determine the target effect identifier based on the initial effect identifier and scene state parameters associated with the current game scene.

[0097] Based on any embodiment of the device in this application, the identifier determination unit includes: a parameter acquisition subunit, configured to acquire at least one scene state parameter in the current game scene in real time based on the triggering of the visual effect update event; and a matching mapping subunit, configured to match and map the initial effect identifier with at least one scene state parameter according to a preset parameter mapping rule, so as to obtain the corresponding target effect identifier based on the mapping result.

[0098] Based on any embodiment of the device in this application, the information matching module 4200 includes: a mapping query unit, configured to combine the effect identifier set and the target effect identifier into a combined status key, and query the effect fusion mapping table corresponding to the effect fusion rule using the combined status key as the query key, wherein the effect fusion mapping table includes the mapping relationship between the combined status key and its corresponding output effect identifier; and an information generation unit, configured to use the query-obtained output effect identifier as the matching result, and generate the rendering configuration information based on the matching result.

[0099] Based on any embodiment of the device in this application, the screen rendering module 4300 includes: a data block acquisition unit, configured to query and obtain the corresponding rendering resource storage address from a preset rendering resource index according to the output effect identifier contained in the rendering configuration information, and acquire a rendering resource data block based on the rendering resource storage address, wherein the rendering resource data block contains a set of pre-loaded pre-configured rendering parameters; and a parameter submission unit, configured to submit the rendering parameters contained in the rendering resource data block to the environment configuration interface of the graphics rendering pipeline to drive the interface to draw the rendering state of the specified scene environment in real time.

[0100] Based on any embodiment of the device in this application, it further includes: a resource preloading module, configured to preload multiple effect rendering resource packages associated with the player character information configured by the user in the current game scene to local memory, wherein the player character information includes skill information corresponding to a specific skill that can trigger the visual effect update event; and an index building module, configured to establish an index relationship between the output effect identifier associated with the skill information and the storage address of the effect rendering resource package in local memory, so as to obtain the rendering parameters corresponding to the resource package.

[0101] Based on any embodiment of the device in this application, it further includes: an information encapsulation module, configured to encapsulate the output effect identifier corresponding to the matching result and the rendering configuration information associated therewith into state synchronization information, so as to send the state synchronization information to the game server; and a synchronous rendering module, configured to have the game client receive the rendering synchronization instruction sent by the game server based on the state synchronization information, so that the game client calls the corresponding effect rendering resource package pre-loaded locally to perform real-time rendering of the specified scene environment based on the rendering synchronization instruction, wherein the game client is the client corresponding to the online player character in the current game scene.

[0102] Another embodiment of this application also provides a scene visual effects interactive device. For example... Figure 4The diagram shows the internal structure of a scene visual effects interaction device. This device includes a processor, a computer-readable storage medium, a memory, and a network interface connected via a system bus. The computer-readable, non-volatile storage medium stores an operating system, a database, and computer-readable instructions. The database stores information sequences, and when executed by the processor, these computer-readable instructions enable the processor to implement a scene visual effects interaction method.

[0103] The processor of this scene visual effects interaction device provides computing and control capabilities to support the operation of the entire device. The memory of the device can store computer-readable instructions, which, when executed by the processor, cause the processor to perform the scene visual effects interaction method of this application. The network interface of the device is used for communication with a terminal.

[0104] Those skilled in the art will understand that Figure 4 The structure shown is merely a block diagram of a portion of the structure related to the solution of this application, and does not constitute a limitation on the scene visual effect interaction device to which the solution of this application is applied. The specific scene visual effect interaction device may include more or fewer components than shown in the figure, or combine certain components, or have different component arrangements.

[0105] In this embodiment, the processor is used to execute... Figure 3 The specific functions of each module are described, and the memory stores the program code and various data required to execute the above modules or sub-modules. The network interface is used to realize data transmission between user terminals or servers. In this embodiment, the non-volatile readable storage medium stores the program code and data required to execute all modules in the scene visual effects interaction device of this application, and the server can call the server's program code and data to execute the functions of all modules.

[0106] This application also provides a non-volatile readable storage medium storing computer-readable instructions, which, when executed by one or more processors, cause the one or more processors to perform the steps of the scene visual interaction method of any embodiment of this application.

[0107] This application also provides a computer program product, including a computer program / instructions that, when executed by one or more processors, implement the steps of the method described in any embodiment of this application.

[0108] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments of this application can be implemented by a computer program instructing related hardware. This computer program can be stored in a non-volatile readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The aforementioned storage medium can be a computer-readable storage medium such as a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM).

Claims

1. A method for scene visual effects interaction, characterized in that, include: In response to a visual effect update event triggered by a player character casting a specific skill in the current game scene, determine the target effect identifier corresponding to the visual effect update event; Obtain the set of effect identifiers that are currently in effect, and match the set of effect identifiers and the target effect identifiers based on preset effect fusion rules, so as to generate corresponding rendering configuration information according to the matching results; Invoke the effect rendering resource that matches the rendering configuration information, so as to render the specified scene environment of the game scene in real time according to the effect rendering resource.

2. The scene visual effects interaction method according to claim 1, characterized in that, The response to a visual effect update event triggered by a player character casting a specific skill in the current game scene, determining the target effect identifier corresponding to the visual effect update event, includes: When the visual effect update event is detected, the corresponding visual effect update data associated with the specific skill cast by the player character is obtained. Obtain the pre-configured initial effect identifier contained in the visual effect update data, and determine the target effect identifier based on the initial effect identifier and the scene state parameters associated with the current game scene.

3. The scene visual effects interaction method according to claim 2, characterized in that, The step of determining the target effect identifier based on the initial effect identifier and scene state parameters associated with the current game scene includes: Based on the triggering of the visual effects update event, at least one of the scene state parameters in the current game scene is obtained in real time; The initial effect identifier is matched and mapped with at least one of the scene state parameters according to the preset parameter mapping rules, so as to obtain the corresponding target effect identifier based on the mapping result.

4. The scene visual effects interaction method according to claim 1, characterized in that, The process of obtaining a set of effect identifiers that are currently in effect, matching the set of effect identifiers with the target effect identifiers based on preset effect fusion rules, and generating corresponding rendering configuration information based on the matching results includes: The effect identifier set and the target effect identifier are combined into a combined status key. The combined status key is used as the query key in the effect fusion mapping table corresponding to the effect fusion rule. The effect fusion mapping table includes the mapping relationship between the combined status key and its corresponding output effect identifier. The output effect identifier obtained from the query is used as the matching result, and the rendering configuration information is generated based on the matching result.

5. The scene visual effects interaction method according to claim 4, characterized in that, The step of invoking an effect rendering resource that matches the rendering configuration information, and rendering the specified scene environment of the game scene in real time according to the effect rendering resource, includes: Based on the output effect identifier contained in the rendering configuration information, the corresponding rendering resource storage address is obtained from the preset rendering resource index, and the rendering resource data block is obtained based on the rendering resource storage address, wherein the rendering resource data block contains a set of pre-loaded pre-configured rendering parameters; The rendering parameters contained in the rendering resource data block are submitted to the environment configuration interface of the graphics rendering pipeline to drive the interface to draw the rendering state of the specified scene environment in real time.

6. The scene visual effects interaction method according to any one of claims 1-5, characterized in that, Prior to the step of responding to a visual effects update event triggered by a player character casting a specific skill in the current game scene, the method further includes: Based on the player character information configured by the user in the current game scene, multiple effect rendering resource packages associated with the player character information are preloaded into local memory. The player character information includes skill information corresponding to a specific skill that can trigger the visual effect update event. An index relationship is established between the output effect identifier associated with the skill information and the storage address of the effect rendering resource package in local memory, so as to obtain the rendering parameters corresponding to the resource package.

7. The scene visual effects interaction method according to claim 6, characterized in that, After the step of performing real-time rendering of the specified scene environment of the game scene based on the effect rendering resource, the method further includes: The output effect identifier corresponding to the matching result and its associated rendering configuration information are encapsulated into state synchronization information, and the state synchronization information is sent to the game server. The game client receives a rendering synchronization instruction sent by the game server based on the status synchronization information, so that the game client calls the corresponding effect rendering resource package pre-loaded locally to perform real-time rendering of the specified scene environment based on the rendering synchronization instruction. The game client is the client corresponding to the online player character in the current game scene.

8. A scene visual effects interactive device, characterized in that, include: The event response module is set to respond to visual effect update events triggered by a player character casting a specific skill in the current game scene, and to determine the target effect identifier corresponding to the visual effect update event; The information matching module is configured to obtain a set of effect identifiers that are currently in effect, and match the set of effect identifiers and the target effect identifiers based on preset effect fusion rules, so as to generate corresponding rendering configuration information based on the matching results; The screen rendering module is configured to call effect rendering resources that match the rendering configuration information, so as to perform real-time rendering of the specified scene environment of the game scene according to the effect rendering resources.

9. A scene visual effects interactive device, comprising a central processing unit and a memory, characterized in that, The central processing unit is used to invoke and run a computer program stored in the memory to perform the steps of the method as described in any one of claims 1 to 7.

10. A non-volatile readable storage medium, characterized in that, It stores, in the form of computer-readable instructions, a computer program implemented according to any one of claims 1 to 7, which, when invoked by a computer, executes the steps included in the corresponding method.

Images