CN118873942A - A collision detection method, device, electronic device and storage medium - Google Patents

Abstract

The application discloses a collision detection method, a device, electronic equipment and a storage medium, comprising the following steps: starting a game engine, and creating a first rendering function interface and a second rendering function interface; rendering an application interface of the target application through a first rendering function interface; responding to triggering operation aiming at an application interface, and acquiring an operation position of the triggering operation; taking a pixel point on the application interface with the hit of the operation position as a target pixel point; determining an image object to be detected based on the target pixel point; calling a second rendering function interface to draw an image object to be detected; invoking a second rendering function interface to acquire target color parameters of the target pixel points, and determining whether the target color parameters meet preset collision conditions; and if the target color parameter meets a preset collision condition, determining that the triggering operation and the image object to be detected generate pixel collision. The embodiment of the application can enable the game engine to normally perform pixel collision detection when the application platform runs, and improve the accuracy of game interaction.

Description

A collision detection method, device, electronic device and storage medium

Technical Field

The present disclosure relates to the technical field of collision detection, and in particular to a collision detection method, device, electronic device and storage medium.

Background Art

In order to meet people's pursuit of spiritual life, entertainment games that can be operated on terminals have emerged, such as multiplayer online action games, role-playing games, tactical competitive games or shooting games developed based on client or server architecture. Among them, pixel detection is a key technology in game development. It is used to determine the pixel-level collision of game elements (such as virtual characters, virtual items, and virtual scenes, etc.), and specifically can determine whether a certain game element is touched by a mouse or finger. In the prior art, by using pixel detection, game developers can more accurately produce the corresponding behaviors of game elements, thereby improving the realism of the game and the game experience of players.

At present, game engines can usually be used to render game interfaces and perform pixel detection and other operations. However, in certain specific environments, due to restrictions on the pixel reading interface in the game engine, the game engine cannot perform pixel detection normally, and thus cannot monitor collision detection events normally. Therefore, under the existing technology, collision detection is performed by falling back to the measurement and recording method using bounding boxes. However, the method of using bounding boxes for collision detection will increase the error when the mouse or finger makes contact, thereby affecting the accuracy of collision detection and the accuracy of game interaction when the player is playing the game, resulting in a poor gaming experience for the player.

Summary of the invention

The embodiments of the present application provide a collision detection method, device, electronic device and storage medium, which can enable a game engine to perform pixel collision detection normally when running a game on a specific application platform, thereby improving the accuracy of collision detection, improving the accuracy of game interaction when players play games on a specific application platform, and enhancing the player's gaming experience.

In a first aspect, an embodiment of the present application provides a collision detection method, the method comprising:

Starting a game engine, creating a first rendering function interface and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering;

Rendering the application interface of the target application through the first rendering function interface to display the application interface;

In response to a trigger operation on the application interface, obtaining an operation position of the trigger operation;

Taking the pixel point on the application interface hit by the operation position as the target pixel point;

Determine the image object to be detected based on the target pixel point;

Calling the second rendering function interface to draw the image object to be detected;

Calling the second rendering function interface to obtain a target color parameter of the target pixel point, and determining whether the target color parameter satisfies a preset collision condition;

If the target color parameter satisfies the preset collision condition, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected.

In a second aspect, an embodiment of the present application provides a collision detection device, comprising:

A creation unit, used to start a game engine, create a first rendering function interface, and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering;

A first calling unit, configured to render an application interface of a target application through the first rendering function interface to display the application interface;

A response unit, configured to obtain an operation position of the trigger operation in response to the trigger operation on the application interface;

A processing unit, configured to take the pixel point on the application interface hit by the operation position as a target pixel point;

A first determining unit, configured to determine an image object to be detected based on the target pixel point;

The second calling unit is used to call the second rendering function interface to draw the image object to be detected

The third calling unit further calls the second rendering function interface to obtain a target color parameter of the target pixel point, and determines whether the target color parameter satisfies a preset collision condition;

The second determination unit is configured to determine that a pixel collision occurs between the trigger operation and the image object to be detected if the target color parameter satisfies the preset collision condition.

In a third aspect, an embodiment of the present application further provides an electronic device, including a memory storing a plurality of instructions; a processor loads the instructions from the memory to execute the steps of any collision detection method provided in the embodiment of the present application.

In a fourth aspect, an embodiment of the present application further provides a computer-readable storage medium, which stores a plurality of instructions suitable for loading by a processor to execute the steps of any collision detection method provided in the embodiment of the present application.

In a fifth aspect, an embodiment of the present application further provides a computer program product, including a computer program or instructions, which, when executed by a processor, implements the steps of any collision detection method provided in the embodiment of the present application.

By adopting the solution of the embodiment of the present application, two rendering function interfaces can be created, one rendering function interface is used to perform operations such as interface rendering, and the other rendering function interface is used to perform pixel collision detection operations, so that the game engine can perform pixel collision detection normally when running the game on a specific application platform, thereby improving the accuracy of collision detection, improving the accuracy of game interaction when players play games on a specific application platform, and enhancing the player's gaming experience.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For those skilled in the art, other drawings can be obtained based on these drawings without creative work.

FIG1 is a schematic diagram of a scene of a collision detection system provided in an embodiment of the present application;

FIG2 is a schematic diagram of a flow chart of an embodiment of a collision detection method provided in an embodiment of the present application;

FIG3 is a schematic diagram of the structure of a collision detection device provided in an embodiment of the present application;

FIG. 4 is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application.

DETAILED DESCRIPTION

The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without making creative work are within the scope of protection of the present application. At the same time, in the description of the embodiments of the present application, the terms "first", "second", etc. are only used to distinguish the descriptions and cannot be understood as indicating or implying relative importance. Thus, the features defined as "first" and "second" may explicitly or implicitly include one or more features. In the description of the embodiments of the present application, the meaning of "multiple" is two or more, unless otherwise clearly and specifically defined.

The embodiments of the present application provide a collision detection method, device, electronic device, and computer-readable storage medium. Specifically, the present embodiment will be described from the perspective of a collision detection device, which can be integrated into an electronic device, that is, the collision detection method of the embodiment of the present application can be performed by an electronic device, and optionally, the electronic device can include: a terminal device. The terminal device can be a mobile phone, a tablet computer, a smart Bluetooth device, a laptop computer, a game console, or a personal computer (PC) and other devices.

The collision detection method provided in the embodiment of the present application can be applied to, for example, a collision detection system. The collision detection system may include a player terminal device and a server, and the terminal may be a device including both receiving and transmitting hardware, that is, a device having receiving and transmitting hardware capable of performing two-way communication on a two-way communication link. The player terminal device and the server may perform two-way communication via a network.

