Detection of unreal virtual objects

Abstract

Some implementations relate to methods and computer-readable media for detecting unrealistic textures in a virtual environment. In some implementations, one method includes receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object. The method further includes combining portions of two or more of the plurality of 2D polygons based on the pose or shape of the 3D virtual object to obtain one or more combined 2D polygons, calculating a corresponding hash value for each combined 2D polygon, determining whether there is a match between at least one of the corresponding hash values ​​and a hash value of at least one reference 2D polygon associated with a real object, and classifying the texture as an unrealistic texture if a match is determined to exist, otherwise classifying the texture as a real texture.

Description

[0001] Cross-references to related applications

[0002] This application claims priority to U.S. Patent Application No. 17 / 127,714, filed December 18, 2020, entitled "Detection of Unreal Virtual Objects," the entire contents of which are incorporated herein by reference. Technical Field

[0003] The various implementations generally relate to computer-based games, and more particularly to methods, systems, and computer-readable media for detecting unreal virtual objects. Background Technology

[0004] Some online platforms (e.g., gaming platforms, media exchange platforms, etc.) allow users to connect and interact with each other via the internet (e.g., within games), create games, and share information. Users of online gaming platforms can participate in multiplayer or virtual environments (e.g., 3D environments), design and customize game environments, design characters and avatars, decorate avatars, exchange virtual items / objects with other users, and communicate with other users using audio or text messages. Environments such as metaverses or multiverses can also allow participating users to share, sell, or trade objects they create with other users.

[0005] To prevent inauthentic objects from appearing on the game platform, a computationally efficient method may be needed to detect inauthentic virtual objects by comparing them with real virtual objects.

[0006] Some implementation methods are conceived based on the above. Summary of the Invention

[0007] A system of one or more computers can be used to perform specific operations or actions by installing software, firmware, hardware, or combinations thereof on the system, the software, firmware, hardware, or combinations thereof causing the system to perform actions during operation. One or more computer programs can be used to perform specific operations or actions by including instructions, which, when executed by a data processing device, cause the device to perform actions. A general aspect includes a computer-implemented method for detecting unrealistic textures in a virtual environment. This computer-implemented method further includes: receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on the pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; calculating a corresponding hash value for each combined 2D polygon; determining whether a match exists between at least one of the corresponding hash values ​​and a hash value of at least one reference 2D polygon associated with a real object; if a match is determined to exist, classifying the texture as an unrealistic texture; if no match is determined to exist, classifying the texture as a real texture. Other embodiments of this aspect include corresponding computer systems, apparatuses, and computer programs recorded on one or more computer storage devices for performing the actions of the methods described above.

[0008] Various implementations may include one or more of the following features. In the computer-implemented method described above, receiving a plurality of 2D polygons may include receiving a plurality of 2D polygons comprising a set of 2D polygons, the set of 2D polygons conforming to a predetermined size set and which may be combined based on a predetermined template to generate a texture for a 3D virtual object. The 3D virtual object is a clothing item associated with a virtual avatar. Combining two or more 2D polygons is based on an overlay arrangement of two or more 2D polygons, wherein the transparency of at least one of the two or more 2D polygons satisfies a threshold transparency. Determining whether a match exists may include: calculating a match score associated with a match between each hash value in the corresponding hash values ​​and the hash value of a reference 2D polygon associated with the real object; if the match score satisfies the threshold, a match is determined to exist. The computer-implemented method described above may include applying weights associated with portions of the combination of two or more 2D polygons to the match score. Combining portions of two or more 2D polygons is based on an ordered list of 2D polygons. One or more animations correspond to the movement of the 3D virtual object in a virtual environment. The ordered list of 2D polygons is based on one or more deformations of the 3D virtual object. The computer-implemented method described above may include, prior to combination: classifying the texture as a non-realistic texture if the hash value of at least one of a plurality of two-dimensional (2D) polygons associated with the texture of the 3D virtual object matches the hash value of a reference 2D polygon associated with a real object. Calculating the corresponding hash value may include using a perceptual hashing technique, wherein the hash values ​​of polygons with similar content have greater similarity than the hash values ​​of polygons with dissimilar content. The computer-implemented method described above may include providing a user interface that includes a realistic texture in a virtual environment. The 3D virtual object is an object that can be worn by a virtual avatar in a virtual environment. Various embodiments of the described techniques may include hardware, methods or processes, or computer software on a computer-accessible medium.

[0009] One general aspect includes a non-transitory computer-readable medium that may include instructions. The non-transitory computer-readable medium further includes receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on the pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; calculating a corresponding hash value for each combined polygon; determining whether a match exists between at least one of the corresponding hash values ​​and a hash value of at least one reference 2D polygon associated with a real object; if a match is determined to exist, classifying the texture as a non-real texture; if no match is determined to exist, classifying the texture as a real texture. Other embodiments of this aspect include corresponding computer systems, apparatuses, and computer programs recorded on one or more computer storage devices for performing the actions of the methods described above.

[0010] Various embodiments may include one or more of the following features. In the aforementioned non-transitory computer-readable medium, the combination of portions of two or more 2D polygons is based on an ordered list of 2D polygons. The operation may also include determining the ordered list of 2D polygons based on one or more animations in a virtual environment where the 3D virtual object is placed, wherein the one or more animations correspond to the movement of the 3D virtual object within the virtual environment. Various embodiments of the described technology may include hardware, methods or processes, or computer software on a computer-accessible medium.

[0011] The system also includes a memory storing instructions; and a processing device coupled to the memory, the processing device being used to access the memory and execute the instructions, wherein the instructions cause the processing device to perform operations including: receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on the pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; calculating a corresponding hash value for each combined polygon; determining whether there is a match between at least one of the corresponding hash values ​​and a hash value of at least one reference 2D polygon associated with a real object; if a match is determined to exist, classifying the texture as a non-real texture; and if no match is determined to exist, classifying the texture as a real texture. Other embodiments of this aspect include corresponding computer systems, apparatuses, and computer programs recorded on one or more computer storage devices for performing the actions of the methods described above.

[0012] Various implementations may include one or more of the following features. In the above system, the combination of two or more 2D polygons is based on an ordered list of 2D polygons. The ordered list of 2D polygons is based on one or more variations of a 3D virtual object. Calculating the corresponding hash value may include using perceptual hashing techniques, wherein the hash values ​​of polygons with similar content have greater similarity than the hash values ​​of polygons with dissimilar content. Various implementations of the described techniques may include hardware, methods or processes, or computer software on a computer-accessible medium. Attached Figure Description

[0013] Figure 1 This is a diagram of an example system architecture for detecting unreal virtual objects, based on some implementation methods.

[0014] Figure 2 Example templates for creating / generating virtual objects are shown according to some implementation methods.

[0015] Figure 3 An example 3D virtual object created using a template according to some implementation methods is shown.

[0016] Figure 4A A view of a 3D virtual object according to some implementations is shown.

[0017] Figure 4B A view of a 3D virtual object according to some implementations is shown.

[0018] Figure 5A A view of a virtual avatar according to some implementations is shown.

[0019] Figure 5B A view of a virtual avatar according to some implementations is shown.

[0020] Figure 6 This is a flowchart illustrating an example method for detecting unreal virtual objects according to some implementations.

[0021] Figure 7 This is a block diagram illustrating an example computing device according to some implementations. Detailed Implementation

[0022] In the following detailed description, reference is made to the accompanying drawings, which form part of the detailed description. In the drawings, similar symbols generally identify similar components unless the context otherwise requires. The illustrative embodiments described in the detailed description, drawings, and claims are not intended to be limiting. Other embodiments may be used and other changes may be made without departing from the spirit or scope of the subject matter shown herein. The aspects of this disclosure, as generally described herein and illustrated in the drawings, can be arranged, substituted, combined, separated, and designed into a variety of different configurations, all of which are contemplated herein.

[0023] The references to "some embodiments," "one embodiment," "example embodiment," etc., in the specification indicate that the described embodiments may include specific features, structures, or characteristics, but each embodiment may not necessarily include the aforementioned specific features, structures, or characteristics. Furthermore, such phrases do not necessarily refer to the same embodiment. Moreover, when a specific feature, structure, or characteristic is described in connection with an embodiment, such feature, structure, or characteristic may be implemented in conjunction with other embodiments, whether explicitly described or not.

[0024] Online gaming platforms (also known as "user-generated content platforms" or "user-generated content systems") offer a variety of ways for users to interact. For example, users on an online gaming platform can work together towards a common goal, share various virtual game projects, and send each other electronic messages. Users on an online gaming platform can join the game as virtual characters, playing specific roles within the game. For instance, a virtual character can be part of a team or multiplayer game environment, where each character is assigned a specific role and has corresponding parameters such as clothing, armor, weapons, and skills. In another example, when a single player is part of the game, a computer-generated character can be added as a virtual character.

[0025] Online gaming platforms can also allow users (developers) to create new games and / or characters. For example, users of an online gaming platform can be allowed to create, design, and / or customize new characters (avatars) and new animation packs, and make these new characters (avatars) and new animation packs available to other users.

[0026] In some cases, online gaming platforms can provide tools that enable users to create new characters, virtual objects, accessories, etc. In some implementations, the gaming platform can provide users with options to create and / or distribute virtual objects.

[0027] In some implementations, users may be provided with template tools to enable them to quickly create virtual objects of certain categories of objects and / or accessories.

[0028] New characters and animation packs (virtual objects) can be traded, exchanged, or bought and sold on online marketplaces using virtual currency and / or real currency. Virtual objects may be copied and redistributed without the knowledge of the counterfeit nature of the seller or buyer. In some cases, virtual objects may include copyrighted images. In some cases, virtual objects may include offensive and inappropriate content.

[0029] The proliferation of counterfeit and non-real virtual objects in the market may be difficult to detect, and the quantity and nature of virtual objects may make it difficult for human intervention to detect them.