Optionally, the server may be an independent server, or a server network or server cluster composed of servers, including but not limited to a computer, a network host, a single network server, a plurality of network server sets or a cloud server composed of multiple servers. The cloud server is composed of a large number of computers or network servers based on cloud computing.

The collision detection method in one embodiment of the present disclosure may be run on a local terminal device or a server. When the collision detection method is run on a server, the method may be implemented and executed based on a cloud interaction system, wherein the cloud interaction system includes a server and a client device.

For example, when the collision detection method is run on a terminal, the terminal device stores a game application and is used to present a virtual scene in the game screen. The terminal device is used to interact with the user through a graphical user interface, for example, the game application is downloaded and installed through the terminal device and run. The terminal device may provide the graphical user interface to the user in a variety of ways, for example, it may be rendered and displayed on the display screen of the terminal device, or the graphical user interface may be presented through holographic projection. For example, the terminal device may include a touch display screen and a processor, the touch display screen is used to present the graphical user interface and receive the operation instructions generated by the user acting on the graphical user interface, the graphical user interface includes a game screen, and the processor is used to run the game, generate a graphical user interface, respond to the operation instructions, and control the display of the graphical user interface on the touch display screen.

For example, when the collision detection method is run on a server, it can be a cloud game. Cloud gaming refers to a gaming method based on cloud computing. In the operation mode of cloud gaming, the operating body of the game application and the game screen presentation body are separated, and the storage and operation of the collision detection method are completed on the cloud gaming server. The game screen presentation is completed on the client of the cloud gaming. The cloud gaming client is mainly used for receiving and sending game data and presenting the game screen. For example, the cloud gaming client can be a display device with data transmission function close to the user side, such as a mobile terminal, a TV, a computer, a PDA, a personal digital assistant, etc., but the terminal device for processing game data is a cloud gaming server in the cloud. When playing the game, the user operates the cloud gaming client to send an operation instruction to the cloud gaming server. The cloud gaming server runs the game according to the operation instruction, encodes and compresses the game screen and other data, and returns it to the cloud gaming client through the network. Finally, the cloud gaming client decodes and outputs the game screen.

Please refer to Figure 1, which is a scene diagram of a collision detection system provided by an embodiment of the present application. The system may include at least one terminal, at least one server, at least one database, and a network. The terminal held by the user can be connected to the servers of different games through the network. The terminal is any device with computing hardware that can support and execute software products corresponding to the game. In addition, when the system includes multiple terminals, multiple servers, and multiple networks, different terminals can be connected to each other through different networks and different servers. The network can be a wireless network or a wired network, such as a wireless network such as a wireless local area network (WLAN), a local area network (LAN), a cellular network, a 2G network, a 3G network, a 4G network, a 5G network, etc. In addition, different terminals can also use their own Bluetooth network or hotspot network to connect to other terminals or to servers, etc. For example, multiple users can be online through different terminals and connected and synchronized with each other through appropriate networks to support multi-player games. In addition, the system may include multiple databases, multiple databases are coupled to different servers, and information related to the game environment can be continuously stored in the database when different users are online for multi-player games.

The embodiment of the present application provides a collision detection method, which can be executed by a terminal or a server. The embodiment of the present application takes the collision detection method executed by a terminal as an example for explanation. Among them, the terminal may include a touch display screen and a processor (of course, the terminal may also use peripherals such as a mouse and a keyboard as input devices, and only the touch display screen is used as an example for explanation here), and the touch display screen is used to present a graphical user interface and receive operation instructions generated by the user acting on the graphical user interface. When the user operates the graphical user interface through the touch display screen, the graphical user interface can control the local content of the terminal by responding to the received operation instructions, and can also control the content of the opposite server by responding to the received operation instructions. For example, the operation instructions generated by the user acting on the graphical user interface include instructions for starting a game application, and the processor is configured to start the game application after receiving the instructions for starting the game application provided by the user. In addition, the processor is configured to render and draw a graphical user interface associated with the game on the touch display screen. The touch display screen is a multi-touch sensitive screen that can sense touch or sliding operations performed simultaneously at multiple points on the screen. The user uses a finger to perform a touch operation on the graphical user interface, and when the graphical user interface detects the touch operation, the different virtual objects in the graphical user interface of the game are controlled to perform actions corresponding to the touch operation.

It should be noted that the scenario diagram of the collision detection system shown in Figure 1 is merely an example. The collision detection system and scenario described in the embodiment of the present application are intended to more clearly illustrate the technical solution of the embodiment of the present application, and do not constitute a limitation on the technical solution provided in the embodiment of the present application. Ordinary technicians in this field can know that with the emergence of new business scenarios, the technical solution provided in the embodiment of the present application is also applicable to similar technical problems.

The embodiment of the present application provides a collision detection method, which can be executed by a terminal or a server. The embodiment of the present application takes the collision detection method executed by a terminal as an example for explanation, and a graphical user interface (i.e., an application interface) can be provided by a terminal device, and the graphical user interface includes at least part of a virtual scene, and a controlled virtual object (i.e., an interface element) located in the virtual scene and controlled by the terminal device. The graphical user interface, virtual scene, and virtual object are explained below.

The game scene (or virtual scene) is a virtual scene displayed (or provided) when the application is running on a terminal or server. Optionally, the virtual scene is a simulation environment of the real world, or a semi-simulation and semi-fictitious virtual environment, or a purely fictitious virtual environment. The virtual scene is any one of a two-dimensional virtual scene and a three-dimensional virtual scene, and the virtual environment can be the sky, land, ocean, etc., wherein the land includes environmental elements such as deserts and cities. Among them, the virtual scene is a scene with complete game logic of virtual objects such as user control. For example, for sandbox 3D shooting games, the virtual scene is a 3D game world for players to control virtual objects to fight. Example virtual scenes may include: at least one element of mountains, plains, rivers, lakes, oceans, deserts, skies, plants, buildings, and vehicles; for example, for 2D card games, the virtual scene is a scene for displaying released cards or displaying virtual objects corresponding to cards. Example virtual scenes may include: an arena, a decisive battlefield, or other "field" elements or other elements that can display the status of card battles; for 2D or 3D multiplayer online tactical competitive games, the virtual scene is a 2D or 3D terrain scene for virtual objects to fight. Example virtual scenes may include: canyon-style mountains, lines, rivers, classrooms, tables and chairs, podiums and other elements.