[0030] The goal of game platform owners or administrators is to reduce inauthentic (fake) and / or offensive objects and to incentivize creators of original content. A technical challenge for online game platform operators is detecting inauthentic virtual objects across the entire online game platform.

[0031] Early detection of fictitious virtual objects can make it more difficult and / or costly for creators of such objects to create and distribute them. Game platforms that prevent the uploading of fictitious virtual objects can effectively deter their creators.

[0032] To evade detection, creators can sometimes manipulate original virtual objects to create manipulated objects. Even if the difference between the manipulated object and the real object is imperceptible, the manipulated object may still be classified as original through some unrealistic detection techniques.

[0033] Some images may infringe on logos or other proprietary property and evade detection by conventional image matching techniques by being configured to pass through the edges of template polygons (e.g., rectangles) or to be visible in specific deformations of virtual characters appearing in specific poses of the avatar. Forged (unrealistic) objects may be distributed across a portion of a 3D virtual object, making them difficult to detect in their original state, but visible in specific deformations, poses, and / or animation sequences of the 3D virtual object within the virtual environment. In some cases, forged (unrealistic) objects may be distributed across a portion of multiple 3D virtual objects, making them difficult to detect in their original state, but visible in specific poses and / or animation sequences when multiple 3D virtual objects are combined (e.g., by overlaying onto a virtual avatar) or when undergoing deformation or bone rigging within the virtual environment.

[0034] This disclosure addresses the aforementioned drawbacks by detecting unreal objects that are similar to real (authentic) objects known to the game platform. Unreal objects are detected using the similarity (perceptual hash matching) between unreal (fake) virtual objects and original virtual objects.

[0035] Perceptual hash matching uses a perceptual hash function, which is a fingerprint of a multimedia file (image file, audio file, video file, etc.) derived from various features of its content. If two files have similar underlying features, their perceptual hashes are close to each other. The perceptual hash function is designed to be robust enough to account for file transformations (rotation, skew, contrast adjustment, use of different compression / formats, etc.) and detect similarities between the transformed file and the original file.

[0036] This article describes various implementations for automatically detecting unreal objects on a gaming platform. Furthermore, these implementations can be designed to provide superior performance compared to a number of comparable virtual objects.

[0037] Figure 1 An example system architecture 100 according to some embodiments of this disclosure is shown. Figure 1 The same reference numerals are used to identify the same elements as in other figures. The letter following the reference numeral (e.g., "110") indicates that the text specifically refers to an element with that particular reference numeral. Reference numerals without a following letter in the text (e.g., "110") refer to any or all elements in the figure that bear that reference numeral (e.g., "110" in the text refers to reference numerals "110a", "110b", and / or "110n" in the figure).

[0038] System architecture 100 (also referred to herein as the "system") includes an online game server 102, a data storage area 120, client devices 110a, 110b, and 110n (collectively referred to herein as "client device 110"), and developer devices 130a and 130n (collectively referred to herein as "developer device 130"). Game server 102, data storage area 120, client device 110, and developer device 130 are coupled via network 122. In some implementations, client device 110 and developer device 130 may refer to the same device or devices of the same type.

[0039] In addition, the online game server 102 may include a game engine 104, one or more games 106, and a graphics engine 108. In some embodiments, the graphics engine 108 may be a system, application, or module that allows the online game server 102 to provide graphics and animation capabilities. In some embodiments, the graphics engine 108 may perform the following combined Figure 6The flowchart shown describes one or more operations. Client device 110 may include game application 112 and input / output (I / O) interface 114 (e.g., input / output device). Input / output device may include one or more of the following: microphone, speaker, headphones, display device, mouse, keyboard, game controller, touch screen, virtual reality console, etc.

[0040] Developer device 130 may include game application 132 and input / output (I / O) interface 134 (e.g., input / output device). Input / output device may include one or more of the following: microphone, speaker, headphones, display device, mouse, keyboard, game controller, touch screen, virtual reality console, etc.

[0041] A system architecture 100 is provided for illustration. In different implementations, the system architecture 100 may include configurations that are compatible with... Figure 1 The same, fewer, more, or different components are configured in the same or different ways as shown.

[0042] In some implementations, network 122 may include a public network (e.g., the Internet), a private network (e.g., a local area network (LAN) or a wide area network (WAN)), a wired network (e.g., Ethernet), or a wireless network (e.g., an 802.11 network). Networks, or wireless LANs (WLANs), cellular networks (such as 5G networks, long term evolution (LTE) networks, etc.), routers, hubs, switches, server computers, or combinations thereof.

[0043] In some implementations, data storage area 120 may be a non-transitory computer-readable storage device (e.g., random access memory), a cache, a drive (e.g., a hard disk drive), a flash drive, a database system, or another type of component or device capable of storing data. Data storage area 120 may also include multiple storage components (e.g., multiple drives or multiple databases) that may span multiple computing devices (e.g., multiple server computers). In some implementations, data storage area 120 may include cloud-based storage.

[0044] In some implementations, the online game server 102 may include a server with one or more computing devices (e.g., a cloud computing system, rack server, server computer, physical server cluster, etc.). In some implementations, the online game server 102 may be a standalone system, may include multiple servers, or may be part of another system or server.

[0045] In some implementations, the online game server 102 may include one or more computing devices (e.g., rack servers, router computers, server computers, personal computers, mainframe computers, laptop computers, tablet computers, desktop computers, etc.), data storage areas (e.g., hard disks, storage devices, databases), networks, software components, and / or hardware components that can be used to perform operations on the online game server 102 and provide users with access to the online game server 102. The online game server 102 may also include website (e.g., web pages) or application backend software that can be used to provide users with access to content provided by the online game server 102. For example, a user can access the online game server 102 using a game application 112 on a client device 110.

[0046] In some implementations, game session data is generated via online game server 102, game application 112, and / or game application 132, and stored in data storage area 120. With the permission of the game players, game session data may include associated metadata, such as game identifiers; device data associated with the player; player demographics; game session identifiers; chat logs; session start time, session end time, and session duration for each player; relative positions of participant avatars within the virtual game environment; in-game purchases by one or more players; accessories used by the game players, etc.

[0047] In some implementations, the online game server 102 may be a social network providing connectivity between users, or a user-generated content system allowing users (e.g., end users or consumers) to communicate with other users through the online game server 102. This communication may include voice chat (e.g., synchronous and / or asynchronous voice communication), video chat (e.g., 1:1 and / or N:N synchronous and / or asynchronous video communication), or text chat (e.g., synchronous and / or asynchronous text-based communication). Records of some or all user communications may be stored in data storage area 120 or within the game 106. Data storage area 120 may be used to store chat logs (text, audio, images, etc.) exchanged between players.

[0048] In some implementations, chat logs are generated via game application 112 and / or game application 132, or stored in data storage area 120. Chat logs may include chat content and associated metadata, such as the text content of the chat, each message having a corresponding sender and receiver; message formatting (e.g., bold, italic, cursive, etc.); message timestamps; the relative positions of participant avatars in the virtual game environment; accessories used by game participants, etc. In some implementations, chat logs may include multilingual content, and messages in different languages ​​from different game sessions may be stored in data storage area 120.

[0049] In some implementations, chat logs can be stored based on timestamps as a form of conversation between participants. In other implementations, chat logs can be stored based on the message initiator.

[0050] In some embodiments of this disclosure, "user" may refer to an individual. However, other embodiments of this disclosure encompass "user" as a group of users or an entity under automated source control (e.g., creative users). For example, a group of individual users united as a community or group in a user-generated content system can be considered "user".

[0051] In some implementations, the online game server 102 may be a virtual game server. For example, the game server may offer single-player or multiplayer games to a user community, who can access or interact with the game via network 122 using client devices 110. In some implementations, the game (also referred to herein as a "video game," "online game," or "virtual game") may be, for example, a two-dimensional (2D) game, a three-dimensional (3D) game (e.g., a user-generated 3D game), a virtual reality (VR) game, or an augmented reality (AR) game. In some implementations, users can participate in the game with other users. In some implementations, the game can be played in real-time with other users in the game.

[0052] In some implementations, gameplay may refer to one or more players interacting within a game (e.g., 106) using a client device (e.g., 110), or the interaction being presented on a display or other output device (e.g., 114) of the client device 110.

[0053] In some implementations, game 106 may include an electronic file that can be executed or loaded using software, firmware, or hardware for presenting game content (e.g., digital media projects) to an entity. In some implementations, game application 112 may be executed and combined with game engine 104 to render game 106. In some implementations, game 106 may have a set of common rules or common objectives, and the environment of game 106 may share this set of common rules or common objectives. In some implementations, different games may have different rules or objectives from each other.

[0054] In some implementations, a game may have one or more environments (also referred to herein as "game environments" or "virtual environments"), wherein multiple environments may be linked. An example of an environment may be a three-dimensional (3D) environment. One or more environments of game 106 may be collectively referred to herein as "worlds," "game worlds," "virtual worlds," or "universes." An example of a world may be a 3D world of game 106. For example, a user may construct a virtual environment linked to another virtual environment created by another user. Characters in a virtual game may cross virtual boundaries to enter adjacent virtual environments.

[0055] It can be noted that 3D environments or 3D worlds use graphics that represent a three-dimensional representation of the game content using geometric data (or at least render the game content as 3D content, regardless of whether a 3D representation of geometric data is used). 2D environments or 2D worlds use graphics that represent a two-dimensional representation of the game content using geometric data.

[0056] In some implementations, online game server 102 may host one or more games 106 and may allow users to interact with games 106 using game application 112 on client device 110. Users of online game server 102 may play, create, interact with, or build games 106, communicate with other users, and / or create and build objects of game 106 (e.g., also referred to herein as “projects”, “game objects”, or “virtual game projects”).

[0057] For example, when generating user-generated virtual items, users can create characters, character decorations, one or more virtual environments for interactive games, or construct structures used in game 106. In some implementations, users can buy, sell, or trade virtual game objects, such as in-platform currency (e.g., virtual currency), with other users on online game server 102. In some implementations, online game server 102 can send game content to a game application (e.g., 112). In some implementations, game content (also referred to herein as "content") can refer to any data or software instructions (e.g., game objects, games, user information, videos, images, commands, media items, etc.) associated with online game server 102 or the game application. In some implementations, game objects (e.g., also referred to herein as "items," "objects," "virtual objects," or "virtual game items") can refer to objects used, created, shared, or otherwise depicted in game application 106 on online game server 102 or game application 112 on client device 110. For example, game objects can include parts, models, characters, accessories, tools, weapons, clothing, buildings, vehicles, currency, flora, fauna, and components of the above objects (such as windows of buildings).

[0058] It should be noted that the online game server 102 providing hosting for game 106 is for illustrative purposes and not for limitation. In some embodiments, the online game server 102 may host one or more media items, which may include communication messages from one user to one or more other users. With user permission and explicit user consent, the online game server 102 may analyze chat log data to improve the game platform. Media items may include, but are not limited to, digital videos, digital movies, digital photos, digital music, audio content, melodies, website content, social media updates, e-books, e-magazines, digital newspapers, digital audiobooks, e-journals, web blogs, real simplesyndication (RSS) feeds, e-comic books, software applications, etc. In some embodiments, media items may be electronic files, which may be executed or loaded using software, firmware, or hardware configured to present digital media items to entities.

[0059] In some implementations, game 106 may be associated with a specific user or group of users (e.g., a private game) or be widely available to users who can access online game server 102 (e.g., a public game). In some implementations where online game server 102 associates one or more games 106 with a specific user or group of users, online game server 102 may use user account information (e.g., user account identifiers such as username and password) to associate a specific user with game 106.

[0060] In some implementations, the online game server 102 or client device 110 may include a game engine 104 or a game application 112. In some implementations, the game engine 104 may be used for the development or execution of game 106. For example, the game engine 104 may include a rendering engine (“renderer”) for 2D, 3D, VR, or AR graphics, a physics engine, a collision detection engine (and collision response), a sound engine, scripting capabilities, an animation engine, an artificial intelligence engine, networking capabilities, streaming capabilities, storage management capabilities, threading capabilities, scene graph capabilities, or animation video support, and other capabilities. Components of the game engine 104 may generate commands that help calculate and render the game (e.g., rendering commands, collision commands, physics commands, etc.). In some implementations, the game application 112 of the client device 110 may operate independently and / or collaborate with the game engine 104 of the online game server 102.

[0061] In some implementations, both the online game server 102 and the client device 110 execute game engines (104 and 112, respectively). The online game server 102, using game engine 104, may execute some or all of the game engine functions (e.g., generating physics commands, rendering commands, etc.), or may offload some or all of the game engine functions to the game engine 104 on the client device 110. In some implementations, the ratio between the game engine functions executed on the online game server 102 and the game engine functions executed on the client device 110 may be different for each game 106. For example, the game engine 104 of the online game server 102 may be used to generate physics commands in the event of a collision between at least two game objects, while additional game engine functions (e.g., generating rendering commands) may be offloaded to the client device 110. In some implementations, the ratio of game engine functions executed on the online game server 102 and the client device 110 may be changed based on game conditions (e.g., dynamically). For example, if the number of users playing a particular game 106 exceeds a threshold, the online game server 102 can execute one or more game engine functions previously executed by the client device 110.

[0062] For example, a user can play game 106 on client device 110 and send control commands (e.g., user input (e.g., right, left, up, down), user selection, or character position and speed information, etc.) to online game server 102. After receiving control commands from client device 110, online game server 102 can send gameplay commands (e.g., position and speed information or commands for characters participating in the game, such as rendering commands, collision commands, etc.) to client device 110 based on the control commands. For example, online game server 102 can perform one or more logical operations on the control commands (e.g., using game engine 104) to generate gameplay commands for client device 110. In other instances, online game server 102 can pass one or more control commands from one client device 110 to other client devices participating in game 106 (e.g., client devices 110a to client devices 110b). Client device 110 can use the gameplay commands and render the game for display on client device 110's screen.

[0063] In some implementations, control commands may refer to instructions that direct a user character's actions in the game. For example, control commands may include user input controlling in-game actions (e.g., right, left, up, down), user selections, gyroscope position and orientation data, force sensor data, etc. Control commands may include character position and velocity information. In some implementations, control commands are sent directly to the online game server 102. In other implementations, control commands may be sent from client device 110 to another client device (e.g., client devices 110b to 110n), wherein the other client device generates gameplay instructions using a local game engine 104. Control commands may include instructions to play voice communication messages or other sounds from another user on an audio device (e.g., a speaker, headphones, etc.), such as voice communication or other sounds generated using audio spatialization techniques as described herein.

[0064] In some implementations, gameplay instructions can be instructions that enable the client device 110 to render gameplay of a game (e.g., a multiplayer game). Gameplay instructions can include one or more of user input (e.g., control instructions), character position and velocity information, or commands (e.g., physics commands, rendering commands, collision commands, etc.).

[0065] In some implementations, characters (or typically game objects) are constructed from components, one or more of which can be selected by the user and are automatically linked together to aid the user in editing.

[0066] In some implementations, the character is implemented as a 3D model and includes a layered collection of surfaces (also called skin or mesh) and interconnected bones (also called skeleton or rig) used to draw the character. This rig can be used to animate the character and simulate its movement and actions. The 3D model can be represented as a data structure, and one or more parameters of this data structure can be modified to change various attributes of the character, such as size (height, width, perimeter, etc.); body type; movement style; number / type of body parts; proportions (e.g., shoulder-to-hip ratio); head size, etc.

[0067] One or more characters (also referred to herein as "avatars" or "models") may be associated with a user, whereby the user can control the character to facilitate the user's interaction with the game.

[0068] In some implementations, a character may include components such as body parts (e.g., hair, arms, legs, etc.) and accessories (e.g., T-shirts, glasses, decorative images, tools, etc.). In some implementations, customizable body parts of the character include head type, body part type (arms, legs, torso, and hands), face type, hair type, and skin type. In some implementations, customizable accessories include clothing (e.g., shirts, trousers, hats, shoes, glasses, etc.), weapons, or other tools.

[0069] In some implementations, for certain asset types (such as shirts, trousers, etc.), online gaming platforms may provide users with access to simplified 3D virtual object models, which are represented by a grid with a low polygon count (e.g., between approximately 20 and 30 polygons).

[0070] In some implementations, the user can also control the character's proportions (e.g., height, width, or depth) or the proportions of the character's components. In some implementations, the user can control the proportions of the character (e.g., blocky, anatomical, etc.). It can be noted that in some implementations, the character may not include the character's game objects (e.g., body parts, etc.), but the user can control the character (without character game objects) to facilitate user interaction with the game (e.g., a puzzle game without rendered character game objects, but where the user still controls the character to control in-game actions).

[0071] In some implementations, components such as body parts can be primitive geometries (e.g., blocks, cylinders, spheres, etc.) or other primitive shapes (e.g., wedges, tori, tubes, channels, etc.). In some implementations, the creator module can publish a user's character for other users on the online game server 102 to view or use. In some implementations, creating, modifying, or customizing characters, other game objects, game 106, or the game environment can be performed by the user using an I / O interface (e.g., a developer interface) and with or without scripts (or with or without an application programming interface (API)). It can be noted that, for illustration, characters are described as having a humanoid form. It can also be noted that characters can have any form, such as vehicles, animals, inanimate objects, or other creative forms.

[0072] In some implementations, the online game server 102 may store user-created characters in data storage 120. In some implementations, the online game server 102 maintains a character directory and a game directory that can be presented to users via the online game server 102. In some implementations, the game directory includes images of games stored on the online game server 102. Furthermore, users can select characters (e.g., characters created by themselves or other users) from the character directory to participate in selected games. The character directory includes images of characters stored on the online game server 102. In some implementations, one or more characters in the character directory may have already been created or customized by the user. In some implementations, the selected character may have character settings that define one or more components of that character.

[0073] In some implementations, a user's role may include the configuration of components, wherein the configuration and appearance of the components, and more generally the appearance of the role, can be defined by role settings. In some implementations, the role settings of a user's role may be at least partially selected by the user. In other implementations, the user may select a role with default role settings or other user-selected role settings. For example, a user may select a default role from a directory of roles with predefined role settings, and the user may further customize the default role by changing some role settings (e.g., adding a shirt with a custom logo). Role settings can be associated with specific roles via the online game server 102.

[0074] In some embodiments, client devices 110 may each include computing devices such as personal computers (PCs), mobile devices (e.g., laptops, mobile phones, smartphones, tablets, or netbooks), internet televisions, game consoles, etc. In some embodiments, client devices 110 may also be referred to as "user devices." In some embodiments, one or more client devices 110 may connect to the online game server 102 at any given time. It should be noted that the number of client devices 110 is provided for illustrative purposes. In some embodiments, any number of client devices 110 may be used.

[0075] In some implementations, each client device 110 may include an instance of a game application 112. In one implementation, the game application 112 may allow a user to interact with and use an online game server 102, such as controlling virtual characters in a virtual game hosted by the online game server 102, or viewing or uploading content (e.g., game 106, images, video items, web pages, documents, etc.). In one example, the game application may be a web application (e.g., an application that operates in conjunction with a web browser), which can access, retrieve, render, or navigate content served by a web server (e.g., virtual characters in a virtual environment). In another example, the game application may be a local application (e.g., a mobile application, app, or game program) that is installed and executed locally on the client device 110 and allows the user to interact with the online game server 102. The game application may render, display, or present content to the user (e.g., a web page, a media viewer). In implementations, the game application may also include an embedded media player embedded in a web page (e.g., a web page, a media viewer). (Player).