The graphical user interface is obtained by executing a software application on a processor of a mobile terminal or other terminal and rendering it on a display, and can be a display screen interface of a terminal device. The graphical user interface can present the entire game scene, or only a part of the game scene. The game scene includes multiple static virtual objects, specifically including ground, mountains, rocks, vegetation, buildings, etc. When the game scene is relatively large, only the local content of the game scene is displayed on the graphical user interface of the terminal device during the game. Optionally, the game scene contains game characters, which can be game characters controlled by players, or NPCs (abbreviation of non-player characters, which is a type of character in the game, meaning non-player characters), which is not limited in this exemplary embodiment. The graphical user interface can include a UI interface and a game screen for players to interact. In an optional embodiment, the UI interface can include game controls (such as skill controls, mobile controls, function controls, etc.), indicator signs (such as direction indicator signs, role indicator signs, etc.), information display areas (such as the number of kills, game time, etc.), or game setting controls (such as system settings, stores, gold coins, etc.). In an optional implementation, the game screen is a display screen corresponding to a virtual scene displayed by a terminal device, and the game screen may include virtual objects such as game characters, NPC characters, AI characters, etc. that execute game logic in the virtual scene.

A game object (or virtual object, game character) refers to a dynamic object that can be controlled in a virtual scene. Optionally, the dynamic object can be a virtual character, a virtual animal, a cartoon character, etc. The virtual object is a character controlled by a player through an input device, or an artificial intelligence (AI) set in a virtual environment battle through training, or a non-player character (NPC) set in a virtual scene battle. Optionally, the virtual object is a virtual character competing in a virtual scene. Optionally, the number of virtual objects in the virtual scene battle is preset, or is dynamically determined according to the number of clients joining the battle, and the embodiment of the present application does not limit this. In a possible implementation, the user can control the virtual object to move in the virtual scene, for example, control the virtual object to run, jump, crawl, etc., and can also control the virtual object to use the skills, virtual props, etc. provided by the application to fight with other virtual objects. (Game) props refer to props that can be used by virtual objects in a virtual environment, including but not limited to firearms, cold weapons, grenades, shields, springboards, puppets, etc., which can be used by virtual objects to speed up their own attributes, assist in combat, or launch damage to other virtual objects. Virtual props can also be supply props such as bullets, and can also be equipped on designated virtual weapons for accessories such as extended magazines, aiming scopes, flash suppressors, and stocks. The virtual camera is a necessary component for the game scene screen, which is used to present the game scene screen. A game scene corresponds to at least one virtual camera. According to actual needs, there can be two or more virtual cameras, which serve as the game rendering window to capture and present the game world's screen content to the player. By setting the parameters of the virtual camera, the player's perspective of viewing the game world can be adjusted, such as the first-person perspective and the third-person perspective.

The following is a detailed description in conjunction with the accompanying drawings. In this embodiment, the execution subject is a terminal device as an example. It should be noted that the description order of the following embodiments is not intended to limit the preferred order of the embodiments. Although the logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in an order different from that shown in the accompanying drawings.

Please refer to FIG. 2 , which is a schematic diagram of a flow chart of a collision detection method provided in an embodiment of the present application. The specific flow of the collision detection method may be as follows: Steps 101 to 108:

Step 101: Start a game engine, create a first rendering function interface, and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering.

The game engine may be the Egret engine, which is a two-dimensional (2D) game engine based on HTML5 technology developed by Egret Technologies. It uses TypeScript as a development language and provides a complete set of 2D game solutions, including basic components such as display objects, event systems, animations, networks, sounds, and resource loading, and may also include extended components such as UI systems, EUI editors, particle systems, and keel animation systems.

The rendering function interface mentioned in the embodiment of the present application is a WebGL context, the first rendering function interface is a WebGL context-primary, and the second rendering function interface is a WebGL context-secondary. Specifically, the WebGL context-primary maintains its original default function unchanged and still serves as the rendering target of the game, that is, it is used for rendering and displaying the game screen; the other WebGL context-secondary is not rendered and is only used for pixel collision detection.

Among them, WebGL context refers to the environment in which WebGL (Web Graphics Library) creates and operates 3D graphics in the browser. WebGL is a cross-platform graphics API based on OpenGL ES2.0. It uses the JavaScript programming language and allows developers to create interactive 3D graphics and animations in a web browser. Specifically, the WebGL context is created by calling the getContext("webgl") function on the canvas element in an HTML document. Once the WebGL context is obtained, developers can use various WebGL functions to define and draw 3D graphics, control shaders, set textures, etc. The WebGL context provides an interface for interacting with a hardware-accelerated graphics renderer, making it possible to draw complex 3D graphics in a browser. In other words, the WebGL context provides an underlying graphics programming interface, and developers can use JavaScript to write programs to operate various stages of the graphics rendering pipeline to achieve customized 3D graphics effects. It provides powerful graphics processing capabilities, can use the parallel computing capabilities of graphics cards to speed up rendering, and supports advanced graphics effects such as hardware-accelerated lighting, texture mapping, and projection.

In one embodiment, the method further comprises:

A specified attribute is set for the image object corresponding to the second rendering function interface, wherein the specified attribute is used to indicate that the image object will not be rendered so that the image object is used for pixel collision detection.

In an embodiment of the present application, a specified attribute (bOnlyPixelHitTest: boolean) can be set for an image object (Image object), and the specified attribute is used to control the scope of the Image instance object. When the attribute value of bOnlyPixelHitTest of the image object is true, it is set not to render, which means that the image object will not be rendered to the WebGL context-primary, and will not be displayed. Only when pixel collision detection is required, the image object will be drawn to the WebGL context-secondary for pixel collision detection.

Specifically, bOnlyPixelHitTest is a property of the egret.Bitmap class in the Egret engine, which is used to specify whether only pixel-level collision detection is performed. In the Egret engine, collision detection is the process used to determine whether two objects collide. Usually, collision detection uses the bounding boxes of two objects to compare to determine whether they intersect, but sometimes more precise collision detection may be required, that is, only comparing at the pixel level of the objects. When the bOnlyPixelHitTest property is set to true, the egret.Bitmap object will only consider pixel-level comparisons when performing collision detection, that is, it will compare the pixels of the two objects one by one to determine whether a collision occurs, rather than just comparing their bounding boxes.

Among them, the Image object is a built-in object that represents an image in JavaScript. It can be used to load and manipulate images. It is usually used to display images or perform image processing on web pages. By creating an Image object, you can load image files and display them on web pages. In addition to loading and displaying images, the Image object also provides some other useful properties and events. Some commonly used properties include width (width of the image), height (height of the image), naturalWidth (original width of the image, read-only), naturalHeight (original height of the image, read-only), complete (indicates whether the image has been loaded), etc. In addition, the Image object also has some events, such as onload (triggered when the image is loaded), onerror (triggered when an error occurs in the image loading), etc., which can be used to detect the loading status of the image. In summary, the Image object is a built-in object for loading and manipulating images. It can load image files and display them on web pages. At the same time, it also provides some useful properties and events to process and manipulate images.

In another embodiment, the method further comprises:

A specified global object is created, where the specified global object is used to enable the second rendering function interface to draw the image object.

Among them, the global object can be customHitTestBuffer2, which can be the environment object of the second rendering function interface (i.e., WebGL context-sub). In Web development, the environment object is usually used to configure the behavior that the application can execute in different environments. The environment object can contain the environment information and resource configuration set for the WebGL context-sub, that is, the WebGL environment object is an important interface for configuring and managing graphics rendering. The rendering state and shader resources can be controlled through the environment object. Therefore, when it is detected that the WebGL context-primary does not support pixel detection in the current environment, a global object customHitTestBuffer2 can be created for the WebGL context-sub, and the global object is used to indicate that the WebGL context-primary cannot perform pixel collision detection. At this time, pixel collision detection needs to be performed through the WebGL context-sub; and the shader can also allocate corresponding shader resources to the WebGL context-sub according to the global object, so that the WebGL context-sub uses the corresponding shader resources to draw the image object, and does not perform rendering operations on the image object, so that the WebGL context-sub performs pixel collision detection based on the image object.

In an embodiment of the present application, due to platform limitations on a specific application platform, when the platform is configured with openDataContext, the WebGL context used for game rendering cannot obtain the pixel value of the game image, that is, the Egret engine is unsuccessful when trying to call the pixel detection function, and cannot perform pixel collision detection, that is, the WebGL context-main pixel detection is not supported in the current environment. Therefore, it is necessary to create a global object customHitTestBuffer2 (that is, the environment object), and through the global object customHitTestBuffer2, the WebGL context-sub is configured with shader resources that can be used for pixel collision detection, so that the WebGL context-sub can perform pixel collision detection. If the current environment supports the WebGL context-main pixel detection, customHitTestBuffer2 will not be created. Specifically, when it is detected that the game is running on the application's mini-game platform or mini-program platform, it can be determined that the WebGL context-main pixel detection is not supported in the current environment. A global object (customHitTestBuffer2) can be declared in the Egret engine, and a global object is created to indicate that the current operating environment cannot be used for the WebGL context-main pixel collision detection, and the WebGL context-sub is required to perform pixel collision detection.

Furthermore, the step of “calling the second rendering function interface to draw the image object to be detected” includes:

When the existence of the designated global object is detected, and the attribute value of the designated attribute of the image object to be detected is a preset attribute value, the image object to be detected is drawn based on the designated global object.

For example, when the existence of the specified global object, that is, the existence of the specified global object customHitTestBuffer2, and the attribute value of the specified attribute of the image object to be detected is the preset attribute value, that is, the attribute value of bOnlyPixelHitTest of the image object to be detected is true, the image object to be detected is drawn through the specified global object.

Specifically, the step of “starting the game engine and creating a first rendering function interface and a second rendering function interface” includes:

Start the game engine and create the first canvas and the second canvas;

A first rendering function interface is created based on the first canvas, and a second rendering function interface is created based on the second canvas.

Due to the limitations of the mini-game platform on a specific application platform (such as chat software), when openDataContext is configured, the WebGL context rendered by the game cannot obtain the pixel value of the game image, that is, the Egret engine is unsuccessful when trying to call the pixel detection function. Therefore, in an embodiment of the present application, the Egret engine code can be modified to support the creation of two WebGL contexts instead of creating a unique WebGL context. Specifically, two canvases can be created to create a first rendering function interface and a second rendering function interface respectively.

Among them, openDataContext refers to the concept of the open data domain (Open Data Context) of the mini program. For example, in the mini program of the chat software, openDataContext is an independent JavaScript execution environment, which can be used to provide cross-page data sharing and communication in the mini game (mini program game). Mini game refers to the game-like part of the mini program. The purpose of openDataContext is to solve the need for sharing data and communication between different pages in the mini program game. Usually, each mini program page runs in its own independent JavaScript environment, and it is difficult for them to share data with each other. However, by using openDataContext, developers can create a shared data domain in the mini game, so that different pages can share data and communicate. In openDataContext, developers can define the data that needs to be shared and send messages to other pages through the postMessage method. Other pages can receive messages sent by openDataContext by listening to the onMessage method, thereby realizing data sharing and communication. openDataContext provides an independent data sharing and communication environment, so that different pages in the mini game can share and communicate data across pages, so as to better realize the functions and experience in the mini game.

Furthermore, the method further comprises:

Allocating a first interface identifier based on the interface type of the first rendering function interface, and allocating a second interface identifier based on the interface type of the second rendering function interface;

Based on the first interface identifier and the second interface identifier, corresponding shader resources are allocated to the first rendering function interface and the second rendering function interface respectively.

Since each WebGL context has its own state, resources, texture objects, and shader resources (shaderprogram), although the WebGL context-sub does not render, it does not render to the main screen, that is, it will not be displayed. It is similar to an off-screen drawing, so the WebGL context-sub also needs to allocate shader resources. Specifically, different interface identifiers (ids) can be allocated according to different WebGL contexts, and then different ids can be used to obtain and allocate corresponding shader resources for different WebGL contexts.

Furthermore, after creating the second rendering function interface, it also includes:

Corresponding shader resources are allocated to the second rendering function interface based on the specified global object.

In the embodiment of the present application, customHitTestBuffer2 is the operating environment of the WebGL context-secondary, so the WebGL context-primary and the WebGL context-secondary can be distinguished based on customHitTestBuffer2. Specifically, the corresponding shader resources can be allocated to the WebGL context-secondary based on the specified global object customHitTestBuffer2.

Step 102: Render the application interface of the target application through the first rendering function interface to display the application interface.

In an embodiment of the present application, the first rendering function interface is also the WebGL context-main, and its main function is to render the application interface of the target application to display the application interface on the screen, for example, to render the game interface of the game to display the game interface on the screen.

Step 103: In response to a trigger operation on the application interface, an operation position of the trigger operation is obtained.

In the embodiment of the present application, the user can perform a touch operation on the screen with a finger or other object to trigger a trigger operation on the application interface; or the user can control a pointer on the application interface by operating a device such as a mouse or keyboard. In response to the trigger operation on the application interface, the computer device obtains the operation position of the trigger operation, which can be the position of the touch operation or the position of the pointer when it is operated.