[0076] According to various aspects of this disclosure, the game application can be an online game server application, allowing users to build, create, edit, upload content to the online game server 102, and interact with the online game server 102 (e.g., play game 106 hosted by the online game server 102). Therefore, the game application can be provided to the client device 110 by the online game server 102. In another example, the game application can be an application downloaded from the server.

[0077] In some implementations, each developer device 130 may include an instance of a game application 132. In one implementation, the game application 132 may allow the developer user to use and interact with the online game server 102, such as controlling virtual characters in a virtual game hosted by the online game server 102, or viewing or uploading content (e.g., game 106, images, video items, web pages, documents, etc.). In one example, the game application may be a web application (e.g., an application that operates in conjunction with a web browser), which can access, retrieve, render, or navigate content served by the web server (e.g., virtual characters in a virtual environment). In another example, the game application may be a native application (e.g., a mobile application, app, or game program) that is installed and executed locally on the client device 130 and allows the user to interact with the online game server 102. The game application may render, display, or present content to the user (e.g., a web page, a media viewer). In implementations, the game application may also include an embedded media player embedded in a web page (e.g., a web page, a media viewer). (Player).

[0078] According to various aspects of this disclosure, game application 132 can be an online game server application, allowing users to build, create, edit, and upload content to online game server 102 and interact with online game server 102 (e.g., providing and / or playing games 106 hosted by online game server 102). Therefore, the game application can be provided to client device 130 by online game server 102. In another example, game application 132 can be an application downloaded from the server. Game application 132 can be used to interact with online game server 102 and obtain access to user credentials, user currency, etc., of one or more games 106 developed, hosted, or provided by game developers.

[0079] In some implementations, users can log in to online game server 102 via a game application. Users can access user accounts by providing user account information (e.g., username and password), where the user account is associated with one or more characters available to participate in one or more games 106 on online game server 102. In some implementations, game developers can obtain access to virtual game objects owned or associated with other users, such as in-platform currency (e.g., virtual currency), avatars, special privileges, and accessories, through appropriate credentials.

[0080] Typically, functions described as being performed by online game server 102 in one embodiment may also be performed by client device 110 or server in other embodiments, if appropriate. Furthermore, functions belonging to a particular component may be performed by different or multiple components operating together. Online game server 102 can also be accessed as a service provided to other systems or devices through appropriate application programming interfaces (APIs), and is therefore not limited to use on a website.

[0081] Figure 2 Example templates 200, 220, and 240, according to some implementations, are shown for use in generating virtual objects. Users can use these example templates to create virtual objects, such as avatars (e.g., humanoid characters), accessories (e.g., clothing, footwear, headwear, etc.), etc., for use in a virtual environment.

[0082] In some implementations, the example template may specify a set of 2D polygons that conform to a predetermined set of sizes and can be combined based on the predetermined template to generate a texture of a 3D virtual object.

[0083] In some implementations, templates 200, 220, and 240 may be graphical templates stored on online game server 102 (e.g., in data storage 120), one or more client devices 110, and / or developer devices 130. In some implementations, templates 200 and 220 may be rendered by game engine 104 on either client device 110 or developer device 130.

[0084] In some implementations, templates 200, 220, and 240 may be provided to users (e.g., to developers) via a graphical user interface of an online gaming platform, which allows users to view and / or design different 3D virtual objects. In some implementations, the templates include multiple 2D polygons corresponding to different views and / or surfaces associated with the 3D virtual objects.

[0085] Users (developers) can, for example, use photo editor tools to edit and create 3D virtual objects based on templates by adding images, artwork, text, and other design elements. In some implementations, users can open the template in an image editor on a local user device (e.g., client device 110 or developer device 130) and create new 3D virtual objects by editing the textures associated with any 2D polygons in the template within the image editor.

[0086] In some implementations, each template may correspond to a specific body part of a virtual avatar in the virtual environment. For example, the torso may correspond to the avatar's torso, the left side may correspond to the left arm / leg, and the right side may correspond to the right arm / leg. However, in some cases, it may be permissible for a portion corresponding to one body part (e.g., the torso) to overlay different body parts (e.g., the head). In this case, the overlay may be imperfect; for example, the portion of the template may be ignored (e.g., not displayed) when the virtual avatar is rendered.

[0087] like Figure 2 As shown, template 200 is a template for creating 3D virtual objects (e.g., accessories such as shirts or pants) for virtual avatars in a virtual environment. In some embodiments, template 200 includes 2D polygons representing different parts of the 3D virtual object. In this illustrative example, template 200 can be used to design the torso portion of a 3D virtual object, such as a shirt associated with a virtual avatar. For example, template 200 includes an upper (top) portion 202 represented by U, a lower (bottom) portion 204 represented by D, a front portion 206 represented by F, a right portion 208 represented by R, a left portion 210 represented by L, and a back portion 212 represented by B. Template 200 can be provided as a guide for designing 3D virtual objects (e.g., clothing accessories) for use in a virtual environment provided by an online gaming platform.

[0088] In some implementations, template 200 may include gridlines that can be used to guide user design within template 200. In some implementations, template 200 may include reference coordinates that can precisely define points and regions within the template.

[0089] Templates 220 and 240 can be used to design the arms or legs of 3D virtual objects, such as pants or shirts for a virtual avatar in a virtual environment.

[0090] In some implementations, template 220 can be used to create the right arm or right leg portion of a 3D virtual object. Template 220 includes a left portion 222 represented by L, a back portion 224 represented by B, a right portion 226 represented by R, an upper portion 228 represented by U, a front portion 232 represented by F, and a lower portion 230 represented by D.

[0091] In some implementations, template 240 can be used to create the left arm or left leg portion of a 3D virtual object. Template 240 includes a left portion 242 represented by L, a back portion 244 represented by B, a right portion 246 represented by R, an upper portion 248 represented by U, a front portion 252 represented by F, and a lower portion 250 represented by D.

[0092] In some implementations, one or more additional features may be included in templates 200, 220, and 240. For example, a pre-designed image or feature may be included in the template, which the user may use as part of their user design.

[0093] In some implementations, when the template is overlaid on the virtualization along with other 3D virtual objects such as shoes, hats, etc., markers can be provided on the template to indicate the areas that overlap with these 3D virtual objects.

[0094] In some implementations, textures can indicate the color and / or pattern of the outer surface of a virtual 3D object. Textures can have attributes that may include transparency (variable degrees from completely transparent to completely opaque), reflectivity (how virtual light reflects from the texture), the diffuseness of incident light within the virtual environment, material properties (e.g., how the texture stretches, folds, creases, etc., when the virtual avatar covering the 3D object has different shapes and / or poses), and refractive properties of the texture and mesh associated with the virtual 3D object. Some examples of textures include grass, light blue glass, ice, water, concrete, brick, carpet, wood, etc. Virtual environments may allow for other synthetic textures that do not exist in the real world, such as wrinkled ice, bendable bricks, etc.

[0095] In some implementations, dimensions can be specified for one or more 2D polygons. For example, in some implementations, the dimensions of the front and rear portions of the torso can be 128 × 128 pixels. The dimensions of the top and bottom portions of the torso can be 128 × 64 pixels. In some implementations, the dimensions of the top and bottom portions of the arms and legs can be 64 × 64 pixels. In some implementations, the dimensions of the sides of the torso and arms / legs can be 64 × 128 pixels.

[0096] Figure 3 An example 3D virtual object created using a template according to some implementation methods is shown.

[0097] In different implementations, the templates can be used to create composite 3D virtual objects that can be used as accessories (e.g., clothing items for virtual avatars).

[0098] In some implementations, the template may be stored in a storage device and / or memory (e.g., in data storage 120, on client device 110, or on developer device 130). The template allows the user to depict specific features of a 3D virtual object. A user interface may be provided to the user of developer device 130 that enables, for example, the use of game application 132 to design accessories.

[0099] Figure 3An example 3D virtual object created using a template according to some implementation methods is shown.

[0100] In some implementations, 2D polygons in the template are folded and / or wrapped around the torso, arms, and / or legs of the avatar (character). A 3D virtual object is generated using content (e.g., images) included in each 2D polygon. Textures of the corresponding surfaces (sides) of the 3D virtual object are generated by combining multiple 2D polygons in a specific arrangement based on the shape and / or pose of the 3D virtual object, which in turn can be based on the shape and / or pose of the avatar to which the 3D virtual object is attached.

[0101] In some implementations, the shape of the 3D virtual object is associated with the shape of the underlying virtual object, wherein the body parts of the character (avatar) can be connected by a grid that provides the definition of the character's shape.

[0102] This illustrative example shows a shirt 350 used for a virtual avatar, the texture of which is created using a template 300 for the torso, a template 330 for the right arm, and a template 340 for the left arm. (See example...) Figure 3 As shown, texture data from 2D polygons in templates 300, 330, and 340 are combined to generate a 3D virtual object, namely the shirt 350 associated with the virtual avatar (character). Figure 3 As shown, a shirt is generated using a design (image) included in a 2D polygon, which includes the design at the corresponding position mapped onto the shirt worn by the avatar.

[0103] Specifically, the front portion 365 of the shirt includes a design 315 from a 2D polygon 310 of the torso template, and the arms 355 and 360 of the shirt include corresponding designs from a 2D polygon 335 of the front portion of the right arm and a 2D polygon 345 of the front portion of the left arm.

[0104] The virtual 3D object is rendered by game server 102 (e.g., via graphics engine 108). In some implementations, this rendering causes one or more images to be generated based on the 3D model of the virtual 3D object. In some implementations, the rendering may be performed at a resolution different from the resolution specified in the template file.