Step 104: taking the pixel point on the application interface hit by the operation position as the target pixel point.

In a specific implementation, the step of “taking the pixel point on the application interface hit by the operation position as the target pixel point” includes:

If the operation position hits a pixel point of a specific interface element on the application interface, the pixel point is used as the target pixel point.

The interface elements may be elements displayed on the application interface, such as a virtual scene, and virtual objects in the virtual scene that can interact with the user.

Specifically, in an embodiment of the present application, if the operation position is detected and the pixel point of a specific interface element on the application interface is hit, after the pixel point is taken as the target pixel point, the second rendering function interface can be called to obtain the target color parameters of the target pixel point, and determine whether the target color parameters meet the preset collision conditions, thereby performing pixel collision detection.

In an embodiment of the present application, the detection of whether the mouse pointer has a pixel collision with an interface element is used as an example for explanation. The coordinates of the mouse click position can be obtained, that is, when the user performs a mouse click operation, the game will obtain and record the coordinates of the mouse click. Then, the game will start from the root node of the display list tree and traverse the entire tree structure of the list tree. Each node represents a game object. Then, for each traversed node, the game will check whether the coordinates of the mouse click are within the bounding box of the node (game object). If so, the child nodes of the node will be further traversed. If the coordinates of the mouse click are within the bounding box of a certain node, a more accurate collision detection will be performed, that is, checking whether the coordinates of the mouse click are on the pixels of the game object. If so, it is considered that the mouse has indeed clicked on this game object.

Furthermore, the image object determined by the pixel points of the game object can be drawn through the second rendering function interface, and then a determination is made as to whether the transparency value of the pixel point clicked by the mouse is not 0. If it is 0, it means that the transparent position of the game object is clicked and no pixel collision occurs; if it is not 0, it means that the opaque position of the game object is clicked, indicating that a valid pixel collision occurs.

Step 105: Determine the image object to be detected based on the target pixel point.

In one embodiment, the step of “determining the image object to be detected based on the target pixel point” includes:

When it is detected that the attribute value of the designated attribute of the image object corresponding to the target pixel point is a preset attribute value, the image object is determined to be the image object to be detected.

Specifically, when it is detected that the attribute value of the designated attribute of the image object corresponding to the target pixel is a preset attribute value, that is, when the attribute value of bOnlyPixelHitTest of the image object is true, it is determined that the image object is the image object to be detected.

Step 106: Call the second rendering function interface to draw the image object to be detected.

Specifically, the step of “calling the second rendering function interface to draw the image object to be detected” includes:

The second rendering function interface is called to draw the image object to be detected to obtain the drawn image object.

For example, the image object to be detected can be drawn onto the WebGL context-sub through customHitTestBuffer2, so as to perform pixel collision detection based on the image object to be detected.

Specifically, the target pixel point at the user click position can be obtained, and the WebGL context-sub can be called to draw the image object to be detected of the target pixel point. Specifically, the image object to be detected can be drawn on the WebGL context-sub according to the shader resources allocated to the WebGL context-sub by the shader based on customHitTestBuffer2, and then the target array corresponding to the preset size can be obtained on the drawn image object according to the preset size. At this time, the target array includes the transparency value of each pixel point in the area of the preset size, and then the transparency value of the target pixel point can be obtained from the target array to determine whether to send a pixel collision, that is, the transparency value is not equal to zero, which indicates contact, that is, the trigger operation collides with the interface element.

Step 107: Call the second rendering function interface to obtain the target color parameter of the target pixel, and determine whether the target color parameter meets a preset collision condition.

Specifically, the transparency value can be judged to determine whether to send a pixel collision, that is, the transparency value is not equal to zero, which means that there is contact, that is, the trigger operation collides with the interface element. The preset collision condition can be that the transparency value of the pixel point is not zero.

In one embodiment, the step of “calling the second rendering function interface to obtain the target color parameter of the target pixel point, and determining whether the target color parameter satisfies a preset collision condition” includes:

Performing data acquisition processing on the drawn image object based on the pixel coordinates of the target pixel and a preset size to obtain a target array;

A target color parameter of the target pixel is determined from the target array based on the pixel coordinates, and it is determined whether the target color parameter satisfies a preset collision condition.

For example, because it is only necessary to obtain the pixel value of a specified point, it is not necessary to apply for the width and height of the entire Image object, thereby reducing memory consumption. Therefore, the embodiment of the present application can transform the coordinates through the matrix and draw the image object to be detected to the WebGL context-sub, and specifically draw the image object to be detected to the WebGL context-sub through customHitTestBuffer2 to obtain the drawn image object (ImageData object). Then, based on the pixel coordinates of the target pixel and the preset size, the drawn image object is processed for data acquisition to obtain a target array, the length of which can be image width × height × 4 (4 channels per pixel); specifically, based on the preset size 3×3 based on the operation position in an area of the image object to be detected, the corresponding target array is determined based on the area; then, based on the pixel coordinates, the target color parameters of the target pixel are determined from the target array, and it is determined whether the target color parameters meet the preset collision conditions. Specifically, the position of the target pixel can be determined, and the index in the target array can be calculated using the following formula:

index＝(y×width+x)×4

Among them, x and y are the horizontal and vertical coordinates of the target pixel, and width is the width of the image object. Finally, the target color value corresponding to the target pixel is obtained from the target array through the index calculated by the above formula, that is, the RGBA value, so as to obtain an array [r, g, b, a], in which the elements represent the red value, green value, blue value and transparency value of the pixel respectively. Finally, by judging the transparency value, it is determined whether to send a collision. That is, if the transparency value is not equal to zero, it means that there is contact, which means that the trigger operation has collided with the interface element.

Step 108: If the target color parameter satisfies the preset collision condition, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected.

Specifically, the target color parameter includes a target transparency value; the step of “determining whether the target color parameter satisfies a preset collision condition” includes:

Calling the second rendering function interface to obtain a target transparency value of the target pixel, and determining whether the target transparency value is a specified reference transparency value;

If not, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected.

For example, the preset collision condition may be that the transparency value of the pixel point is not 0. If the transparency value of the pixel value is not 0, the preset collision condition is met, indicating that a pixel collision has occurred between the trigger operation and the image object to be detected; if the transparency value of the pixel value is 0, the preset collision condition is met, indicating that no pixel collision has occurred between the trigger operation and the image object to be detected.

The embodiment of the present application can modify the Egret engine code to enable the Egret engine to support the creation of two WebGL contexts, thereby solving the problem that the Egret engine cannot perform pixel detection under certain circumstances. In this way, even under certain circumstances, the Egret engine can perform accurate pixel detection, thereby improving the realism of the game and the game experience of the players.