[0105] from Figure 3As can be seen, templates 300, 330, and 340 are attached to (fold and / or wrap around) the virtual avatar to present the avatar as wearing a shirt 350. Furthermore, it can be understood that when the avatar's posture changes (e.g., arms fold or rotate, torso bends or stretches, etc.), corresponding deformations are automatically applied to the shirt 350. For example, when the left arm is partially bent, the parallelogram on the left arm portion 360 can be compressed accordingly. In another example, based on the template's material properties, the parallelogram can be "wrinkled" or "rumpled" to achieve this shirt effect. In another example, if the avatar stretches its torso upwards, the circle 315 on the front portion 365 of the shirt can be elongated into an ellipse.

[0106] Furthermore, based on the shape of the virtual character, corresponding deformations are automatically applied to the shirt 350. For example, based on whether the virtual character is thin or muscular and based on the arm shape defined for the virtual character, the parallelograms on the left and right arms can have different angles.

[0107] Figure 4A A view of a 3D virtual object according to some implementations is shown.

[0108] In some implementations, the camera view in the virtual environment can produce different views of the 3D virtual object. In some implementations, a user can use one or more camera views to view the presented virtual 3D object.

[0109] The camera view can be provided by a virtual camera, which can be located at different viewpoints in the 3D world to generate different views of the 3D virtual object. The position and capture resolution of the virtual camera can also be updated / changed. For example, in some implementations, the camera view may include features that zoom in and out and / or capture images of the virtual object at higher or lower resolutions.

[0110] In some implementations, the movement of the virtual avatar is achieved through animation routines associated with the virtual avatar. In some implementations, the 3D virtual object associated with the virtual avatar undergoes changes (morphings) corresponding to the animation associated with the virtual avatar. For example, if the virtual avatar is animated such that it performs a dance through the movement of its head, torso, arms, and legs, the 3D virtual object can also undergo corresponding changes.

[0111] In some implementations, the movement of the virtual avatar is simulated by the movement of the corresponding 2D or 3D object. Accordingly, one or more 2D polygons associated with the 3D virtual object also undergo movement and / or deformation.

[0112] The movement / movement of a virtual avatar and any associated 3D virtual object can realize the corresponding movement of any texture (design) provided (e.g., overlay) on the 3D virtual object. This movement can also cause changes in the position of textures on the 3D virtual object, such as those captured in a camera view and viewed by the user.

[0113] In some cases, users may include inappropriate and / or offensive content (adult content, content that violates copyright, content that violates the policies set by the game developer and / or game platform, etc.) that does not appear directly in a single view or subview, but is distributed in different areas of the object, but these areas are adjacent, for example, during animation or when the avatar of the wearing object enters a specific pose.

[0114] In some cases, inappropriate content can be distributed across different objects or multiple objects (e.g., a portion of pants and a portion of a shirt, a portion of two pairs of pants, etc.). Furthermore, an avatar can be configured to wear multiple 3D virtual objects, such as pants and / or a shirt, portions of which can be defined by the user as completely or partially transparent, and then used to include inappropriate or infringing content. For example, multiple partially transparent 3D virtual objects can be composed of the same portion of a view (slot), such that the view includes the inappropriate content even when the individual 3D virtual objects do not contain it.

[0115] Some images may infringe on logos or other proprietary property and may evade detection by conventional image matching techniques by being configured to pass through the edges of template polygons (e.g., rectangles) or to be visible in specific deformations of virtual characters appearing in specific poses of avatars.

[0116] In some implementations, when new 3D objects are uploaded to the game platform, these objects can be verified / checked against a database of real-world objects (e.g., images, patterns, etc.). All received 2D polygons associated with textures can be compared to a set of objects (e.g., reference images, previously authenticated textures, identifiers, etc.) stored on the online game platform. Based on defined adjacency, 2D polygons are combined, and images of the combined adjacent 2D polygons are captured and compared with stored real-world objects (e.g., reference images).

[0117] In this illustrative example, a real object (image) 410 that has been identified as a real image is shown.

[0118] Uploading can be performed by providing a set of 2D polygons, for example, refer to... Figure 3 The templates described are variations of 300, 330, and 350.

[0119] Figure 4AReal objects (images) 410 that are not permitted in the game environment are shown. For example, real objects 410 may be copyrighted images, images identified as inappropriate (e.g., adult-themed images), or images identified as not permitted. Figure 4A A 3D virtual object 420 associated with the virtual avatar, generated based on a combination of provided 2D polygons, is also shown. The 2D polygons are combined based on a predefined template (e.g., a template for generating a shirt from a provided set of 2D polygons). As shown, in the default camera view, no violation is observed when the virtual avatar is in a standing pose 420. In this pose, texture portions 425 and 430 appear on the torso and right front portion of the shirt. However, in a pose (440) where the virtual avatar is observed to be extending its arms, the proximity of the corresponding torso 2D polygons and right front 2D polygons creates a view that makes texture portion 445 now look similar to the real object 410. Such visual representation, even if it is transient in nature, may be unacceptable, therefore detecting such visual representation is important.

[0120] In some implementations, similarity between a real image and one or more views of an object in a virtual environment is detected by comparing a texture (image) generated from an unverified set of 2D polygons of an object with a previously received real image. In some implementations, the comparison uses hash matching of images generated by combining unverified sets of 2D polygons of various poses and / or shapes.

[0121] In some implementations, 2D polygons are combined based on a set of poses and movements (e.g., poses and movements from animation) of the 3D virtual object and any associated virtual character. For example, adjacent 2D polygons from a 3D virtual object can be combined, and the texture generated from the combined polygons can be compared with previously received and authenticated objects (images) to detect similarity.

[0122] In some implementations, approximate hash matching (fuzzy matching, where a match that is not 100% perfect is still considered a match) is used to compare each of the received 2D polygons and combinations of 2D polygons with a real object to detect similar views. A hash value is calculated for each image and used as a fingerprint or watermark for the image. The hash value can be a fixed-length and / or structured alphanumeric value and can be generated by a hash function that takes the image file as input and computes the corresponding hash value.

[0123] In some implementations, approximate hash matching techniques can be used to determine that compared objects are not identical, but similar in that they are within a threshold distance of each other, where the difference between corresponding hashes is a measure of the similarity between the objects. In some implementations, perceptual hashing techniques can be used, which use a hash function and a threshold to determine whether compared objects (e.g., images) are likely to be similar. For example, perceptual hashing can be used to determine whether compared objects have similar characteristics. Furthermore, because the hash value of the manipulated object (e.g., an image) is similar to the hash value of the original object modified to generate the manipulated object, these techniques are unaffected by adversarial manipulation, such as attempts to impersonate a fake object as a real one.

[0124] Perceptual hash functions can be used to extract features of interest from an image, and hash values ​​can be calculated based on these features. A perceptual hash function can be designed such that the hash values ​​of the original object and the object to be authenticated (calculated using the perceptual hash function) are similar when the objects are perceptually similar (e.g., visually similar), and dissimilar when the objects are perceptually dissimilar.

[0125] In this illustrative example, based on the above comparison, and based on the similarity between the detected texture portion 445 and the real object 410, it is determined that the texture associated with the virtual 3D object corresponding to views 420 and 440 is not real.

[0126] Figure 4B A view of a 3D virtual object according to some embodiments is shown. In this illustrative example, a real image 490, which has been identified as a real object, is shown.

[0127] This illustrative example shows a sample 3D virtual object (shirt) created based on texture information provided via a set of 2D polygons. Specifically, the set of 2D polygons, including a 2D polygon 450 for the front torso and a 2D polygon 460 for the right side of the right arm based on a shirt template, is provided, for example, by a user who uploads a set of 2D polygons to define the 3D virtual object on an online gaming platform.

[0128] Figure 4B A side view of the virtual avatar and 3D virtual object is shown. As shown, when viewed from the side, the combination of texture design features of polygons 450 and 460 from a specific pose (where a portion of 2D polygon 450 appearing on the torso is combined with a portion of another 2D polygon 460 appearing on the right arm) results in an image 480 that resembles a real image 490.

[0129] In this illustrative example, based on the comparison described above, and based on the similarity between the detected texture associated with the received virtual 3D object, which includes 2D polygons 450 and 460, and the real object 490, it is determined that the texture is not real.

[0130] Figure 5A A view of a virtual avatar according to some implementations is shown. In this illustrative example, a real image (object) 510 that has been identified as a real object is shown.

[0131] In some cases, users may attempt to circumvent the detection of unrealistic textures by distributing unrealistic textures across multiple 3D virtual objects. This can lead to missed detection of unrealistic textures when validating a set of 2D polygons (each 2D polygon associated with a corresponding 3D virtual object). However, when used together in a virtual environment, images and / or textures from different 3D virtual objects may be combined to result in the display of unrealistic (e.g., inappropriate and / or offensive) content.

[0132] As an example, a user can create a first 3D virtual object (e.g., a shirt) with a texture defined by a first set of 2D polygons. A user can also create a second 3D virtual object (e.g., trousers) with a texture defined by a second set of 2D polygons. In some cases, adjacent portions of the first and second 3D virtual objects can be combined to create / display unrealistic content.

[0133] For example, such as Figure 5A As shown, a user can upload (provide) a set of 2D polygons, which includes 2D polygon 520 specifying a texture associated with the front torso of a shirt. The user can provide a second set of 2D polygons, which includes 2D polygon 530 specifying a texture associated with the front leg portion of trousers.

[0134] Each individual 3D virtual object (shirt or pants) does not contain unrealistic textures, such as textures that do not match any previously received object (image) that was classified as real and could be classified as real when individually verified by the online gaming platform. However, when worn together in a virtual avatar, adjacent areas of the 3D virtual objects can create a view of an unrealistic image that matches the real object 510.

[0135] The detection of unrealistic textures generated by different 3D virtual objects is performed by jointly evaluating a set of received 2D polygons associated with a 3D virtual object and a set of 2D polygons associated with other 3D virtual objects and / or images stored on the online game platform. The evaluation considers the possible poses and animated movements of the virtual avatars covered by the 3D virtual objects.

[0136] In this illustrative example, based on the comparison described above, and based on the detected similarity of the combined 2D polygons (combined polygons 520 and 530) representing a view 550 having a real object 510, it is determined that the texture associated with one or more of the received virtual 3D objects including 2D polygons 520 and / or 2D polygons 530 is not real.

[0137] In some implementations, both of the aforementioned 3D virtual objects can be tagged for additional checks and / or verifications, such as those performed manually. In some implementations, authenticity can be assigned to the earlier received 3D virtual object without the texture being built as a proprietary image.

[0138] In some implementations, authenticity is assigned to the licensee of the proprietary image where the texture was previously created as a proprietary image (e.g., a copyrighted image).

[0139] Figure 5B A view of a virtual avatar according to some implementations is shown.

[0140] In some cases, 3D virtual objects can be used in combination with other objects. For example, a 3D virtual object (such as a shirt for a virtual avatar (character)) can be used in a virtual environment in combination with another 3D virtual object (such as a jacket for a virtual character). As another example, a scarf can be used in combination with a shirt. 3D virtual objects can be specified to have any different levels of transparency.

[0141] For example, in Figure 5B In this example, 2D polygon 560 is included in a set of 2D polygons associated with the texture of the shirt, and 2D polygon 570 is a torso 2D polygon included in a set of 2D polygons associated with a jacket that can be worn over the shirt. In this example, the jacket is specified to be transparent, and the surface beneath the jacket is visible when the avatar is wearing it.

[0142] like Figure 5B As shown, the individual 3D virtual objects (shirts or pants) associated with 2D polygons 560 and 570 do not include unrealistic textures, such as textures that do not match any previously received images that are classified as real and could be classified as real when individually verified by the online gaming platform. However, when used together in a virtual avatar (worn), overlapping areas can cause the display of unrealistic textures (images) that match the real object 510.

[0143] In this illustrative example, based on the comparison described above, and based on the similarity between the detected combined 2D polygons (combined 2D polygons 560 and 570) and the real object 510, it is determined that the textures associated with one or more of the received virtual 3D objects including 2D polygons 560 and / or 2D polygons 570 are not real.

[0144] Figure 6 This is a flowchart illustrating an example method 600 for detecting unrealistic textures associated with virtual objects, according to some implementations. In some implementations, this can be done, for example, in reference to... Figure 1 Method 600 is implemented on the described game server 102. In some implementations, part or all of method 600 can be implemented as follows: Figure 1 The method 600 may be implemented on one or more client devices 110, one or more developer devices 130, one or more server devices 102, and / or a combination of developer devices, server devices, and client devices. In the described examples, the implemented system includes one or more digital processors or processing circuitry (“processors”) and one or more storage devices (e.g., data storage area 120 or other storage). In some implementations, different components of one or more servers and / or clients may execute different blocks or other portions of method 600. In some examples, the first device is described as executing blocks of method 600. Some implementations may have one or more blocks of method 600 executed by one or more other devices (e.g., other client devices or server devices) capable of sending results or data to the first device.

[0145] Processing begins at 610, where multiple unauthenticated two-dimensional (2D) polygons associated with the texture of a three-dimensional (3D) virtual object are received. The 2D polygons associated with the texture of the virtual 3D object can be provided in a virtual 3D environment (e.g., game 106) for use by one or more users within the virtual 3D environment. In some implementations, the texture of the virtual 3D object is generated by combining multiple 2D polygons in a specific arrangement based on the shape and / or pose of the 3D virtual object.

[0146] In some implementations, a developer using developer device 130 can receive the aforementioned multiple uncertified 2D polygons by uploading them to game server 102.

[0147] In some implementations, the 3D virtual object can be an accessory or clothing item associated with the virtual avatar, such as a shirt, pants, or jacket, which the virtual avatar can wear in a virtual environment such as a game environment or a social network environment.

[0148] In some implementations, multiple 2D polygons may comprise a set of rectangles conforming to a predefined template of a 3D virtual object. Online gaming platforms may generate one or more predefined templates and share them with users and / or developers. A predefined template may define a set of polygons (e.g., rectangles), each polygon mapped to a specific part of the virtual character, such as the front of the torso, the left side of the left arm, the right side of the right arm, the rear of the torso, etc. In some implementations, only a subset of the 2D polygons associated with the texture may be received, and the remainder of the unreceived set of 2D polygons may be set to default values.

[0149] In some implementations, the aforementioned 3D virtual object may be included as part of a set of game assets received from the developer. In some implementations, the aforementioned 3D virtual object may be a standalone 3D virtual object that may be uploaded to an online game platform and subsequently used by one or more users, traded with one or more users, or sold to one or more users in real or virtual currency, etc.

[0150] In some implementations, unauthenticated virtual 3D objects may include user-provided tags that can serve as descriptors for the virtual 3D object and / or textures defined by a set of 2D polygons. For example, the tags may indicate the name of the object, such as "cool shirt," "Batman costume," "Santa Claus pants," "cool jacket," etc. Block 610 may be followed by block 620.

[0151] In block 620, portions of two or more 2D polygons are combined to obtain one or more combined polygons.

[0152] In some implementations, the combination of portions of two or more 2D polygons is based on an ordered list of 2D polygons to be combined. In some implementations, multiple ordered lists may be determined based on a superset of poses and / or animated movements compatible with the virtual character. In some implementations, the ordered lists may be stored in storage devices and / or memory, for example, on data storage area 120, or on a local user or developer device. For example, the ordered list may be generated based on all 2D polygons that may be adjacent to and / or overlap with each other in one or more camera views of the 3D virtual object.

[0153] In some implementations, each 2D polygon is sequentially combined with the remainder of the set of 2D polygons to generate a combined set of 2D polygons. In some implementations, the combination is also based on combining each 2D polygon in the set of 2D polygons with the remainder of the set of 2D polygons using multiple angular transformations. The aforementioned angular combinations can be determined based on the possible and physically feasible transformations of corresponding parts of the 3D virtual object (e.g., arms, legs, etc.).

[0154] For example, a 2D polygon associated with the forequarter portion of a 3D virtual object can be combined with a 2D polygon associated with the forequarter portion of the left arm, the 2D polygon associated with the forequarter portion of the left arm taking into account all possible (and visible) angles of the left arm based on the possible poses and / or movements of the virtual character (avatar) in the virtual environment.

[0155] In some implementations, the ordered list of some or all of the 2D polygons used to combine two or more 2D polygons is based on one or more poses of 3D virtual objects selected from a set of predetermined poses typically observed and used in the virtual environment.

[0156] In some implementations, 2D polygons that cannot appear adjacent to another 2D polygon in any possible pose or configuration can be excluded and thus not combined. For example, because it may be impossible to see any part of the 2D polygon associated with the front torso and any part of the 2D polygon associated with the rear (back) torso in any possible view of the avatar associated with the 3D virtual object, the 2D polygon associated with the front torso may not be combined with the 2D polygon associated with the rear (back) torso.

[0157] In some implementations, the ordered list may also include weights associated with each corresponding set of 2D polygons in the respective combinations of 2D polygons. The weights may be based on the relative probability that the 2D polygons in the aforementioned combinations are adjacent or nearly adjacent in different camera views of the 3D virtual object within the virtual environment. Parameterized weighting of different combinations of 2D polygons can be used, where some views are weighted differently than others. For example, views that a user (viewer) views more frequently in the 3D environment may be weighted more heavily than views that are viewed less frequently.

[0158] In some implementations, the ordered list may be based on a matrix of adjacent polygons, as well as polygons that appear within a threshold distance (almost adjacent) of each other in the default and common poses of the avatar.

[0159] In some implementations, the 2D polygons included in a set of 2D polygons associated with the texture of the 3D virtual object may be combined with 2D polygons from one or more sets of 2D polygons, which are associated with the textures of other 3D virtual objects previously received and stored in storage devices and / or memories on the online gaming platform.

[0160] For example, a 2D polygon included in a set of 2D polygons associated with a shirt can be combined with a 2D polygon included in a set of 2D polygons associated with a texture of trousers previously received by the same or different users. As previously described, the combination is determined based on 2D polygons that may be adjacent in the camera view within the virtual environment. For example, as referenced Figure 5A As described, the 2D polygon of the forequarter portion can be combined with the front portion of a 2D polygon associated with the right leg and / or left leg of a pair of pants.

[0161] In some implementations, based on the transparency properties of one or more 3D virtual objects and the possibility of partial overlap of 2D polygons from the corresponding 3D virtual objects, 2D polygons in a set of 2D polygons associated with the texture of a 3D virtual object can be combined with 2D polygons from one or more sets of 2D polygons associated with the textures of other 3D virtual objects. For example, a virtual avatar can use layered clothing, such as a jacket with transparent properties worn over a shirt. To accurately detect unrealistic content in this case, 2D polygons associated with the front torso of the shirt can be combined with the front torso of the jacket.

[0162] In some implementations, the history of combined 3D virtual objects (e.g., clothing) used on an online gaming platform can be used to determine the likelihood of combinations of 3D virtual objects and to determine a set of 2D polygon combinations to be compared with real 3D virtual objects.

[0163] In some implementations, possible stacking arrangements of 2D polygons are predetermined, stored, and used to combine 2D polygons. In some implementations, the stacking arrangement is used to combine the 2D polygons of one or more 3D virtual objects when the transparency of at least one of the one or more 2D polygons meets a threshold transparency.

[0164] In some implementations, the combination of 2D polygons associated with the texture of the 3D virtual object is based on the animated movement of the virtual avatar. In some implementations, an ordered list of animation sequences may be used and determined based on one or more animations in the virtual environment where the 3D virtual object is placed, wherein the one or more animations correspond to the movement of the 3D virtual object in the virtual environment.