Then, by adding new property controls to the Image object, the Image object can be used for pixel detection without being rendered. This solves the problem of using corresponding textures for different WebGL contexts in WebGL1.0. This avoids unnecessary rendering and improves the running efficiency of the game.

Furthermore, by declaring a global object in the Egret engine and creating the global object on the application mini-game platform, the Egret engine can perform pixel detection on the WeChat mini-game platform. This can expand the application scope of the Egret engine and enable it to perform pixel detection on more platforms.

Finally, by modifying the original pixel detection function for an Image object in the Egret engine, when the global object is found to exist and the specific attribute value of the Image object is equal to true, the WebGL context is used to draw the Image object. In this way, pixel detection can be implemented in a specific environment, thereby improving the realism of the game and the gaming experience of the players; at the same time, no modification is required to the upper-level business code, reducing the access cost.

This embodiment also provides a collision detection device, which can be integrated in a terminal device. For example, as shown in FIG3 , the collision detection device may include:

A creation unit 201 is used to start a game engine, create a first rendering function interface, and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering;

A first calling unit 202 is used to render an application interface of a target application through the first rendering function interface to display the application interface;

A response unit 203, configured to obtain an operation position of the trigger operation in response to the trigger operation on the application interface;

A processing unit 204 is configured to use the pixel point on the application interface hit by the operation position as a target pixel point;

A first determining unit 205, configured to determine an image object to be detected based on the target pixel point;

The second calling unit 206 is used to call the second rendering function interface to draw the image object to be detected;

The third calling unit 207 further calls the second rendering function interface to obtain a target color parameter of the target pixel point, and determines whether the target color parameter satisfies a preset collision condition;

The second determining unit 208 is configured to determine whether a pixel collision occurs between the trigger operation and the image object to be detected if the target color parameter satisfies the preset collision condition.

In some embodiments, the collision detection device comprises:

A setting subunit is used to set a specified attribute for the image object corresponding to the second rendering function interface, wherein the specified attribute is used to indicate that the image object will not be rendered so that the image object is used for pixel collision detection.

In some embodiments, the collision detection device comprises:

The first detection subunit is configured to determine that the image object is an image object to be detected when it is detected that the attribute value of the designated attribute of the image object corresponding to the target pixel point is a preset attribute value.

In some embodiments, the collision detection device comprises:

The first calling subunit is used to call the second rendering function interface to draw the image object to be detected to obtain the drawn image object.

In some embodiments, the collision detection device comprises:

A first processing sub-unit is used to perform data acquisition processing on the drawn image object based on the pixel coordinates of the target pixel and a preset size to obtain a target array;

The first determining subunit is used to determine a target color parameter of the target pixel point from the target array based on the pixel point coordinates, and to determine whether the target color parameter satisfies a preset collision condition.

In some embodiments, the collision detection device comprises:

A second determination subunit, configured to determine whether the target transparency value is a specified reference transparency value;

The second determining subunit is configured to determine, if not, whether a pixel collision occurs between the triggering operation and the image object to be detected.

In some embodiments, the collision detection device comprises:

A creation subunit is used to create a specified global object, where the specified global object is used to enable the second rendering function interface to draw the image object.

In some embodiments, the collision detection device comprises:

The second detection subunit is configured to draw the image object to be detected based on the designated global object when it is detected that the designated global object exists and the attribute value of the designated attribute of the image object to be detected is a preset attribute value.

In some embodiments, the collision detection device comprises:

An allocation subunit is used to allocate corresponding shader resources to the second rendering function interface based on the specified global object.

In some embodiments, the collision detection device comprises:

The second processing sub-unit is used for, if the operation position hits a pixel point of a specific interface element on the application interface, taking the pixel point as a target pixel point.

The embodiment of the present application discloses a collision detection device, which starts a game engine through a creation unit 201, creates a first rendering function interface and a second rendering function interface, and the second rendering function interface is configured to be unable to perform screen rendering; a first calling unit 202 renders an application interface of a target application through the first rendering function interface to display the application interface; a response unit 203 obtains an operation position of the trigger operation in response to a trigger operation on the application interface; a processing unit 204 uses a pixel point on the application interface hit by the operation position as a target pixel point; a first determination unit 205 determines an image object to be detected based on the target pixel point; a second calling unit 206 calls the second rendering function interface to draw the image object to be detected; a third calling unit 207 is used to call the second rendering function interface to obtain a target color parameter of the target pixel point, and determine whether the target color parameter meets a preset collision condition; a second determination unit 208 determines that a pixel collision has occurred between the trigger operation and the image object to be detected if the target color parameter meets the preset collision condition. The embodiment of the present application can create two rendering function interfaces, one rendering function interface is used to perform operations such as interface rendering, and the other rendering function interface is used to perform pixel collision detection operations, so that the game engine can perform pixel collision detection normally when running the game on a specific application platform, thereby improving the accuracy of collision detection, improving the accuracy of game interaction when players play games on a specific application platform, and enhancing the player's gaming experience.

Accordingly, an embodiment of the present application further provides an electronic device, which may be a terminal, and the terminal may be a smart phone, a tablet computer, a laptop computer, a touch screen, a game console, a personal computer (PC, Personal Computer), a personal digital assistant (Personal Digital Assistant, PDA) and other terminal devices. Alternatively, the electronic device may be a server.

As shown in Figure 4, Figure 4 is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. The electronic device 300 includes a processor 301 having one or more processing cores, a memory 302 having one or more computer-readable storage media, and a computer program stored in the memory 302 and executable on the processor. Among them, the processor 301 is electrically connected to the memory 302. Those skilled in the art will appreciate that the electronic device structure shown in the figure does not constitute a limitation on the electronic device, and may include more or fewer components than shown, or combine certain components, or arrange components differently.

The processor 301 is the control center of the electronic device 300, and uses various interfaces and lines to connect various parts of the entire electronic device 300. By running or loading software programs and/or units stored in the memory 302, and calling data stored in the memory 302, the processor 301 executes various functions of the electronic device 300 and processes data, thereby monitoring the electronic device 300 as a whole. The processor 301 can be a central processing unit CPU, a graphics processing unit GPU, a network processor (Network Processor, NP), etc., and can implement or execute the various methods, steps and logic block diagrams disclosed in the embodiments of the present application.

In the embodiment of the present application, the processor 301 in the electronic device 300 will load instructions corresponding to the processes of one or more application programs into the memory 302 according to the following steps, and the processor 301 will run the application programs stored in the memory 302 to implement various functions, such as:

Starting a game engine, creating a first rendering function interface and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering;

Rendering the application interface of the target application through the first rendering function interface to display the application interface;

In response to a trigger operation on the application interface, obtaining an operation position of the trigger operation;

Taking the pixel point on the application interface hit by the operation position as the target pixel point;

Determine the image object to be detected based on the target pixel point;

Calling the second rendering function interface to draw the image object to be detected;

Calling the second rendering function interface to obtain a target color parameter of the target pixel point, and determining whether the target color parameter satisfies a preset collision condition;

If the target color parameter satisfies the preset collision condition, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected.

The electronic device provided in the embodiment of the present application can create a first rendering function interface and a second rendering function interface by starting a game engine, and the second rendering function interface is configured to be unable to perform screen rendering; then, the application interface of the target application is rendered through the first rendering function interface to display the application interface; then, in response to a trigger operation on the application interface, the operation position of the trigger operation is obtained; then, the pixel point on the application interface hit by the operation position is used as the target pixel point; then, the image object to be detected is determined based on the target pixel point; then, the second rendering function interface is called to draw the image object to be detected; then, the second rendering function interface is called to obtain the target color parameter of the target pixel point, and it is determined whether the target color parameter meets the preset collision condition; finally, if the target color parameter meets the preset collision condition, it is determined that the trigger operation has a pixel collision with the image object to be detected. By adopting the solution of the embodiment of the present application, two rendering function interfaces can be created, one rendering function interface is used to perform operations such as interface rendering, and the other rendering function interface is used to perform pixel collision detection operations, so that the game engine can perform pixel collision detection normally when running the game on a specific application platform, thereby improving the accuracy of collision detection, improving the accuracy of game interaction when players play games on a specific application platform, and enhancing the player's gaming experience.

The specific implementation of the above operations can be found in the previous embodiments, which will not be described in detail here.

Optionally, as shown in FIG4 , the electronic device 300 further includes: a touch screen 303, a radio frequency circuit 304, an audio circuit 305, an input unit 306, and a power supply 307. The processor 301 is electrically connected to the touch screen 303, the radio frequency circuit 304, the audio circuit 305, the input unit 306, and the power supply 307, respectively. Those skilled in the art will appreciate that the electronic device structure shown in FIG4 does not limit the electronic device, and may include more or fewer components than shown, or combine certain components, or arrange components differently.

The touch display screen 303 can be used to display a graphical user interface and receive operation instructions generated by the user acting on the graphical user interface. The touch display screen 303 may include a display panel and a touch panel. Among them, the display panel can be used to display information input by the user or information provided to the user and various graphical user interfaces of the electronic device, and these graphical user interfaces can be composed of graphics, text, icons, videos and any combination thereof. Optionally, the display panel can be configured in the form of a liquid crystal display (LCD, Liquid Crystal Display), an organic light-emitting diode (OLED, Organic Light-Emitting Diode) and the like. The touch panel can be used to collect the user's touch operation on or near it (such as the user uses any suitable object or attachment such as a finger, a stylus, etc. on the touch panel or near the touch panel), and generate corresponding operation instructions, and the operation instructions execute corresponding programs. Optionally, the touch panel may include two parts: a touch detection device and a touch controller. Among them, the touch detection device detects the user's touch direction, detects the signal brought by the touch operation, and transmits the signal to the touch controller; the touch controller receives the touch information from the touch detection device, converts it into the touch point coordinates, and then sends it to the processor 301, and can receive the command sent by the processor 301 and execute it. The touch panel can cover the display panel. When the touch panel detects a touch operation on or near it, it is transmitted to the processor 301 to determine the type of touch event, and then the processor 301 provides a corresponding visual output on the display panel according to the type of touch event. In an embodiment of the present application, the touch panel and the display panel can be integrated into the touch display screen 303 to realize the input and output functions. However, in some embodiments, the touch panel and the touch panel can be used as two independent components to realize the input and output functions. That is, the touch display screen 303 can also be used as a part of the input unit 306 to realize the input function.

The radio frequency circuit 304 may be used to send and receive radio frequency signals, so as to establish wireless communication with a network device or other electronic devices through wireless communication, and to send and receive signals with the network device or other electronic devices.

The audio circuit 305 can be used to provide an audio interface between the user and the electronic device through a speaker and a microphone. The audio circuit 305 can transmit the electrical signal converted from the received audio data to the speaker, which is converted into a sound signal for output; on the other hand, the microphone converts the collected sound signal into an electrical signal, which is received by the audio circuit 305 and converted into audio data, and then the audio data is output to the processor 301 for processing, and then sent to another electronic device through the radio frequency circuit 304, or the audio data is output to the memory 302 for further processing. The audio circuit 305 may also include an earplug jack to provide communication between an external headset and the electronic device.

The input unit 306 may be used to receive input numbers, character information or user feature information (such as fingerprint, iris, facial information, etc.), and generate keyboard, mouse, joystick, optical or trackball signal input related to user settings and function control.

The power supply 307 is used to supply power to various components of the electronic device 300. Optionally, the power supply 307 can be logically connected to the processor 301 through a power management system, so that the power management system can manage charging, discharging, and power consumption. The power supply 307 can also include one or more DC or AC power supplies, recharging systems, power failure detection circuits, power converters or inverters, power status indicators, and other arbitrary components.

Although not shown in FIG. 4 , the electronic device 300 may further include a camera, a sensor, a wireless fidelity module, a Bluetooth module, etc., which will not be described in detail herein.

In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

A person of ordinary skill in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be completed by instructions, or by controlling related hardware through instructions. The instructions may be stored in a computer-readable storage medium and loaded and executed by a processor.

To this end, an embodiment of the present application provides a computer-readable storage medium, in which multiple computer programs are stored, and the computer program can be loaded by a processor to execute any collision detection method provided in the embodiment of the present application. The computer program can execute the following steps of the collision detection method:

Starting a game engine, creating a first rendering function interface and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering;

Rendering the application interface of the target application through the first rendering function interface to display the application interface;

In response to a trigger operation on the application interface, obtaining an operation position of the trigger operation;

Taking the pixel point on the application interface hit by the operation position as the target pixel point;

Determine the image object to be detected based on the target pixel point;

Calling the second rendering function interface to draw the image object to be detected;

Calling the second rendering function interface to obtain a target color parameter of the target pixel point, and determining whether the target color parameter satisfies a preset collision condition;

If the target color parameter satisfies the preset collision condition, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected.