[0165] The combination of corresponding 2D polygons is based on the transformation (e.g., displacement, rotation, movement, etc.) of the 3D virtual object corresponding to the animation of the associated virtual avatar. In the case of animation achieved by using lattice deformation of the underlying mesh used to define the characteristics of the virtual avatar, the 2D polygons associated with the texture deform accordingly. In some implementations, the deformation may be defined by a predetermined function applied to one or more 2D polygons before and / or after combination with other 2D polygons.

[0166] In some implementations, custom motion associated with the same developer and / or game as the 3D virtual object can be used to determine a set of combinations of 2D polygons.

[0167] In some implementations, after combining two or more 2D polygons, the combined 2D polygons can be modified (e.g., cropped) to generate modified combined 2D polygons that further define preferred regions of interest for verifying false content. For example, portions of the combined 2D polygons can be excluded based on the distances of these portions to the overlapping edges of the 2D polygons that were combined to generate the combined 2D polygons. For example, modified 2D polygons can be generated from the combined 2D polygons that include only the regions of the combined 2D polygons located within a threshold distance from the center of the combined polygons.

[0168] Block 620 can be followed by block 630.

[0169] In block 630, calculate the corresponding hash value for each of one or more combined 2D polygons.

[0170] In some implementations, a perceptual hash function is used to compute the hash value. Perceptual hash functions can be used to determine the perceptual similarity of digital media content (such as image files, animations, etc.). Perceptual hash functions can also be used to extract features of interest from textures and compute hash values ​​based on these features.

[0171] A perceptual hash function can be designed such that the hash values ​​of the original object and the object to be authenticated (calculated using the perceptual hash function) are similar when the objects are perceptually similar (e.g., visually similar), and dissimilar when the objects are perceptually dissimilar.

[0172] Block 630 can be followed by block 640.

[0173] In block 640, the hash values ​​of the combined 2D polygons are compared with the hash values ​​of the real objects to determine whether the hash values ​​of any combined 2D polygons match the hash values ​​of the real objects.

[0174] For example, it can be determined whether there is a match between at least one hash value of the corresponding hash value of a 2D polygon and the hash value of at least one reference 2D polygon associated with a real object.

[0175] In some implementations, the hash value of each of the combined 2D polygons of the received virtual 3D object is compared with the hash values ​​of the 2D polygons of objects (e.g., images, textures, etc.) stored by the online game platform. As mentioned earlier, in some implementations, parametric weighting of different views can be used, where the weighting of some views differs from that of others. For example, the weighting of views that a user (viewer) views more frequently in the 3D environment can be greater than the weighting of views that are viewed less frequently.

[0176] In some implementations, a matching score can be calculated associated with the aforementioned match between each of the corresponding hash values ​​and the hash value of a reference 2D polygon associated with the real object. One or more weights can be applied to the combined portion of two or more 2D polygons, where the weights are based on the probability of a specific configuration of the virtual avatar represented by the combination of 2D polygons occurring. If the matching score meets a predetermined threshold, a match can be determined to exist.

[0177] In some implementations, the matching score can be based on the similarity between the combined 2D polygon and a reference 2D polygon. For example, if similarity is detected between a 2D polygon corresponding to a specific location (e.g., the outside of the left arm) and a reference 2D polygon that also corresponds to the same location, a higher matching score can be assigned.

[0178] In some implementations, the distance between the corresponding hash value of the combined 2D polygon and the corresponding hash value of the 2D polygon of the real virtual 3D object can be calculated.

[0179] In some implementations, a distance value is compared to a predetermined distance threshold to determine whether a received texture associated with a virtual 3D object resembles the texture of a real virtual 3D object. In some implementations, the distance threshold can be set based on a value of the category type of the received virtual 3D object. In some implementations, the distance threshold can be adjusted based on previously used distance thresholds and textures previously classified as real or unreal based on those distance thresholds (e.g., via game server 102).

[0180] In some implementations, the predetermined distance threshold can be a configurable value. In some implementations, the predetermined distance threshold can be set to a value based on the category type of the received virtual 3D object.

[0181] For example, thresholds can be used for certain object categories that are more frequently forged or have higher sensitivity within a gaming platform. A lower degree of similarity might lead to virtual 3D objects in those categories being flagged as fake when compared to received virtual 3D objects belonging to categories that are less frequently forged. Shirts and trousers are examples of virtual 3D objects that are easily, frequently, and quickly forged. Virtual 3D objects that require less work to create and upload content for are also easier to copy.

[0182] In some implementations, the classification and / or labeling of received objects may be based on the type or category of real objects determined to be similar to the received object. For example, even if only a single pose results in a view of the received object matching a real object, similarity to identifiers and / or other copyrighted material may be completely disallowed. As another example, near-duplicate objects, determined by the difference between the corresponding hash values, may be disallowed if at least a threshold number (e.g., percentage) of the object's views match a real object.

[0183] If the hash value of the combined 2D polygon determined in block 640 matches the hash value of the real object, then block 650 follows block 640.

[0184] In block 650, the received virtual 3D objects are classified as unrealistic textures. In some implementations, 3D virtual objects determined to be unrealistic (fake) can be excluded from the virtual platform's (online gaming platform's) list. In some implementations, a message indicating that a 3D virtual object has been marked as unrealistic (fake) can be provided to the uploader and / or the administrator of the virtual environment. In some implementations, unrealistic objects can be marked for further review (e.g., manual review by an administrator associated with the gaming platform).

[0185] If the hash value of the combined 2D polygon determined in block 640 does not match the hash value of the real object, then block 660 follows block 640.

[0186] In block 660, the received virtual 3D object is classified as a real texture. In some implementations, classification as a real object is used as a signal and combined with other signals (e.g., human review of the 3D virtual object, developer rating associated with the developer who uploaded the 3D virtual object, etc.) to classify the virtual 3D virtual object.

[0187] In some implementations, after classifying uncertified virtual 3D objects as real 3D virtual objects, multiple 2D polygons of the uncertified virtual 3D objects can be stored in a storage device and / or memory (e.g., on data storage area 120) and used to authenticate other virtual 3D objects that can subsequently be received. The stored real 3D virtual objects can be used in the virtual environment. A user interface that includes real textures and 3D virtual objects in the virtual environment can be provided. Furthermore, if the virtual environment enables users to purchase real objects (e.g., by paying virtual currency) or gain access to real objects through a subscription, then the real 3D virtual objects (which are uncertified 3D virtual objects after classification in block 660) are available to the user.

[0188] Blocks 610 through 660 may be performed (or repeated) in a different order than described above and / or one or more steps may be omitted. For example, block 620 may be performed multiple times, for instance, to obtain a subset of combined 2D polygons based on a selected sequence. For example, a set of combined 2D polygons more likely to appear in the camera view may be generated in the first stage, and blocks 630 through 660 may be performed, and the process may be repeated in subsequent stages with 2D polygons of less likely combinations.

[0189] In some implementations, virtual 3D objects received on the game platform can be scanned at a predetermined frequency (e.g., daily, every other day, hourly, etc.) to detect any non-realistic objects, thereby reducing user access to these objects. In some implementations, received virtual 3D objects that are more likely to be copied can be scanned at a higher frequency than virtual 3D objects that are unlikely to be copied. In some implementations, method 600 can be executed each time a new object is received via upload. In some implementations, method 600 can be executed when a stored object is modified.

[0190] In some implementations, the threshold distance can be updated using user feedback about unreal objects encountered by the user on the platform, and method 600 can be performed on one or more previously authenticated 3D virtual objects.

[0191] In some implementations, one or more detection parameters (such as the matrix of adjacent polygons, threshold distance, ordered list, etc.) can be updated (adjusted) based on the detection of unrealistic 3D virtual objects.

[0192] In some implementations, the classification as a real object can be used as a signal and combined with other signals (e.g., human review of 3D virtual objects, developer ratings associated with the developers who uploaded the 3D objects, etc.) to classify virtual 3D objects.

[0193] In some implementations, after classifying unauthenticated virtual 3D objects as real objects, the hash values ​​of the received 2D polygons and combined 2D polygons can be stored (e.g., on data storage 120) and used to authenticate other virtual 3D objects that can subsequently be received.

[0194] In some implementations, before block 620 obtains one or more combined polygons, the hash value of each of the received 2D polygons can be calculated. If the hash value of at least one of the multiple 2D polygons associated with the texture of the 3D virtual object matches the hash value of a reference 2D polygon associated with the real object, the texture of the received unauthenticated 3D virtual object can be classified as an unreal texture.

[0195] Figure 7 This is a block diagram of an example computing device 700 that can be used to implement one or more features described herein. In one example, device 700 can be used to implement a computer device (e.g., Figure 1 The computing device 700 may be any suitable computer system, server, or other electronic or hardware device. For example, the computing device 700 may be a mainframe computer, desktop computer, workstation, portable computer, or electronic device (portable device, mobile device, mobile phone, smartphone, tablet computer, television, set-top box, personal digital assistant (PDA), media player, gaming device, wearable device, etc.). In some embodiments, the device 700 includes a processor 702, a memory 704, an input / output (I / O) interface 706, and an audio / video input / output device 714.

[0196] Processor 702 can be one or more processors and / or processing circuitry to execute program code and control the basic operations of device 700. "Processor" includes any suitable hardware and / or software system, mechanism, or component that processes data, signals, or other information. A processor can include a system with a general-purpose central processing unit (CPU), multiple processing units, dedicated circuitry for implementing functions, or other systems. Processing is not limited to a specific geographical location or time. For example, a processor can perform its functions in a "real-time," "offline," or "batch processing mode." Different parts of the processing can be executed by different (or the same) processing systems at different times and locations. A computer can be any processor that communicates with memory.

[0197] Memory 704 is typically provided in device 700 for access by processor 702 and can be any suitable processor-readable storage medium, such as random access memory (RAM), read-only memory (ROM), electrically erasable read-only memory (EEPROM), flash memory, etc. Memory 704 is suitable for storing instructions for execution by the processor and is decoupled from and / or integrated with processor 702. Memory 704 may store software operated by processor 702 on server device 700, including operating system 708, one or more applications 710 (e.g., an audio spatialization application), and application data 712. In some embodiments, application 710 may include functions (or controls) that enable processor 702 to perform the functions described herein (e.g., see reference 1). Figure 6 Instructions (described in part or all of the methods).

[0198] For example, application 710 may include audio spatialization module 712, which, as described herein, can provide audio spatialization within an online game server (e.g., 102). Software elements in memory 704 may alternatively be stored in any other suitable storage location or on a computer-readable medium. Furthermore, memory 704 (and / or other connected storage devices) may store instructions and data used in the features described herein. Memory 704 and any other type of memory (disk, optical disk, magnetic tape, or other tangible media) may be considered "storage" or "storage device".

[0199] I / O interface 706 provides functionality that enables server device 700 to interface with other systems and devices. For example, network communication devices, storage devices (e.g., memory and / or data storage area 120), and input / output devices can communicate via interface 706. In some embodiments, the I / O interface can be connected to interface devices, including input devices (keyboard, pointing device, touchscreen, microphone, camera, scanner, etc.) and / or output devices (display device, speaker device, printer, motor, etc.).

[0200] Audio / video input / output device 714 may include user input devices (e.g., mouse, etc.) for receiving user input, display devices (e.g., screen, monitor, etc.) for providing graphical and / or visual output, and / or combinations of input and display devices.

[0201] For ease of explanation, Figure 7A block is shown for each of the processor 702, memory 704, I / O interface 706, operating system 708, and game application 710. These blocks may represent one or more processors or processing circuits, operating systems, memory, I / O interfaces, applications, and / or software engines. In other embodiments, device 700 may not have all the components shown, and / or may have other components including other types of elements instead of those shown herein, or include such other elements in addition to those shown herein. While online game server 102 is described as performing the operations described in some embodiments herein, any suitable component or combination of components of online game server 102 or similar systems, or any suitable one or more processors associated with such a system, may perform the described operations.

[0202] User equipment may also implement and / or use with the features described herein. Example user equipment may be a computer device including components similar to those of device 700, such as processor 702, memory 704, and I / O interface 706. An operating system, software, and applications suitable for the client device may be provided in memory and used by the processor. The I / O interface for the client device may connect to network communication devices and input / output devices, such as a microphone for capturing sound, a camera for capturing images or video, a mouse for capturing user input, a gesture device for recognizing user gestures, a touchscreen for detecting user input, an audio speaker device for outputting sound, a display device for outputting images or video, or other output devices. For example, a display device within audio / video input / output device 714 may be connected to (or included in) device 700 to display pre-processed and post-processed images as described herein, wherein such a display device may include any suitable display device, such as an LCD, LED, or plasma display screen, CRT, television, monitor, touchscreen, 3D display screen, projector, or other visual display device. Some implementations may provide an audio output device, such as a speech output or a synthesized voice for reading text.

[0203] One or more methods described herein (e.g., method 600) can be implemented by computer program instructions or code executable on a computer. For example, the code can be implemented by one or more digital processors (e.g., microprocessors or other processing circuitry) and can be stored on a computer program product including a non-transitory computer-readable medium (e.g., a storage medium), such as magnetic, optical, electromagnetic, or semiconductor storage media, including semiconductor or solid-state memory, magnetic tape, removable computer floppy disks, random access memory (RAM), read-only memory (ROM), flash memory, hard magnetic disks, optical disks, solid-state storage drives, etc. The program instructions can also be contained in and provided as an electronic signal, for example, in the form of software as a service (SaaS) delivered from a server (e.g., a distributed system and / or cloud computing system). Alternatively, one or more methods can be implemented using hardware (logic gates, etc.) or a combination of hardware and software. Example hardware can be a programmable processor (e.g., a field-programmable gate array (FPGA), a complex programmable logic device), a general-purpose processor, a graphics processor, an application-specific integrated circuit (ASIC), etc. One or more methods can be executed as part of or a component of an application running on the system, or as an application or software that runs with other applications and the operating system.

[0204] One or more methods described herein can run in standalone programs that can run on any type of computing device, programs that run on a web browser, or mobile applications (“apps”) that run on mobile computing devices (e.g., mobile phones, smartphones, tablets, wearable devices (watches, armbands, jewelry, headwear, goggles, glasses, etc.), laptops, etc.). In one example, a client / server architecture can be used, whereby the mobile computing device (as a client device) sends user input data to a server device and receives final output data from the server for output (e.g., for display). In another example, all computations are performed within a mobile application (and / or other applications) on the mobile computing device. In yet another example, computations can be split between the mobile computing device and one or more server devices.

[0205] Although the specification has been described with reference to specific embodiments, these embodiments are illustrative only and not limiting. The concepts illustrated in the examples can be applied to other examples and embodiments.

[0206] The functional blocks, operations, features, methods, devices, and systems described in this disclosure can be integrated or divided into different combinations of systems, devices, and functional blocks known to those skilled in the art. Routines for a particular implementation can be implemented using any suitable programming language and programming technique. Different programming techniques can be employed, such as procedural or object-oriented programming. Routines can be executed on a single processing device or multiple processors. While steps, operations, or calculations can be presented in a specific order, the order can be changed in different specific implementations. In some implementations, multiple steps or operations shown as sequential in this specification can be performed simultaneously.

Claims

1. A computer-implemented method for detecting inauthentic textures in a virtual environment, the method comprising: receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on a pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; computing a respective hash value for each of the combined 2D polygons; determining whether there is a match between at least one of the respective hash values and a hash value of a reference 2D polygon associated with a real object; if it is determined that there is the match, classifying the texture as an inauthentic texture; and if it is determined that there is no match, classifying the texture as a real texture.

2. The computer-implemented method of claim 1, wherein, Receiving the plurality of 2D polygons includes receiving a plurality of 2D polygons comprising a set of 2D polygons that conform to a predetermined set of dimensions and that are combinable based on a predetermined template to generate a texture of the 3D virtual object.

3. The computer-implemented method of claim 2, wherein, The 3D virtual object is an item of clothing associated with a virtual avatar.

4. The computer-implemented method of claim 1, wherein, Combining the two or more 2D polygons is based on an overlapping arrangement of the two or more 2D polygons, and wherein a transparency of at least one of the two or more 2D polygons satisfies a threshold transparency.

5. The computer-implemented method of claim 1, wherein, Determining whether there is the match includes: computing a match score associated with the match between each of the respective hash values and the hash value of the reference 2D polygon associated with the real object; and determining that there is the match if the match score satisfies a threshold.

6. The computer-implemented method of claim 5, further comprising applying a weight associated with the portions of the combination of the two or more 2D polygons to the match score.

7. The computer-implemented method of claim 1, wherein, Combining the portions of the two or more 2D polygons is based on an ordered list of 2D polygons.

8. The computer-implemented method of claim 7, further comprising determining an ordered list of the 2D polygons based on one or more animations in the virtual environment in which the 3D virtual object is placed, and wherein, The one or more animations correspond to movement of the 3D virtual object in the virtual environment.

9. The computer-implemented method of claim 7, wherein, The ordered list of 2D polygons is based on one or more morphs of the 3D virtual object.

10. The computer-implemented method of claim 1, further comprising, prior to the combining: if a hash value of at least one of the plurality of two-dimensional (2D) polygons associated with the texture of the 3D virtual object matches the hash value of the reference 2D polygon associated with the real object, classifying the texture as the inauthentic texture.

11. The computer-implemented method of claim 1, wherein, Computing the respective hash values includes computing the respective hash values using a perceptual hashing technique, wherein hash values of polygons having similar content have greater similarity than hash values of polygons having dissimilar content.

12. The computer-implemented method of claim 1, further comprising providing a user interface comprising the real texture in a virtual environment.

13. The computer-implemented method of claim 1, wherein, The 3D virtual object is an object that is wearable by a virtual avatar in the virtual environment.

14. A non-transitory computer-readable medium comprising instructions that, in response to being executed by a processing device, cause the processing device to perform operations comprising: receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on a pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; computing a respective hash value for each of the combined 2D polygons; determining whether there is a match between at least one of the respective hash values and a hash value of at least one reference 2D polygon associated with a real object; if it is determined that there is the match, classifying the texture as a non-real texture; and if it is determined that there is no match, classifying the texture as a real texture. Combining the portions of the two or more 2D polygons is based on an ordered list of 2D polygons.

15. The non-transitory computer-readable medium of claim 14, wherein, The operations further comprise determining the ordered list of 2D polygons based on one or more animations of a virtual environment in which the 3D virtual object is placed, and wherein the one or more animations correspond to movement of the 3D virtual object in the virtual environment.

16. The non-transitory computer-readable medium of claim 15, wherein, 17. A computer system comprising: a memory having instructions stored thereon; and a processing device coupled to the memory, the processing device to access the memory and execute the instructions, wherein the instructions cause the processing device to perform operations comprising: receiving a plurality of two-dimensional (2D) polygons associated with a texture of a three-dimensional (3D) virtual object; combining portions of two or more of the plurality of 2D polygons based on a pose or shape of the 3D virtual object to obtain one or more combined 2D polygons; computing a respective hash value for each of the combined 2D polygons; determining whether there is a match between at least one of the respective hash values and a hash value of at least one reference 2D polygon associated with a real object; if it is determined that there is the match, classifying the texture as a non-real texture; and if it is determined that there is no match, classifying the texture as a real texture. Combining the portions of the two or more 2D polygons is based on an ordered list of 2D polygons.

18. The computer system of claim 17, wherein, The ordered list of 2D polygons is based on one or more deformations of the 3D virtual object.

19. The computer system of claim 18, wherein, Computing the respective hash value includes computing the respective hash value using a perceptual hashing technique, wherein hash values of polygons having similar content have greater similarity than hash values of polygons having dissimilar content.

20. The computer system of claim 17, wherein, ​

Images