Due to the computer program stored in the storage medium, a first rendering function interface and a second rendering function interface can be created by starting a game engine, and the second rendering function interface is configured to be unable to perform screen rendering; then, the application interface of the target application is rendered through the first rendering function interface to display the application interface; then, in response to a trigger operation on the application interface, the operation position of the trigger operation is obtained; then, the pixel point on the application interface hit by the operation position is used as the target pixel point; then, the image object to be detected is determined based on the target pixel point; then, the second rendering function interface is called to draw the image object to be detected; then, the second rendering function interface is called to obtain the target color parameter of the target pixel point, and it is determined whether the target color parameter meets the preset collision condition; finally, if the target color parameter meets the preset collision condition, it is determined that the trigger operation has a pixel collision with the image object to be detected. By adopting the solution of the embodiment of the present application, two rendering function interfaces can be created, one rendering function interface is used to perform operations such as interface rendering, and the other rendering function interface is used to perform pixel collision detection operations, so that the game engine can perform pixel collision detection normally when running the game on a specific application platform, thereby improving the accuracy of collision detection, improving the accuracy of game interaction when players play games on a specific application platform, and enhancing the player's gaming experience.

The specific implementation of the above operations can be found in the previous embodiments, which will not be described in detail here.

The computer-readable storage medium may include: a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

Since the computer program stored in the computer-readable storage medium can execute any collision detection method provided in the embodiments of the present application, the beneficial effects that can be achieved by any collision detection method provided in the embodiments of the present application can be achieved. Please refer to the previous embodiments for details and will not be repeated here.

According to one aspect of the present application, a computer program product or a computer program is also provided, the computer program product or the computer program including computer instructions, the computer instructions being stored in a computer-readable storage medium. A processor of an electronic device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the electronic device executes the methods provided in various optional implementations of the above embodiments.

In the above-mentioned collision detection device, computer-readable storage medium, electronic device, and computer program product embodiments, the description of each embodiment has its own emphasis. For parts not described in detail in a certain embodiment, reference can be made to the relevant description of other embodiments. Those skilled in the art can clearly understand that for the convenience and simplicity of description, the specific working process and beneficial effects of the above-mentioned collision detection device, computer-readable storage medium, computer program product, electronic device and its corresponding units can refer to the description of the collision detection method in the above embodiment, and will not be repeated here.

The above is a detailed introduction to a collision detection method, device, electronic device, computer-readable storage medium and computer program product provided in the embodiments of the present application. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea; at the same time, for technical personnel in this field, according to the ideas of the present application, there will be changes in the specific implementation methods and application scopes. In summary, the content of this specification should not be understood as a limitation on the present application.

Claims (13)

1. A collision detection method, comprising: Starting a game engine, creating a first rendering function interface and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering; Rendering the application interface of the target application through the first rendering function interface to display the application interface; In response to a trigger operation on the application interface, obtaining an operation position of the trigger operation; Taking the pixel point on the application interface hit by the operation position as the target pixel point; Determine the image object to be detected based on the target pixel point; Calling the second rendering function interface to draw the image object to be detected; Calling the second rendering function interface to obtain a target color parameter of the target pixel point, and determining whether the target color parameter satisfies a preset collision condition; If the target color parameter satisfies the preset collision condition, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected. 2. The method according to claim 1, characterized in that the method further comprises: A specified attribute is set for the image object corresponding to the second rendering function interface, wherein the specified attribute is used to indicate that the image object will not be rendered so that the image object is used for pixel collision detection. 3. The method according to claim 2, characterized in that the step of determining the image object to be detected based on the target pixel point comprises: When it is detected that the attribute value of the designated attribute of the image object corresponding to the target pixel point is a preset attribute value, the image object is determined to be the image object to be detected. 4. The method according to claim 3, characterized in that the calling of the second rendering function interface to draw the image object to be detected comprises: The second rendering function interface is called to draw the image object to be detected to obtain a drawn image object. 5. The method according to claim 4, characterized in that the calling the second rendering function interface to obtain the target color parameter of the target pixel point and determining whether the target color parameter meets the preset collision condition comprises: Performing data acquisition processing on the drawn image object based on the pixel coordinates of the target pixel and a preset size to obtain a target array; A target color parameter of the target pixel is determined from the target array based on the pixel coordinates, and it is determined whether the target color parameter satisfies a preset collision condition. 6. The method according to claim 5, characterized in that the target color parameter includes a target transparency value; The determining whether the target color parameter satisfies a preset collision condition includes: Determining whether the target transparency value is a specified reference transparency value; If not, it is determined that a pixel collision occurs between the trigger operation and the image object to be detected. 7. The method according to claim 2, characterized in that the method further comprises: A specified global object is created, where the specified global object is used to enable the second rendering function interface to draw the image object. 8. The method according to claim 7, characterized in that the calling of the second rendering function interface to draw the image object to be detected comprises: When the existence of the designated global object is detected, and the attribute value of the designated attribute of the image object to be detected is a preset attribute value, the image object to be detected is drawn based on the designated global object. 9. The method according to claim 7, characterized in that after creating the second rendering function interface, it also includes: Corresponding shader resources are allocated to the second rendering function interface based on the specified global object. 10. The method according to claim 1, characterized in that the step of taking the pixel point on the application interface hit by the operation position as the target pixel point comprises: If the operation position hits a pixel point of a specific interface element on the application interface, the pixel point is used as the target pixel point. 11. A collision detection device, comprising: A creation unit, used to start the game engine, create a first rendering function interface, and a second rendering function interface, wherein the second rendering function interface is configured to be unable to perform screen rendering; A first calling unit, configured to render an application interface of a target application through the first rendering function interface to display the application interface; A response unit, configured to obtain an operation position of the trigger operation in response to the trigger operation on the application interface; A processing unit, configured to take the pixel point on the application interface hit by the operation position as a target pixel point; A first determining unit, configured to determine an image object to be detected based on the target pixel point; A second calling unit, used for calling the second rendering function interface to draw the image object to be detected; A third calling unit, configured to call the second rendering function interface to obtain a target color parameter of the target pixel point, and determine whether the target color parameter satisfies a preset collision condition; The second determination unit is configured to determine that a pixel collision occurs between the trigger operation and the image object to be detected if the target color parameter satisfies the preset collision condition. 12. An electronic device, comprising a processor and a memory, wherein the memory stores a plurality of instructions; the processor loads instructions from the memory to execute the steps of the collision detection method according to any one of claims 1 to 10. 13. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a plurality of instructions, wherein the instructions are suitable for a processor to load to execute the steps of the collision detection method according to any one of claims 1 to 10.