Hierarchical bounding volume leaf node compression

By using hierarchical enclosure structure and arithmetic compression technology in graphics processing, the metadata in leaf nodes is efficiently compressed, which solves the problem of low compression efficiency of leaf nodes in the prior art, and improves ray tracing performance and memory bandwidth utilization.

CN118901085APending Publication Date: 2024-11-05QUALCOMM INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202380016600.4
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2022-02-04
Filing Date
2023-01-19
Publication Date
2024-11-05

AI Technical Summary

Technical Problem

The existing node compression technology in the graphics processing cannot efficiently compress leaf nodes, resulting in the addition of traversal loop iteration, memory bandwidth consumption and power consumption during ray tracing, and the complexity of determining the number of primitives per leaf node.

Method used

Using a hierarchical enclosing body (BVH) structure, by compressing the ID, geometric ID and floating point coordinates of the element, combined with arithmetic compression technology, the copy of the element is stored and the number of elements is efficiently determined in the leaf node, using the lossless compression mechanism and Lossy variants to improve compression success rate.

Benefits of technology

Improves ray tracing performance, optimizes memory bandwidth, reduces the size of leaf nodes, and improves the efficiency of graphics processing.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118901085A_ABST
    Figure CN118901085A_ABST
Patent Text Reader

Abstract

Aspects presented herein relate to methods and apparatus for graphics processing, including devices, such as GPUs. The apparatus may configure a BVH structure that includes a plurality of nodes that each include one or more primitives, and each of the primitives is associated with a primitive ID, a geometry ID, and a set of floating point coordinates. The apparatus may also compress the primitive ID or the geometry ID for each of the primitives. Further, the apparatus may convert a binary representation of each of the floating point coordinates into an integer value of each of the floating point coordinates. The apparatus may also calculate a difference between the integer values for each floating point coordinate of the set of floating point coordinates for each primitive of the plurality of primitives. The apparatus may also store the compressed primitive ID or the compressed geometry ID and the calculated difference.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims the benefit of U.S. patent application No. 17 / 650,060, filed on February 4, 2022, entitled “BOUNDINGVOLUME HIERARCHY LEAF NODE COMPRESSION,” which is expressly incorporated herein by reference in its entirety. Technical Field

[0003] The present disclosure relates generally to processing systems and, more particularly, to one or more graphics processing techniques.

[0004] introduction

[0005] Computing devices typically perform graphics and / or display processing (e.g., using a graphics processing unit (GPU), a central processing unit (CPU), a display processor, etc.) to render and display visual content. Such computing devices may include, for example, computer workstations, mobile phones (such as smart phones), embedded systems, personal computers, tablet computers, and video game consoles. The GPU is configured to execute a graphics processing pipeline that includes one or more processing stages that operate together to execute graphics processing commands and output frames. The central processing unit (CPU) can control the operation of the GPU by issuing one or more graphics processing commands to the GPU. Modern CPUs are typically capable of executing multiple applications concurrently, and each application may need to utilize a GPU during execution. The display processor is configured to convert digital information received from the CPU into analog values, and can issue commands to a display panel to display visual content. A device that provides content for visual presentation on a display may utilize a GPU and / or a display processor.

[0006] Currently, there is a need for improved graph processing. For example, current node compression techniques in graph processing may not be able to efficiently compress leaf nodes. Therefore, there is an increased need for improved node compression techniques to efficiently compress leaf nodes. Summary of the invention

[0007] The following presents a simplified summary of one or more aspects in order to provide a basic understanding of these aspects. This summary is not an extensive overview of all contemplated aspects, and is neither intended to identify key or important elements of all aspects, nor to describe the scope of any or all aspects. Its sole purpose is to present some concepts of one or more aspects in a simplified form as a prelude to a more detailed description presented later.

[0008] In one aspect of the present disclosure, a method, a computer-readable medium, and a device are provided. The device may be a graphics processing unit (GPU), a GPU, or any device that can perform graphics processing. The device may configure a hierarchical bounding volume (BVH) structure, the hierarchical bounding volume (BVH) structure including a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes including one or more primitives in the plurality of primitives, and each of the plurality of primitives being associated with a primitive identifier (ID), a geometric ID, and a floating-point coordinate set. The device may also compress at least one of the primitive ID or the geometric ID of each primitive in the plurality of primitives. Additionally, the device may convert a binary representation of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives into an integer value of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives. The device may also calculate the difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives. The device may also modify the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives. In addition, the device may store at least one of the compressed primitive ID or the compressed geometry ID of each of the plurality of primitives and the calculated difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates.

[0009] The details of one or more examples of the disclosure are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the disclosure will become apparent from the description and drawings, and from the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] Figure 1 is a block diagram illustrating an example content generation system in accordance with one or more techniques of this disclosure.

[0011] Figure 2 is an example graphics processing unit (GPU) in accordance with one or more techniques of this disclosure.

[0012] Figure 3 is a diagram illustrating an example ray tracing process in accordance with one or more techniques of this disclosure.

[0013] Figure 4A is a diagram illustrating an example rasterization process in accordance with one or more techniques of this disclosure.

[0014] Figure 4B is a diagram illustrating an example ray tracing process in accordance with one or more techniques of this disclosure.

[0015] Figure 5 is a diagram illustrating an example ray tracing process in accordance with one or more techniques of this disclosure.

[0016] Fig. 6A is a diagram illustrating an example data structure in accordance with one or more techniques of this disclosure.

[0017] Figure 6B is a diagram illustrating an example data structure in accordance with one or more techniques of this disclosure.

[0018] Fig. 7A is a diagram illustrating an example internal node structure in accordance with one or more techniques of this disclosure.

[0019] Figure 7B is a diagram illustrating an example leaf node structure in accordance with one or more techniques of this disclosure.

[0020] Fig. 8A is a diagram illustrating an example leaf node structure in accordance with one or more techniques of this disclosure.

[0021] Figure 8B is a diagram illustrating an example leaf node structure in accordance with one or more techniques of this disclosure.

[0022] Fig. 9 is a diagram illustrating an example compression algorithm call flow in accordance with one or more techniques of this disclosure.

[0023] Fig. 10A is a diagram illustrating an example graph of floating point coordinates in accordance with one or more techniques of this disclosure.

[0024] Fig. 10B is a diagram illustrating an example graph of floating point coordinates in accordance with one or more techniques of this disclosure.

[0025] Fig.11 is a diagram illustrating an example compression algorithm structure in accordance with one or more techniques of this disclosure.

[0026] Fig.12 is a communication flow diagram illustrating example communications between GPU components in accordance with one or more techniques of this disclosure.

[0027] Fig.13 is a flow chart of an example graphics processing method according to one or more techniques of this disclosure.

[0028] Fig.14 is a flow chart of an example graphics processing method according to one or more techniques of this disclosure. DETAILED DESCRIPTION

[0029] Various aspects of the system, device, computer program product and method will be described more fully below with reference to the accompanying drawings. However, the present disclosure can be embodied in many different forms and should not be interpreted as being limited to any specific structure or function presented throughout the present disclosure. On the contrary, these aspects are provided so that the present disclosure will be thorough and complete, and the scope of the present disclosure will be fully conveyed to those skilled in the art. Based on the teachings of this article, it should be understood by those skilled in the art that the scope of the present disclosure is intended to cover any aspect of the system, device, computer program product and method disclosed herein, whether it is implemented independently of other aspects of the present disclosure or implemented in combination with other aspects of the present disclosure. For example, any number of aspects set forth herein can be used to implement a device or practice method. In addition, the scope of the present disclosure is intended to cover such a device or method that is practiced using other structures, functions, or structures and functions other than the various aspects of the disclosure set forth herein or different from the various aspects of the disclosure set forth herein. Any aspect disclosed herein can be embodied by one or more elements of the claims.

[0030] Although various aspects are described herein, many variations and permutations of these aspects fall within the scope of the present disclosure. Although some potential benefits and advantages of various aspects of the present disclosure are mentioned, the scope of the present disclosure is not intended to be limited to specific benefits, uses or objectives. Specifically, various aspects of the present disclosure are intended to be broadly applicable to different wireless technologies, system configurations, networks and transmission protocols, some of which are illustrated by way of example in the drawings and the description below. The specific embodiments and drawings merely illustrate the present disclosure and do not limit the present disclosure, and the scope of the present disclosure is defined by the attached claims and their equivalent technical solutions.

[0031] Several aspects are presented with reference to various devices and methods. These devices and methods are described in the following detailed description and illustrated in the accompanying drawings by various blocks, components, circuits, processes, algorithms, etc. (collectively referred to as "elements"). These elements can be implemented using electronic hardware, computer software, or any combination thereof. Whether these elements are implemented as hardware or software depends on the specific application and the design constraints imposed on the overall system.

[0032] For example, an element, or any part of an element, or any combination of elements may be implemented as a "processing system" including one or more processors (which may also be referred to as a processing unit). Examples of processors include microprocessors, microcontrollers, graphics processing units (GPUs), general-purpose GPUs (GPGPUs), central processing units (CPUs), application processors, digital signal processors (DSPs), reduced instruction set computing (RISC) processors, systems on chip (SOCs), baseband processors, application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), programmable logic devices (PLDs), state machines, gating logic, discrete hardware circuits, and other suitable hardware configured to perform the various functions described in this disclosure. One or more processors in a processing system may execute software. Software may be broadly interpreted as meaning instructions, instruction sets, codes, code segments, program codes, programs, subroutines, software components, applications, software applications, software packages, routines, subroutines, objects, executable files, threads of execution, procedures, functions, etc., whether expressed in software, firmware, middleware, microcode, hardware description languages, or other terms. The term "application" may refer to software. As described herein, one or more technologies may refer to an application, i.e., software, configured to perform one or more functions. In such examples, the application may be stored in a memory (e.g., an on-chip memory of a processor, a system memory, or any other memory). The hardware described herein (such as a processor) may be configured to execute an application. For example, an application may be described as including a code that, when executed by hardware, causes the hardware to perform one or more technologies described herein. As an example, the hardware may access the code from the memory and execute the code accessed from the memory to perform one or more technologies described herein. In some examples, components are identified in the present disclosure. In such examples, the components may be hardware, software, or a combination thereof. Each component may be a separate component or a subcomponent of a single component.

[0033] Accordingly, in one or more examples described herein, the functions described can be implemented in hardware, software, or any combination thereof. If implemented in software, the functions can be stored or encoded as one or more instructions or codes on a computer-readable medium. Computer-readable media include computer storage media. Storage media can be any available media that can be accessed by a computer. As an example and not limitation, such computer-readable media may include random access memory (RAM), read-only memory (ROM), electrically erasable programmable ROM (EEPROM), optical disk storage devices, magnetic disk storage devices, other magnetic storage devices, combinations of computer-readable media of the above types, or any other media that can be used to store instructions or data structure forms of computer executable code that can be accessed by a computer.

[0034] In summary, this disclosure describes techniques for having a graphics processing pipeline in a single device or multiple devices to improve rendering of graphics content and / or reduce load on a processing unit (i.e., any processing unit, such as a GPU, configured to perform one or more of the techniques described herein). For example, this disclosure describes techniques for performing graphics processing in any device that utilizes graphics processing. Other example benefits are described throughout this disclosure.

[0035] As used herein, instances of the term "content" may refer to "graphic content," "images," and vice versa. This is true regardless of whether these terms are used as adjectives, nouns, or other parts of speech. In some examples, as used herein, the term "graphic content" may refer to content produced by one or more processes of a graphics processing pipeline. In some examples, as used herein, the term "graphic content" may refer to content produced by a processing unit configured to perform graphics processing. In some examples, as used herein, the term "graphic content" may refer to content produced by a graphics processing unit.

[0036] In some examples, as used herein, the term "display content" may refer to content generated by a processing unit configured to perform display processing. In some examples, as used herein, the term "display content" may refer to content generated by a display processing unit. Graphics content may be processed to become display content. For example, a graphics processing unit may output graphics content (such as a frame) to a buffer (which may be referred to as a frame buffer). The display processing unit may read graphics content (such as one or more frames) from the buffer and perform one or more display processing techniques thereon to generate display content. For example, the display processing unit may be configured to perform synthesis on one or more rendering layers to generate a frame. As another example, the display processing unit may be configured to synthesize, mix or otherwise combine two or more layers into a single frame. The display processing unit may be configured to perform scaling on a frame, such as zooming in or out. In some examples, a frame may refer to a layer. In other examples, a frame may refer to two or more layers that have been mixed together to form the frame, that is, the frame includes two or more layers, and the frame including two or more layers may be subsequently mixed.

[0037] In some aspects of ray tracing, leaf nodes may contain information about the actual primitives that make up the geometry of the scene. Leaf nodes may contain indices and vertex buffers for each of these primitives. However, leaf nodes may not contain the primitives themselves (i.e., the coordinates of the primitives per vertex may not be stored in the leaf nodes). For example, if the application program interface (API) allows different types of primitives, storing copies of primitives in leaf nodes may be an expensive proposition. In some instances, without compression, a primitive / triangle can be accommodated in a leaf node. In fact, without compression, four triangles stored in a leaf node may have to be stored as four separate leaf nodes, plus additional internal nodes to connect them. Further, without leaf node compression, the ray tracing unit (RTU) may face the following: a higher number of traversal loop iterations (i.e., hop counts) to trace rays, higher memory bandwidth consumption to extract individual nodes for each triangle (plus more internal nodes), and higher power consumption to extract and process additional nodes. In addition, the process of determining the number of primitives per leaf node may be a complex task. In some instances, these steps may include negative consequences, such as leaf node expansion (i.e., the size of the leaf node increases), which is not optimal for leaf node compression. Aspects of the present disclosure may utilize an efficient leaf node compression algorithm to store copies of primitives in leaf nodes. Aspects of the present disclosure may also efficiently determine the number of primitives per leaf node. For example, aspects of the present disclosure may include a lossless compression mechanism for handling the compression of leaf nodes, wherein leaf nodes may store copies of primitives (i.e., floating point coordinates or floating point type coordinates). In addition, each leaf node in these leaf nodes may contain several primitives (e.g., 1, 2, 3, or 4 primitives). Aspects of the present disclosure may utilize a combination of arithmetic compression techniques, i.e., techniques involving performing reversible mathematical operations on the vertices of primitives and storing the results in several bits. This type of compression may compress up to a certain number of primitives / triangles (e.g., 3 or 4 primitives / triangles) into a certain number of bytes (e.g., 64 bytes). In some instances, the aspects presented herein may utilize leaf node compression algorithms. For example, aspects presented herein may include the ability to store triangle geometry within a BVH data structure.

[0038] Figure 11 is a block diagram illustrating an example content generation system 100 configured to implement one or more techniques of the present disclosure. The content generation system 100 includes a device 104. The device 104 may include one or more components or circuits for performing various functions described herein. In some examples, one or more components of the device 104 may be components of a SOC. The device 104 may include one or more components configured to perform one or more techniques of the present disclosure. In the example shown, the device 104 may include a processing unit 120, a content encoder / decoder 122, and a system memory 124. In some aspects, the device 104 may include several other components, such as a communication interface 126, a transceiver 132, a receiver 128, a transmitter 130, a display processor 127, and one or more displays 131. References to the display 131 may refer to one or more displays 131. For example, the display 131 may include a single display or multiple displays. The display 131 may include a first display and a second display. The first display may be a left-eye display, and the second display may be a right-eye display. In some examples, the first display and the second display may receive different frames for presentation thereon. In other examples, the first display and the second display may receive the same frame for presentation thereon. In further examples, the results of the graphics processing may not be displayed on the device, for example, the first display and the second display may not receive any frames for presentation thereon. Instead, the frames or graphics processing results may be transmitted to another device. In some aspects, this may be referred to as split rendering.

[0039] The processing unit 120 may include an internal memory 121. The processing unit 120 may be configured to perform graphics processing, such as in the graphics processing pipeline 107. The content encoder / decoder 122 may include an internal memory 123. In some examples, the device 104 may include a display processor (such as a display processor 127) to perform one or more display processing techniques on one or more frames generated by the processing unit 120 before being presented by one or more displays 131. The display processor 127 may be configured to perform display processing. For example, the display processor 127 may be configured to perform one or more display processing techniques on one or more frames generated by the processing unit 120. The one or more displays 131 may be configured to display or otherwise present frames processed by the display processor 127. In some examples, the one or more displays 131 may include one or more of the following: a liquid crystal display (LCD), a plasma display, an organic light emitting diode (OLED) display, a projection display device, an augmented reality display device, a virtual reality display device, a head mounted display, or any other type of display device.

[0040] Memory external to the processing unit 120 and the content encoder / decoder 122, such as the system memory 124, may be accessible to the processing unit 120 and the content encoder / decoder 122. For example, the processing unit 120 and the content encoder / decoder 122 may be configured to read from and / or write to the external memory, such as the system memory 124. The processing unit 120 and the content encoder / decoder 122 may be communicatively coupled to the system memory 124 via a bus. In some examples, the processing unit 120 and the content encoder / decoder 122 may be communicatively coupled to each other via the bus or a different connection.

[0041] The content encoder / decoder 122 may be configured to receive graphics content from any source, such as the system memory 124 and / or the communication interface 126. The system memory 124 may be configured to store the received encoded or decoded graphics content. The content encoder / decoder 122 may be configured to receive the encoded or decoded graphics content in the form of encoded pixel data, for example, from the system memory 124 and / or the communication interface 126. The content encoder / decoder 122 may be configured to encode or decode any graphics content.

[0042] Internal memory 121 or system memory 124 may include one or more volatile or non-volatile memories or storage devices. In some examples, internal memory 121 or system memory 124 may include RAM, SRAM, DRAM, erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, magnetic data media, or optical storage media, or any other type of memory.

[0043] According to some examples, the internal memory 121 or the system memory 124 may be a non-transitory storage medium. The term "non-transitory" may indicate that the storage medium is not embodied in a carrier wave or propagating signal. However, the term "non-transitory" should not be interpreted to mean that the internal memory 121 or the system memory 124 is non-removable or that its contents are static. As an example, the system memory 124 may be removed from the device 104 and moved to another device. As another example, the system memory 124 may not be removable from the device 104.

[0044] Processing unit 120 may be a central processing unit (CPU), a graphics processing unit (GPU), a general purpose GPU (GPGPU), or any other processing unit that may be configured to perform graphics processing. In some examples, processing unit 120 may be integrated into the motherboard of device 104. In some examples, processing unit 120 may be present on a graphics card installed in a port in the motherboard of device 104, or may be otherwise incorporated into a peripheral device configured to interoperate with device 104. Processing unit 120 may include one or more processors, such as one or more microprocessors, GPUs, application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), arithmetic logic units (ALUs), digital signal processors (DSPs), discrete logic, software, hardware, firmware, other equivalent integrated or discrete logic circuits, or any combination thereof. If the technology is partially implemented in software, processing unit 120 may store instructions for the software in a suitable non-transitory computer-readable storage medium (e.g., internal memory 121), and may use one or more processors to execute instructions in hardware to perform the technology of the present disclosure. Any of the above (including hardware, software, a combination of hardware and software, etc.) may be considered to be one or more processors.

[0045] The content encoder / decoder 122 may be any processing unit configured to perform content decoding. In some examples, the content encoder / decoder 122 may be integrated into the mainboard of the device 104. The content encoder / decoder 122 may include one or more processors, such as one or more microprocessors, application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), arithmetic logic units (ALUs), digital signal processors (DSPs), video processors, discrete logic, software, hardware, firmware, other equivalent integrated or discrete logic circuits, or any combination thereof. If the technology is partially implemented in software, the content encoder / decoder 122 may store instructions for the software in a suitable non-transitory computer-readable storage medium (e.g., internal memory 123), and may use one or more processors to execute instructions in hardware to perform the technology of the present disclosure. Any of the above (including hardware, software, a combination of hardware and software, etc.) may be considered to be one or more processors.

[0046] In some aspects, the content generation system 100 may include a communication interface 126. The communication interface 126 may include a receiver 128 and a transmitter 130. The receiver 128 may be configured to perform any receiving functions described herein with respect to the device 104. Additionally, the receiver 128 may be configured to receive information from another device, such as eye or head position information, rendering commands, or position information. The transmitter 130 may be configured to perform any sending functions described herein with respect to the device 104. For example, the transmitter 130 may be configured to send information to another device, which may include a request for content. The receiver 128 and the transmitter 130 may be combined into a transceiver 132. In such examples, the transceiver 132 may be configured to perform any receiving functions and / or sending functions described herein with respect to the device 104.

[0047] Reference again Figure 1In some aspects, the processing unit 120 may include a BVH component 198 configured to obtain a hierarchical bounding volume (BVH) structure, the hierarchical bounding volume (BVH) structure including a plurality of nodes, the BVH structure associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes including one or more primitives in the plurality of primitives, and each of the plurality of primitives associated with a primitive identifier (ID), a geometry ID, and a set of floating-point coordinates. The geometry data may include data associated with geometric primitives in a scene or frame processed in a graphics pipeline, such as draw call data, programming data, constant data, content register data, etc. A scene may be one or more frames including a set of objects / primitives for processing or rendering in the graphics pipeline. For example, a scene may include a series of frames including similar objects or primitives. The BVH component 198 may also be configured to compress at least one of the primitive ID or the geometry ID of each of the plurality of primitives. The BVH component 198 may also be configured to convert the binary representation of each floating-point coordinate in the floating-point coordinate set of each of the multiple primitives into the integer value of each floating-point coordinate in the floating-point coordinate set of each of the multiple primitives. The BVH component 198 may also be configured to calculate the difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each of the multiple primitives. The BVH component 198 may also be configured to modify the difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each of the multiple primitives. The BVH component 198 may also be configured to store at least one of the calculated differences between the compressed primitive ID or the compressed geometry ID of each of the multiple primitives and the integer value of each floating-point coordinate in the floating-point coordinate set. The BVH component 198 may also be configured to retrieve at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. The BVH component 198 may also be configured to perform a ray intersection on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. Although the following description may focus on graphics processing, the concepts described herein may be applicable to other similar processing techniques.

[0048] As described herein, a device such as device 104 may refer to any device, apparatus or system configured to perform one or more technologies described herein. For example, a device may be a server, a base station, a user equipment, a client device, a station, an access point, a computer (e.g., a personal computer, a desktop computer, a laptop computer, a tablet computer, a computer workstation or a mainframe computer), a final product, an apparatus, a phone, a smart phone, a server, a video game platform or console, a handheld device (e.g., a portable video game device or a personal digital assistant (PDA)), a wearable computing device (e.g., a smart watch, an augmented reality device or a virtual reality device), a non-wearable device, a display or display device, a television, a television set-top box, an intermediate network device, a digital media player, a video streaming device, a content streaming device, an onboard computer, any mobile device, any device configured to generate graphics content, or any device configured to perform one or more technologies described herein. The process herein may be described as being performed by a specific component (e.g., a GPU), but in further embodiments, other components (e.g., a CPU) consistent with the disclosed embodiments may be used to perform.

[0049] The GPU can process multiple types of data or data packets in the GPU pipeline. For example, in some aspects, the GPU can process two types of data or data packets, such as context register packets and draw call data. The context register packet can be a set of global state information, such as information about global registers, shaders, or constant data, which can adjust how the graphics context will be processed. For example, the context register packet may include information about the color format. In some aspects of the context register packet, there may be a bit indicating which workload belongs to the context register. In addition, there may be multiple functions or programs running simultaneously and / or in parallel. For example, a function or program can describe a certain operation, such as a color mode or color format. Therefore, the context register can define multiple states of the GPU.

[0050] Context states can be used to determine how individual processing units (e.g., vertex extractors, vertex shaders (VS), shader processors, or geometry processors) work and / or in what mode a processing unit works. To this end, the GPU can use context registers and programming data. In some aspects, the GPU can generate workloads (e.g., vertex or pixel workloads) in a pipeline based on context register definitions of a mode or state. Certain processing units (e.g., vertex extractors) can use these states to determine certain functions, such as how vertices are assembled. Since these modes or states may change, the GPU may need to change the corresponding context. Additionally, the workload corresponding to the mode or state can follow the changed mode or state.

[0051] Figure 2 2 illustrates an example GPU 200 in accordance with one or more techniques of this disclosure. Figure 2 As shown, GPU 200 includes a command processor (CP) 210, a draw call group 212, a vertex extractor 220, a VS 222, a vertex cache (VPC) 224, a triangle setup engine 226, a rasterizer 228, a Z pass engine (ZPE) 230, a pixel interpolator (PI) 232, a fragment shader (FS) 234, a rendering back end (RB) 236, a level 2 (L2) cache (UCHE) 238, and a system memory 240. Although Figure 2 GPU 200 is shown to include processing units 220-238, but GPU 200 may include multiple additional processing units. Additionally, processing units 220-238 are merely examples, and any combination or order of processing units may be used with a GPU according to the present disclosure. GPU 200 also includes command buffer 250, context register group 260, and context state 261.

[0052] like Figure 2 As shown, the GPU may parse the command buffer into context register packets (e.g., context register packets 260) and / or draw call data packets (e.g., draw call packets 212) using a CP (e.g., CP 210) or a hardware accelerator. Subsequently, the CP 210 may transmit the context register packets 260 or the draw call packets 212 to a processing unit or block in the GPU through a separate path. Further, the command buffer 250 may alternate different states of context registers and draw calls. For example, the command buffer may be constructed in the following manner: context registers of context N, draw calls of context N, context registers of context N+1, and draw calls of context N+1.

[0053] The GPU can render images in a variety of different ways. In some instances, the GPU can use rendering and / or tile rendering to render images. In a tile rendering GPU, the image can be divided or separated into different sections or tiles. After the image is divided, each section or tile can be rendered separately. The tile rendering GPU can divide the computer graphics image into a grid format so that each part of the grid (i.e., tile) is rendered separately. In some aspects, during the binning channel, the image can be divided into different boxes or tiles. In some aspects, during the binning channel, a visibility stream can be constructed in which visible primitives or drawing calls can be identified. In contrast to tile rendering, direct rendering does not divide the frame into smaller boxes or tiles. On the contrary, in direct rendering, the entire frame is rendered at once. Additionally, some types of GPUs may allow both tile rendering and direct rendering.

[0054] Some aspects of graphics processing can utilize different types of rendering techniques, such as ray tracing. Ray tracing is a rendering technique for generating images by tracing the light path of pixels in the image plane and simulating the effects of their encounters with objects in the scene. By doing so, ray tracing can produce very realistic lighting effects. Ray tracing has several benefits, including: providing more realistic effects (e.g., reflections), improved global illumination, improved gloss effects, improved depth of field, etc. Ray tracing can also help generate different types of improved shadows, such as hard shadows and / or soft shadows. Some effects of ray tracing can include indirect lighting and the ability to depict caustics (i.e., patterns of light and color that appear when light is reflected or refracted from a surface). Therefore, ray tracing can result in the generation of photo-realistic images. Ray tracing can be utilized by several different processors (such as a graphics processing unit (GPU) or a central processing unit (CPU)) within graphics processing or data processing.

[0055] Figure 3 A diagram 300 is illustrated that includes an example of a ray tracing process. Figure 3 As shown, diagram 300 includes camera 310 , image plane 320 including pixels 322 , scene objects 330 , light sources 340 , line of sight 350 , and shadow rays 352 . Figure 3 Line of sight 350 is shown being tracked from camera 310 and through image plane 320. After passing through image plane 320, line of sight 350 is tracked to scene object 330. At least some of line of sight 350 are tracked away from scene object 330 and to light source 340 as shadow rays 352. Thus, shadow rays 352 and line of sight 350 may track light from light source 340. Figure 3 Depicted is how ray tracing may generate an image by tracing the path of light (eg, from light source 340 ) to pixels in an image plane (eg, pixel 322 in image plane 320 ).

[0056] Ray tracing is distinguishable from several other rendering techniques utilized in graphics processing, such as rasterization. In the process of rasterization, for each pixel in each primitive in the scene, the pixel may be shaded if a portion of the pixel is covered by the primitive. In contrast, in the process of ray tracing, for each pixel corresponding to a primitive in the scene, a ray is generated. If the generated ray is determined to hit or intersect a primitive, the pixel is shaded. In some instances of graphics processing, ray tracing algorithms may be performed together with rasterization (such as via a hybrid ray tracing / rasterization model).

[0057] Figure 4A and Figure 4B Graphs 400 and 450 illustrate an example process including rasterization and an example process including ray tracing, respectively. Figure 4A As shown, diagram 400 includes scene objects 410 and pixels 420 . Figure 4A Depicted is the rasterization process for each pixel 420 in a scene including a scene object 410 determining that the pixel is shaded if a portion of the pixel is covered by a primitive. Figure 4B As shown, diagram 450 includes scene objects 460 , pixels 470 , light sources 480 , shadow rays 482 , and primary rays 484 . Figure 4B The process of ray tracing is depicted as determining that a pixel is shaded if a generated ray (eg, shadow ray 482 ) will hit or intersect a primitive in scene object 460 corresponding to one of pixels 470 via primary ray 484 .

[0058] As indicated herein, the process of ray tracing can be performed by determining whether a ray will hit / intersect any primitive(s) in a scene. For example, a ray tracing algorithm can perform a simple query operation: Does a given ray hit / intersect any primitive in the scene? The process of ray tracing is computationally intensive because a large number of rays can be traced for a large number of primitives / triangles, which can utilize a large number of ray-triangle intersection tests. For example, in a ray tracing procedure, approximately 1 million rays can be traced for approximately 1 million primitives / triangles, which can utilize approximately 1 trillion ray-triangle intersection tests. In some aspects of the ray tracing procedure, the origin of a given ray can be represented by O(N). Further, there can be several values ​​calculated for a ray, such as the minimum time (t min ), the maximum time of intersection with primitives in the scene (t max ) and the calculated distances of intersections with primitives in the scene.

[0059] Figure 5 A diagram 500 is illustrated that includes an example of a ray tracing process. Figure 5 As shown, diagram 500 includes the origin of the ray (O(N) 510), the minimum time to intersect a primitive in the scene (t min 520), the maximum time of intersection with the primitives in the scene (t max 522), a calculated distance (distance 530) intersecting with a primitive in the scene, and a number of primitives in the scene (primitive 540, primitive 541, and primitive 542). Figure 5 It is shown that ray tracing techniques can use several values ​​to determine whether a ray will hit a primitive. For example, to determine whether a ray will intersect a primitive, the ray tracing technique can use the origin of the ray (O(N) 510), the minimum time to intersect the primitive (t min 520), the maximum time of intersection with the primitive (tmax 522), a calculated distance (distance 530) intersecting with a primitive, and a number of primitives (primitive 540, primitive 541, and primitive 542).

[0060] Ray tracing can utilize various data structures to accelerate the computation process, such as a bounding volume hierarchy (BVH). In a bounding volume hierarchy, primitives are stored in leaf nodes. Further, internal nodes can maintain access to aligned bounding boxes (AABBs) that encapsulate certain leaf node geometries. The data structure used for ray tracing can also use ray box intersections for internal nodes and / or use ray-triangle tests for leaf nodes. These types of data structures can reduce the computational complexity (N) of the ray tracing process, for example, reducing the computational complexity (N) by log(N).

[0061] Fig. 6A and Figure 6B Graphs 600 and 650 respectively illustrate example data structure techniques utilized in ray tracing. Fig. 6A As shown, the diagram 600 includes several nodes (internal nodes N 611 To N 617 ) and several primitives (element O 621 To 628 ). Fig. 6A Depicts the internal node N 611 To N 617 and element O 621 To 628 The ray boxes of . Figure 6B As shown, the diagram 650 includes several nodes (leaf nodes N 661 To N 667 ) and several primitives (element O 671 To 678 ). Figure 6B Depicts the leaf node N 661 To N 667 and element O 671 To 678 The ray-triangle test. Fig. 6A and Figure 6B Two data structure techniques in (e.g., ray-box intersection and ray-triangle testing) are designed to reduce the computational complexity of ray tracing.

[0062] As indicated herein, there are several different stages during the ray tracing process. For example, the stages of ray tracing may include: hierarchy construction and refinement, ray generation, hierarchy traversal, ray-triangle intersection, and ray box intersection. There may also be different steps during hierarchy construction, including separating triangles into groups, forming bounding boxes around each group, and recursively separating each group. Additionally, during hierarchy construction, there may be several ways of separation, which may result in a certain number of possible solutions, for example, 2 n log n Therefore, these improved solutions can result in improved ray tracing performance.

[0063] Aspects of ray tracing may also utilize several hierarchical bounding volume algorithms, such as split hierarchical bounding volume (SBVH) and linear hierarchical bounding volume (LBVH). In some instances, SBVH may result in slower build times and better quality than LBVH. Similarly, LBVH may result in faster build times and worse quality than SBVH. Additionally, some aspects of ray tracing may utilize hierarchical bounding volume refinement. In hierarchical bounding volume refinement, given a binary BVH with one triangle per leaf, ray tracing techniques may replace tree topology. Hierarchical bounding volume refinement may utilize different algorithms, such as treelet reconstruction BVH (TRBVH) and parallel reinsertion BVH (PRBVH). Some aspects of ray tracing may also utilize BVH widening, which may convert a binary tree (i.e., an initial BVH) into a wider BVH than a binary tree or an initial BVH. For example, a hierarchy in an initial BVH may include three levels, wherein primitives are included in the third level of the hierarchy. The hierarchy in the wide BVH may include two levels, where primitives are included in the second level of the hierarchy. In some instances of BVH widening, the wide BVH may include internal nodes with a certain number of AABBs (e.g., up to eight AABBs) and leaf nodes with a certain number of primitives / triangles (e.g., up to four primitives / triangles).

[0064] As indicated herein, some aspects of ray tracing can utilize hierarchical bounding volume compression. For example, ray tracing techniques can compress wide nodes to accommodate a fixed size (e.g., 64 bytes). BVH compression can compress all contents of both internal nodes and leaf nodes to a certain amount (e.g., 64 bytes). In some instances, the BVH compression process can be lossy compression (i.e., a data compression method in which the size of data is reduced by reducing or eliminating data) or lossless compression (i.e., a data compression method that allows the original data to be reconstructed from the compressed data). BVH compression can also be aligned with cache lines. Further, BVH compression can store primitive / triangle data together with the BVH so that the data may not need to be extracted separately, for example, by a ray tracing unit (RTU). The BVH compression process can allow the GPU to improve bandwidth.

[0065] Fig. 7A and Figure 7B Graphs 700 and 750 are illustrated, respectively, including an example internal node structure and an example leaf node structure utilized in ray tracing. Fig. 7A As shown, diagram 700 includes internal nodes 710 , which include AABB 711 , AABB 712 , AABB 713 , AABB 714 , AABB 715 , AABB 716 , AABB 717 , and AABB 718 . Fig. 7A It is depicted that BVH compression may include compressing a certain number of AABBs (e.g., eight AABBs) and / or internal node compression of the index of the first child node. Figure 7B As shown, graph 750 includes a leaf node 760 , which includes primitive 761 , primitive 762 , primitive 763 , and primitive 764 . Figure 7B It is depicted that BVH compression may also include compressing a certain amount of primitives / triangles (eg, up to four primitives / triangles) as well as leaf node compression of corresponding indices.

[0066] Some aspects of BVH compression can utilize wide BVH nodes, i.e., BVH nodes with more child nodes (e.g., 8 child nodes) than other BVH nodes. In some instances, each wide BVH node can be compressed and stored (e.g., stored in 64 bytes). These types of nodes can be stored / packed tightly without empty space. Child nodes can be adjacent to each other, but can also be stored in any location. This type of BVH compression can allow random access to consecutive blocks. In addition, each step in the BVH compression step can be performed on the GPU in compute mode.

[0067] Ray tracing techniques may also utilize bounding volume hierarchy (BVH) traversals, such as breadth-first search traversals and / or depth-first search traversals of wide BVHs. Some aspects of ray tracing generation may utilize operations that generate rays in the air. For example, several different types of rays may be generated, such as primary rays, shadow rays, and / or secondary rays. Additionally, there may be several different ray tracing stages utilized in hardware or software (e.g., GPU / CPU hardware or software). For example, at certain stages, the driver may construct a BVH on the CPU or GPU (e.g., a BVH construction stage and a BVH node compression stage). In the BVH traversal stage, the BVH traversal may occur in a shader at the GPU. In addition, certain stages may be implemented in GPU hardware (e.g., a BVH node decompression stage, a ray-bounding box intersection stage, and a ray-triangle intersection stage).

[0068] As mentioned herein, an internal node of a BVH structure may contain a certain amount of access aligned bounding boxes (AABBs) (e.g., Fig. 7A As shown, up to 8 AABBs). Each of the valid sub-AABBs can be stored / packed contiguously in the internal node (e.g., starting at index 0). In addition, each of these sub-AABBs can be associated with a maximum AABB value and a minimum AABB value. In some instances, an invalid child node can have a minimum AABB value greater than the maximum AABB value. The internal node can also include an integer node ID of the first child node (e.g., a 32-bit integer node). Further, each of these child nodes can be contiguous in the internal node. In addition, the order of these child nodes can be used to represent traversal priority.

[0069] In some aspects, the process of BVH compression may include several different internal node compression algorithms. For example, the internal node compression algorithm may determine the minimum coordinate in each dimension. The internal node compression algorithm may also calculate the offset from the anchor node. In addition, the internal node compression algorithm may find and store the exponent of the maximum offset of each dimension. The internal node compression algorithm may also shift the mantissa of the offset (i.e., the part of the floating point number representing the significant digits of the number) to share the exponent value. In addition, the internal node compression algorithm may round the mantissa to several bits (e.g., 8 bits). In some instances, the internal node compression algorithm may be lossy compression, and it may succeed most of the time. The BVH compression process may also be lossless compression. If BVH compression fails, the internal node may be split into more leaf nodes. The leaf node may include a fairly uniform distribution of primitives per leaf node. Further, if BVH compression fails, the weight of the non-compressed node may be increased, and the node optimizer may select different separations.

[0070] Additionally, the process of BVH compression can include an internal node decompression algorithm. For example, the internal node decompression algorithm can recreate the coordinate offsets, such as by the following steps: (1) shifting the mantissa based on the leading "1" value; (2) biasing the shared exponent based on the leading "1" value; and (3) packing / storing the offsets into floating point coordinates (e.g., 32-bit floating point coordinates). The internal node decompression algorithm can also recreate anchor nodes. Further, the internal node decompression algorithm can add anchor nodes to the coordinate offsets.

[0071] Fig. 8A and Figure 8B Graphs 800 and 850 are illustrated, respectively, including example leaf nodes and corresponding primitives utilized in ray tracing. Fig. 8A As shown, diagram 800 includes leaf node 810, which includes primitive 811, primitive 812, primitive 813, and primitive 814. Diagram 800 also depicts ray 820 and ray 822 intersecting leaf node 810. Since ray 820 and ray 822 intersect leaf node 810, they will be added to the traversal step of the ray tracing process. Figure 8B As shown, diagram 850 includes leaf node 860 (including primitive 861) and leaf node 870 (including primitive 871, primitive 872, and primitive 873). Diagram 850 also depicts that ray 880 and ray 882 do not intersect leaf node 860 or leaf node 870. Since ray 880 and ray 882 do not intersect leaf node 860 or leaf node 870, they are not added to the traversal steps of the ray tracing process. Since these two rays 880 and ray 882 do not hit any of leaf node 860 and leaf node 870, there is no need to perform two traversal steps for these two rays. Therefore, as shown in FIG. Fig. 8A and Figure 8B As shown, a smaller number of primitives per leaf node can reduce the number of traversal steps, which in turn can save bandwidth and / or increase processing speed. On the contrary, if there are more primitives per leaf node (e.g., 4 primitives per node), more traversal steps may need to be performed.

[0072] In some instances, there may be several unique floating point coordinates for each primitive in a node. For example, there may be up to 36 unique floating point coordinates in a node containing four primitives (i.e., 36 floating point coordinates per node = 3 vertices * 3 coordinates * 4 primitives). These nodes may contain several different primitives / triangles (e.g., 1, 2, 3 or 4 primitives / triangles). Additionally, these unique floating point coordinates of each primitive in a node may have a certain amount of entropy. These unique floating point coordinates may also be classified to sort out all coordinates. Further, in some instances, the difference between the current floating point coordinate and the previous floating point coordinate may be calculated.

[0073] The ray tracing process can utilize an acceleration data structure (AS). In some instances, without utilizing AS, the ray in the ray tracing process can intersect with each primitive in the scene. On the contrary, with the use of a suitable AS, the number of intersection operations can be reduced (e.g., reduced by up to log n). In one example, a scene with 1,000,000 triangles may require 20 intersection operations using the AS of the prior art. These types of data structures can be associated with the aforementioned BVH structure including AABB. As indicated herein, BVH is a binary tree whose root node contains AABB (including scene geometry). Each primitive in the node can be assigned to a left child node or a right child node. A child node can contain an AABB (including its assigned geometry), and the geometry can also be recursively assigned to a left child node or a right child node until a leaf node contains a small number of primitives (e.g., 4 or fewer primitives). In some examples, to achieve memory bandwidth gains, each of the BVH nodes may be compressed into a certain number of bytes (eg, 64 bytes) in order to take advantage of the cache line size.

[0074] In some aspects of ray tracing, leaf nodes may contain information about the actual primitives that make up the geometry of the scene. Leaf nodes may contain indices and vertex buffers for each of these primitives. However, leaf nodes may not contain the primitives themselves (i.e., the coordinates of the primitives per vertex may not be stored in the leaf nodes). For example, if the application program interface (API) allows different types of primitives, storing copies of primitives in leaf nodes may be an expensive proposition. In some instances, without compression, a primitive / triangle can be accommodated in a leaf node. In fact, without compression, four triangles stored in a leaf node may have to be stored as four separate leaf nodes, plus additional internal nodes to connect them. Further, without leaf node compression, the ray tracing unit (RTU) may face the following: a higher number of traversal loop iterations (i.e., hop counts) to trace rays, higher memory bandwidth consumption to extract individual nodes for each triangle (plus more internal nodes), and higher power consumption to extract and process additional nodes. In addition, the process of determining the number of primitives per leaf node may be a complex task. In some instances, these steps may include negative consequences, such as leaf node bloat (i.e., the size of the leaf nodes increases), which is not optimal for leaf node compression. Based on the above, it may be beneficial to store copies of primitives in leaf nodes using an efficient leaf node compression algorithm. It may also be beneficial to efficiently determine the number of primitives per leaf node.

[0075] Aspects of the present disclosure can utilize efficient leaf node compression algorithms to store copies of primitives in leaf nodes. Aspects of the present disclosure can also efficiently determine the number of primitives per leaf node. For example, aspects of the present disclosure can include a lossless compression mechanism for handling the compression of leaf nodes, wherein leaf nodes can store copies of primitives (i.e., floating point coordinates). In addition, each leaf node in these leaf nodes can contain several primitives (e.g., 1, 2, 3 or 4 primitives). Aspects of the present disclosure can utilize a combination of arithmetic compression techniques, that is, techniques that relate to performing reversible mathematical operations on the vertices of primitives and storing the results in several bits. This type of compression can compress up to a certain number of primitives / triangles (e.g., 3 or 4 primitives / triangles) into a certain number of bytes (e.g., 64 bytes).

[0076] In some instances, the various aspects presented herein can utilize leaf node compression algorithms. For example, the various aspects presented herein can include the ability to store triangle geometry within a BVH data structure. An application program interface (API) can specify a copy of the geometry to be generated, and the various aspects presented herein can compress the copy and store the copy according to an internal node. The various aspects presented herein can also support several primitive types per API. For example, the various aspects presented herein can support triangles as primitives (e.g., triangles with 3 vertices, 3 dimensions, and 4 bytes). The aspects presented herein can also support program primitives including AABBs with minimum and maximum vertices. In addition, the various aspects presented herein can support instances of underlying acceleration structures (BASS) including AABBs with minimum and maximum vertices. In addition, the various aspects of the present disclosure can store AABBs similar to primitives / triangles. For example primitives including three vertices, vertex 0 can correspond to the minimum AABB value, vertex 1 can correspond to the maximum AABB value, and vertex 2 can correspond to the minimum AABB value (i.e., the value that can be removed after compression). Further, the primitive ID or instance ID (e.g., 4-byte integer primitive ID or instance ID) of each primitive can be stored in the leaf node. In addition, the data structure can be used to interpret certain compressed nodes (e.g., 64-byte compressed nodes) for different numbers of primitives per leaf node.

[0077] Additionally, the various aspects presented herein can utilize a compression algorithm that compresses the primitive identifier (ID) and geometry ID of each primitive. The primitive ID and geometry ID can be compressed into several bits (e.g., 32 bits). The compression algorithm can compress the coordinates (e.g., floating-point coordinates or floating-point type coordinates) of each primitive. These coordinates can be used as predictors for other coordinates (e.g., other floating-point coordinates). The compression algorithm can also calculate the signed difference between the coordinates (e.g., the signed difference between the floating-point coordinates). In order to calculate the signed difference, the compression algorithm can use a monotonic adjustment value (i.e., monotone bit) for the value of the floating-point coordinates. The compression algorithm can also store the signed difference rather than the original floating-point coordinates. Further, the compression algorithm can cut or modify the difference between the coordinates to be less than several bits (e.g., less than 32 bits).

[0078] Fig. 9 A diagram 900 is illustrated that includes an example of a call flow for a compression algorithm. Fig. 9 As shown, diagram 900 includes several steps (e.g., steps 910, 920, 930, 940, 950, 960, 970, 980, 990, and 992) for a compression algorithm according to various aspects of the present disclosure. At step 910, the compression algorithm may reorder the triangles / primitives and the vertices of the triangles / primitives. For example, the compression algorithm may reorder the triangles and the vertices of the triangles to determine an order with ideal predictive power. For example, the compression algorithm may reorder the triangles and the vertices of the triangles in a winding-preserving manner (i.e., preserving the order in which the vertices rotate around the center of the triangle). Each triangle may have a clockwise winding or a counterclockwise winding. In some instances, the winding order may be determined when a user issues a drawing command and the vertices are processed by the rendering pipeline in the order provided by the vertex specification. At step 920, the compression algorithm may convert the bit pattern into a monotonic adjusted value. For example, the compression algorithm may convert the bit pattern into a monotonic real-valued monotonic by converting it into a monotonic format (e.g., a monotonic bit format). At step 930, the compression algorithm can apply a lossy shift (i.e., rounding floating point numbers to discard the least significant bits). At step 940, the compression algorithm can store the primitive / triangle and vertex values ​​at full precision. For example, the compression algorithm can store the triangle and vertex values ​​(e.g., triangle 0, vertex 0) at full precision as anchor values ​​for the algorithm. Fig. 9At step 950 in, for each coordinate, the compression algorithm can calculate the difference between the current coordinate and the previous coordinate. For example, the difference can be between the previous coordinates of the same dimension, as a 2-back difference (BACK_2) (i.e., the coordinate value is adjusted backward by 2 coordinate values) or a 4-back difference (BACK_4) (i.e., the coordinate value is adjusted backward by 4 coordinate values) from the current coordinate. At step 960, the compression algorithm can store the difference between the current coordinate and the previous coordinate. For example, the BACK_2 value or the BACK_4 value can be stored as an enumeration (e.g., this can be implicit for coordinates '0' or '1'). At step 970, the compression algorithm can calculate the number of bits in the difference value and fill a certain amount of bits (e.g., fill up to 0, 16, 20 or 24 bits). At step 980, the compression algorithm can store the difference in the incremental width value of the coordinate. For example, the difference width enumeration can be stored in the deltaWidths array. At step 990, the compression algorithm can use a selected number of bits to store the filled difference in the incremental value. At step 992, the compression algorithm may store the vertex permutation for each primitive / triangle (eg, in a "vertPerms" field so that the value may be inverted later).

[0079] In some instances, each compressed leaf node may be stored in a location, and the location may in turn be compressed. For example, as an indicator of the remaining entropy after compression, all compressed leaf nodes may be stored in a file and compressed using a file compressor. These file compressors may be able to compress the file by an additional amount (e.g., 21% compression), which may indicate a suitable level of compression performance for the compression algorithm. The compression algorithm may also be used with block-based compression, which may not exploit cross-node redundancy.

[0080] Aspects of the present disclosure can compress the primitive ID and geometry ID of certain primitives. For example, the primitive ID and geometry ID of each of these primitives can be packed / compressed into a plurality of bit integers (e.g., a 32-bit integer). The primitive ID can then be stored in a number of bytes (e.g., 4 bytes). The remaining primitive IDs can be stored as differences in front of the array near the increment. In addition, the difference can be rounded up to the nearest byte. For example, if the difference between the primitive IDs is +1, the value can be stored in 0 bytes. In addition, an enumeration can be used to indicate the type of packing, wherein the enumeration is stored in front of the incremental width array. The enumeration can be a bit field, wherein the bit encoding represents a symbol value. For example, a two-bit enumeration can have values ​​00, 01, 10, and 11. These values ​​can be used to represent different modes or states. For example, the CrdWidth enumeration can correspond to 0, 16, 20, and 24 bits.

[0081] In some instances, the various aspects presented herein can use coordinates (e.g., floating point coordinates) as a way to predict other coordinates. The various aspects presented herein can also calculate the signed difference from one coordinate to another coordinate. For example, monotone bit coordinates can be used as integer values ​​(e.g., monotone adjustment values). Then, the difference between the coordinates can be stored instead of the original coordinate values. Further, the difference between the coordinates can be trimmed or modified to a certain number of bits (e.g., less than 32 bits).

[0082] As indicated herein, floating point coordinates may not produce sufficiently monotonic values ​​to produce results suitable for compression. Therefore, the binary representation of the floating point coordinates can be converted to monotonic values. Fig. 10A and Fig. 10B Graphs 1000 and 1050 are illustrated, respectively, and include examples of binary representations of floating point coordinates and monotonic numerical values ​​of floating point coordinates. Fig. 10A As shown, curve 1000 includes x-axis values ​​from [0x0000000] to [0xffffffff] and y-axis values ​​from [-∞] to [∞]. Curve graph 1000 plots binary representations of floating-point coordinates from [0x0000000] to [0x7fffffff] and [0x8000000] to [0xffffffff] (i.e., these values ​​represent the bit encodings of all possible 32-bit numbers). These 32-bit encodings can be used to represent floating-point numbers. For example, if a 32-bit number is interpreted as an integer, integer mathematical operations can be performed on the 32-bit number. Similar to curve graph 1000, curve graph 1050 also includes x-axis values ​​from [0x0000000] to [0xffffffff] and y-axis values ​​from [-∞] to [∞]. Graph 1050 also plots binary representations of floating point coordinates from [0x0000000] to [0x7fffffff] and [0x8000000] to [0xffffffff]. Fig. 10B As shown, Fig. 10A The floating point coordinates in are converted to Fig. 10B More specifically, in Fig. 10B middle, Fig. 10A The floating-point coordinates in are converted into bit vectors that are monotonic in floating-point values. Fig. 10B As shown, the bit pattern of the floating point coordinates is monotonic except for the discontinuity at the sign.

[0083] Additionally, the various aspects presented herein can compress or pack floating point coordinates. For example, the various aspects presented herein can classify coordinates for use in predicting other coordinates, including bits for indexing these coordinates. In some instances, the order of triangles in a node can be unconstrained, and the order of vertices in a triangle can be unconstrained, but the winding order can be preserved. In addition, various aspects of the present disclosure can permute triangles for optimized prediction without storing pattern enumerations. In some instances, when compression speed is an issue, the compressor can use heuristics to select permutations of triangles rather than trying every possible permutation.

[0084] Aspects of the present disclosure may also utilize offsets for coordinate prediction. For example, each coordinate may be predicted using a coordinate back-off 2 algorithm or a coordinate back-off 4 algorithm. Fig. 9 As described in step 950 of , for each coordinate, the compression algorithm can calculate the difference between the current coordinate and the previous coordinate. For example, the difference can be between the previous coordinates of the same dimension as a back 2 difference (BACK_2) from the current coordinate (i.e., adjusting the coordinate value back by 2 coordinate values) or a back 4 difference (BACK_4) from the current coordinate (i.e., adjusting the coordinate value back by 4 coordinate values).

[0085] Fig.11 A diagram 1100 is illustrated that includes an example of a compression algorithm (eg, BACK_2 algorithm and BACK_4 algorithm). Fig.11 As shown, diagram 1100 includes coordinate values ​​1110, 1111, 1112, 1113, 1114, 1115, and 1116 (eg, floating point coordinate values), BACK_2 algorithm 1120, and BACK_4 algorithm 1130. Fig.11 As depicted, BACK_2 algorithm 1120 adjusts the coordinate value backward by two coordinate values. For example, according to BACK_2 algorithm 1120, coordinate value 1116 will be adjusted to coordinate value 1114. Fig.11 As further depicted in FIG. 1 , BACK_4 algorithm 1130 adjusts the coordinate value backward by four coordinate values. For example, according to BACK_4 algorithm 1130, coordinate value 1116 will be coordinate value 1112. For BACK_2 algorithm 1120 and BACK_4 algorithm 1130, there are some special cases. For example, the first coordinate value (e.g., coordinate value 1110) may not have a predicted value because it is an anchor coordinate. In addition, the enumeration of the first two coordinates (e.g., coordinate value 1110 and coordinate value 1111) may not be stored. In BACK_4 algorithm 1130, coordinate value 1112 corresponds to coordinate value 1111, and coordinate value 1113 corresponds to coordinate value 1110. In addition, coordinate value 1111 may be implicitly predicted by coordinate value 1110.

[0086] Aspects of the present disclosure may also include a lossy shift component of the algorithm. For example, lossy shift may shift N least significant bits (LSB) to the right to improve the compression success rate. This lossy shift is acceptable for instance and programmatic (AABB) primitives. In addition, lossy shift may allow instance nodes to accommodate metadata values ​​(e.g., instance mask (InstanceMask) and instance flag (InstanceFlag)) associated with each AABB of each primitive. Lossy shift may also be performed on triangles, but it is lossy, so it may not be optimal to use it on all triangles. Further, lossy shift may be decompressed with a left shift of N bits. The purpose of lossy shift may be to store AABB primitives in a reduced amount of space so that space can be used for metadata. Lossy shift may be applied to all coordinates of leaf nodes, including those coordinates where each leaf node and anchor node has 1 primitive. In addition, N bits can be stored in a two-bit lossy shift flag of the leaf node, for example, LOSSY_SHIFT_0=0, LOSSY_SHIFT_4=1, LOSSY_SHIFT_8=2, and LOSSY_SHIFT_16=3. During decompression, the lossy shift can be applied before the monotone bit to floating point coordinate conversion (i.e., monoBitsToFloat conversion). After the lossy shift, a certain number of LSBs (e.g., N LSBs) can be equal to 0. Lossy shift can be used mainly with AABB coordinates, which can conservatively tolerate precision loss (like internal node AABB). However, lossy shift can also be used with leaf nodes containing triangles, which can introduce simple lossy compression. In some compression instances, improving compression may be more important than improving precision. When lossy shift is applied to triangle coordinates, it may be important to apply the same shift to all coordinates in BLAS. This ensures that shared coordinates (such as those in a triangle strip) will continue to have exactly the same values ​​and no small gaps will be introduced between them that could break the watertightness of the node.

[0087] In some instances, each BVH node can be compressed to a certain number of bytes (e.g., 64 bytes). For example, the nodes can be stored / packed into 64-byte aligned memory accessible to the GPU. Typically, these nodes can be located in system memory, but the entire BVH structure can also be stored in graphics memory (GMEM) to improve performance. Typically, the higher the position of a node in the BVH structure, the more frequently the node may be accessed, so storing the node in GMEM can allow for improved performance.

[0088] For internal nodes, the compression algorithm can determine the minimum coordinate in each dimension (i.e., the anchor coordinate) and store the coordinate as a floating point coordinate. The compression algorithm can then calculate the offset from the anchor coordinate (e.g., if the floating point coordinate is greater than or equal to 0). This can allow compression to identify the exponent of the maximum offset per dimension. The compression algorithm can then align the mantissa to share the exponent and round the mantissa to a certain amount of bits (e.g., 8 bits). Further, the compression algorithm can round down the minimum value and round up the maximum value. The compression algorithm may produce the following properties: compression will succeed most of the time, compression is lossy but conservative, and for an 8-bit offset mantissa, the algorithm can expect a certain amount of node overprocessing (e.g., 4% of nodes are overprocessed).

[0089] The compression algorithm of this article can also make use of metadata. For example, each primitive can have a 32-bit integer mixture of a primitive index and a geometric index. Masking these indexes together may be part of the binary BVH construction. Primitive IDs can be discontinuous and can be stored explicitly, and they can be compressed using a similar scheme to coordinate data. Anchors can be explicitly stored in primitive IDs (e.g., primitive ID 0). Subsequent indexes can be stored as increments of the immediately preceding index. The increments can be stored in an increment array, and the width can be stored as a two-bit enumeration (e.g., primitive ID enumeration) in an increment width array. Instance primitives can have additional metadata stored in the coordinate positions of primitive vertices (e.g., vertex 2).

[0090] Additionally, the compression algorithm can take advantage of primitive and vertex permutations. The application program interface (API) may not impose any constraints on the order of primitives in the BVH leaf nodes. Therefore, the compression algorithm can try multiple orderings until one is found with increments small enough to accommodate the increment field. Similarly, the triangle vertices can be reordered to reduce the size of the increment. However, in this case, the API can impose two constraints on the ordering: (1) the device API can query the UV coordinates of the hit (relative to the two edges of the triangle in API order), and (2) the device API can query whether the triangle is facing forward or backward, depending on the vertex ordering. Because vertex permutations facilitate compression, but the API imposes these constraints, the vertex permutations can be stored in the compressed file so that they can be reversed during decompression. In addition, a two-bit enumeration for each triangle can be utilized during the compression process.

[0091] Aspects of the present disclosure may include several benefits or advantages. For example, the aspects presented herein may utilize an efficient leaf node compression algorithm to store copies of primitives in leaf nodes. Aspects of the present disclosure may also efficiently determine the number of primitives per leaf node. Aspects of the present disclosure may also utilize lossless compression with a lossy variant that increases the success rate of compression. For example, by discarding a certain amount of floating point coordinates during compression, the compression success rate may be increased. Aspects presented herein may write all successfully compressed leaf nodes to disk. Then, the aspects presented herein may compress the file with a high success rate. By compressing with a high success rate, the aspects presented herein may improve ray tracing performance and optimize memory bandwidth.

[0092] Fig.12 FIG. 12 is a communication flow diagram 1200 of a graphical process according to one or more techniques of this disclosure. Fig.12 As shown, diagram 1200 includes example communications between components of a GPU (or other graphics processor), such as GPU component 1202, GPU component 1204, and memory 1206 (eg, GMEM or system memory), in accordance with one or more techniques of this disclosure.

[0093] At 1210, GPU component 1202 may obtain a hierarchical bounding volume (BVH) structure, the hierarchical bounding volume (BVH) structure including a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives (e.g., primitive 1212) in a scene, each of the plurality of nodes including one or more of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a floating point coordinate set. The primitives (e.g., primitive 1212) in the scene may be received from another component or another portion of the GPU (e.g., GPU component 1204). Each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives may be associated with an axis-aligned bounding box (AABB). In addition, each floating point coordinate in the floating point coordinate set may correspond to a minimum AABB value or a maximum AABB value. Each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives may be associated with a predicted offset of each floating point coordinate in the floating point coordinate set. For example, to obtain the predicted offset, the compression algorithm may calculate an offset from an anchor coordinate or node. The predicted offset may be the difference between the current coordinate and the previous coordinate of the same dimension, for example, backing off by 2 differences from the current coordinate (i.e., adjusting the coordinate value back by 2 coordinate values) or backing off by 4 differences from the current coordinate (i.e., adjusting the coordinate value back by 4 coordinate values).

[0094] In some aspects, the BVH structure may include multiple levels, and each level in the multiple levels may include at least one node in the multiple nodes. The multiple nodes may include multiple internal nodes and multiple leaf nodes, and the multiple internal nodes may be associated with multiple bounding boxes of multiple primitives, and the multiple leaf nodes may be associated with the geometric data of the multiple primitives. In addition, the BVH structure may be a data structure associated with a ray tracing process of multiple primitives in a scene, and the ray tracing process may include multiple rays associated with the geometric data of the multiple primitives. The one or more primitives included in each of the multiple nodes may include: one primitive, two primitives, three primitives, or four primitives.

[0095] At 1220, the GPU component 1202 can compress at least one of the primitive ID or the geometry ID of each of the plurality of primitives. At least one of the primitive ID or the geometry ID of each of the plurality of primitives can be compressed into a plurality of bits (e.g., 32 bits).

[0096] At 1230, GPU component 1202 can convert a binary representation of each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives into an integer value for each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives. The integer value for each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives can be a singleton adjusted value.

[0097] At 1240, the GPU component 1202 may calculate the difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each of the plurality of primitives. The calculated difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set may be a signed integer difference. In some aspects, at least one of the calculated difference between the converted binary representation of each floating-point coordinate in the floating-point coordinate set or the integer value of each floating-point coordinate in the floating-point coordinate set may be associated with a compression algorithm. For example, at least one of the calculated difference between the converted binary representation of each floating-point coordinate in the floating-point coordinate set or the integer value of each floating-point coordinate in the floating-point coordinate set may be an input to a compression algorithm or an output from a compression algorithm. The compression algorithm may adjust the order of a plurality of primitives, or may adjust one or more vertices of each of the plurality of primitives. The compression algorithm may also select several permutations for the adjusted order of primitives or vertices, for example, a first permutation of the adjusted order of a plurality of primitives or a second permutation of the adjusted one or more vertices of each of the plurality of primitives. The compression algorithm may also store a permutation of vertices for each primitive / triangle. Further, the compression algorithm may be associated with a lossy shift of each node in the plurality of nodes or each primitive in the plurality of primitives.

[0098] At 1250, GPU component 1202 can modify the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives. At least one of a primitive ID or a geometry ID for each primitive in the plurality of primitives can be compressed to 32 bits, and the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates can be modified to be less than 32 bits.

[0099] At 1260, GPU component 1202 may store at least one of the compressed primitive ID or the compressed geometry ID for each of the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates (e.g., data 1262). For example, data 1262 may be stored in memory 1206. At least one of the compressed primitive ID or the compressed geometry ID for each of the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates may be stored in graphics memory (GMEM) or system memory (e.g., memory 1206).

[0100] At 1270, GPU component 1202 can retrieve at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference (e.g., data 1262) after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. For example, data 1262 can be retrieved from memory 1206.

[0101] At 1280, the GPU component 1202 can perform a ray intersection on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. For example, the ray intersection of at least one of the plurality of nodes can be a ray triangle intersection for a plurality of interior nodes in the plurality of nodes and / or a ray box intersection for a plurality of leaf nodes in the plurality of nodes.

[0102] Fig.13 1300 is a flowchart of an example graphics processing method according to one or more techniques of the present disclosure. The method can be performed by a GPU (such as a device for graphics processing), a graphics processor, a CPU, a wireless communication device, and / or a combination thereof. Figures 1 to 12 The examples are performed using any device that can perform graphics processing. The methods described herein may provide several benefits, such as improved resource utilization and / or power savings.

[0103] At 1302, the GPU may obtain a bounding volume hierarchy (BVH) structure, the bounding volume hierarchy (BVH) structure including a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes including one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a set of floating-point coordinates, such as in combination with Figures 1 to 12 For example, Fig.12 As described in 1210 of the embodiment, the GPU component 1202 can configure a bounding volume hierarchy (BVH) structure, the bounding volume hierarchy (BVH) structure includes a plurality of nodes, the BVH structure is associated with geometric data of a plurality of primitives in the scene, each of the plurality of nodes includes one or more primitives in the plurality of primitives, and each of the plurality of primitives is associated with a primitive identifier (ID), a geometry ID, and a floating point coordinate set. Further, step 1302 can be performed by Figure 1 The processing unit 120 in the GPU may be executed. The primitives in the scene may be received from another component or another part of the GPU. Each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives may be associated with an axis-aligned bounding box (AABB). In addition, each floating-point coordinate in the floating-point coordinate set may correspond to a minimum AABB value or a maximum AABB value. Each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives may be associated with a predicted offset for each floating-point coordinate in the floating-point coordinate set.

[0104] In some aspects, the BVH structure may include multiple levels, and each level in the multiple levels may include at least one node in the multiple nodes. The multiple nodes may include multiple internal nodes and multiple leaf nodes, and the multiple internal nodes may be associated with multiple bounding boxes of multiple primitives, and the multiple leaf nodes may be associated with the geometric data of the multiple primitives. In addition, the BVH structure may be a data structure associated with a ray tracing process of multiple primitives in a scene, and the ray tracing process may include multiple rays associated with the geometric data of the multiple primitives. The one or more primitives included in each of the multiple nodes may include, for example: one primitive, two primitives, three primitives, or four primitives.

[0105] At 1304, the GPU may compress at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12 As described in step 1220, the GPU component 1202 may compress at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives. Further, step 1304 may be performed by Figure 1At least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives may be compressed into a plurality of bits (eg, 32 bits).

[0106] At 1306, the GPU may convert the binary representation of each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives into an integer value for each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives, such as by combining Figures 1 to 12 For example, Fig.12 As described in step 1230, the GPU component 1202 may convert the binary representation of each floating point coordinate in the floating point coordinate set of each of the plurality of primitives into an integer value of each floating point coordinate in the floating point coordinate set of each of the plurality of primitives. Further, step 1306 may be performed by Figure 1 The integer value of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives may be a single adjusted value.

[0107] At 1308, the GPU may calculate the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12 As described in 1240 of the embodiment, the GPU component 1202 can calculate the difference between the integer values ​​of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives. Further, step 1308 can be performed by Figure 1 The processing unit 120 in the floating-point coordinate set is executed. The calculated difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set can be a signed integer difference. In some aspects, at least one of the converted binary representation of each floating-point coordinate in the floating-point coordinate set or the calculated difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set can be associated with a compression algorithm. Using the compression algorithm, the GPU can adjust the order of multiple primitives, or can adjust one or more vertices of each of the multiple primitives. Using the compression algorithm, the GPU can also select a first permutation of the adjusted order of the multiple primitives or a second permutation of the adjusted one or more vertices of each of the multiple primitives. Further, the compression algorithm can be associated with a lossy shift of each of the multiple nodes or each of the multiple primitives.

[0108] At 1310, the GPU may modify the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12As described in step 1250, the GPU component 1202 may modify the difference between the integer values ​​of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives. Further, step 1310 may be performed by Figure 1 At least one of the primitive ID or the geometry ID of each of the plurality of primitives may be compressed into 32 bits, and the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates may be modified to be less than 32 bits.

[0109] Fig.14 1400 is a flowchart of an example graphics processing method according to one or more techniques of the present disclosure. The method can be performed by a GPU (such as a device for graphics processing), a graphics processor, a CPU, a wireless communication device, and / or a combination thereof. Figures 1 to 12 The examples are performed using any device that can perform graphics processing. The methods described herein may provide several benefits, such as improved resource utilization and / or power savings.

[0110] At 1402, the GPU may obtain a bounding volume hierarchy (BVH) structure, the bounding volume hierarchy (BVH) structure including a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes including one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a set of floating-point coordinates, such as in combination with Figures 1 to 12 For example, Fig.12 As described in 1210 of the embodiment, the GPU component 1202 can configure a bounding volume hierarchy (BVH) structure, the bounding volume hierarchy (BVH) structure includes a plurality of nodes, the BVH structure is associated with geometric data of a plurality of primitives in the scene, each of the plurality of nodes includes one or more primitives in the plurality of primitives, and each of the plurality of primitives is associated with a primitive identifier (ID), a geometry ID, and a floating point coordinate set. Further, step 1402 can be performed by Figure 1 The processing unit 120 in the GPU may be executed. The primitives in the scene may be received from another component or another part of the GPU. Each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives may be associated with an axis-aligned bounding box (AABB). In addition, each floating-point coordinate in the floating-point coordinate set may correspond to a minimum AABB value or a maximum AABB value. Each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives may be associated with a predicted offset for each floating-point coordinate in the floating-point coordinate set.

[0111] In some aspects, the BVH structure may include multiple levels, and each level in the multiple levels may include at least one node in the multiple nodes. The multiple nodes may include multiple internal nodes and multiple leaf nodes, and the multiple internal nodes may be associated with multiple bounding boxes of multiple primitives, and the multiple leaf nodes may be associated with the geometric data of the multiple primitives. In addition, the BVH structure may be a data structure associated with a ray tracing process of multiple primitives in a scene, and the ray tracing process may include multiple rays associated with the geometric data of the multiple primitives. The one or more primitives included in each of the multiple nodes may include: one primitive, two primitives, three primitives, or four primitives.

[0112] At 1404, the GPU may compress at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12 As described in step 1220, the GPU component 1202 may compress at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives. Further, step 1404 may be performed by Figure 1 At least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives may be compressed into a plurality of bits (eg, 32 bits).

[0113] At 1406, the GPU may convert the binary representation of each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives into an integer value for each floating point coordinate in the set of floating point coordinates for each of the plurality of primitives, such as by combining Figures 1 to 12 For example, Fig.12 As described in step 1230, the GPU component 1202 may convert the binary representation of each floating point coordinate in the floating point coordinate set of each of the plurality of primitives into an integer value of each floating point coordinate in the floating point coordinate set of each of the plurality of primitives. Further, step 1406 may be performed by Figure 1 The integer value of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives may be a single adjusted value.

[0114] At 1408, the GPU may calculate the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12As described in step 1240, the GPU component 1202 may calculate the difference between the integer values ​​of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives. Further, step 1408 may be performed by Figure 1 The processing unit 120 in the floating-point coordinate set is executed. The calculated difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set can be a signed integer difference. In some aspects, at least one of the converted binary representation of each floating-point coordinate in the floating-point coordinate set or the calculated difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set can be associated with a compression algorithm. The compression algorithm can adjust the order of multiple primitives, or can adjust one or more vertices of each of the multiple primitives. The compression algorithm can select a first permutation of the adjusted order of the multiple primitives or a second permutation of the adjusted one or more vertices of each of the multiple primitives. Further, the compression algorithm can be associated with a lossy shift of each of the multiple nodes or each of the multiple primitives.

[0115] At 1410, the GPU may modify the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives, such as in combination with Figures 1 to 12 For example, Fig.12 As described in step 1250, the GPU component 1202 may modify the difference between the integer values ​​of each floating point coordinate in the floating point coordinate set of each primitive in the plurality of primitives. Further, step 1410 may be performed by Figure 1 At least one of the primitive ID or the geometry ID of each of the plurality of primitives may be compressed into 32 bits, and the difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates may be modified to be less than 32 bits.

[0116] At 1412, the GPU may store at least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates, such as in combination with Figures 1 to 12 For example, Fig.12 As described in 1260 of FIG. 14, the GPU component 1202 may store at least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates. Further, step 1412 may be performed by Figure 1At least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates may be stored in a graphics memory (GMEM) or a system memory.

[0117] At 1414, the GPU may retrieve at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference, such as in conjunction with Figures 1 to 12 For example, Fig.12 As described in 1270 of , GPU component 1202 may retrieve at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. Further, step 1414 may be performed by Figure 1 The processing unit 120 in the embodiment is used for execution.

[0118] At 1416, the GPU may perform a ray intersection on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference, such as in conjunction with Figures 1 to 12 For example, Fig.12 As described in 1280 of , the GPU component 1202 may perform a ray intersection on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. Further, step 1416 may be performed by Figure 1 The processing unit 120 in the embodiment is used for execution.

[0119] In a configuration, a method or apparatus for graphics processing is provided. The apparatus may be a GPU, a graphics processor, or some other processor that may perform graphics processing. In various aspects, the apparatus may be a processing unit 120 within a device 104, or may be some other hardware within a device 104 or another device. The apparatus (e.g., processing unit 120) may include a component for obtaining a hierarchical bounding volume (BVH) structure, the hierarchical bounding volume (BVH) structure including a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes including one or more primitives in the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometric ID, or a floating point coordinate set. The apparatus (e.g., processing unit 120) may also include a component for compressing at least one of a primitive ID or a geometric ID of each of the plurality of primitives. The device (e.g., processing unit 120) may also include a component for converting a binary representation of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives into an integer value of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives. The device (e.g., processing unit 120) may also include a component for calculating a difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives. The device (e.g., processing unit 120) may also include a component for storing at least one of a compressed primitive ID or a compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating-point coordinate in the floating-point coordinate set. The device (e.g., processing unit 120) may also include a component for modifying the difference between the integer values ​​of each floating-point coordinate in the floating-point coordinate set of each primitive in the plurality of primitives. The apparatus (e.g., processing unit 120) may also include means for retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing the at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference. The apparatus (e.g., processing unit 120) may also include means for performing ray intersection on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference.

[0120] The subject matter described herein can be implemented to achieve one or more benefits or advantages. For example, the described graphics processing techniques can be used by a GPU, a graphics processor, or some other processor that can perform graphics processing to implement the node compression techniques described herein. Compared with other graphics processing techniques, this can also be implemented at a low cost. In addition, the graphics processing techniques herein can improve or accelerate data processing or execution. Further, the graphics processing techniques herein can improve resource or data utilization and / or resource efficiency. Additionally, various aspects of the present disclosure can utilize node compression techniques to improve memory bandwidth efficiency and / or increase processing speed at the GPU.

[0121] It should be understood that the specific order or hierarchy of the blocks in the disclosed process / flowchart is merely an illustration of the exemplary method. It should be understood that the specific order or hierarchy of the blocks in the process / flowchart may be rearranged based on design preferences. Further, some blocks may be combined or omitted. The attached method claims provide the elements of the various blocks in a sample order, but are not meant to be limited to the specific order or hierarchy provided.

[0122] The foregoing description is provided to enable any person skilled in the art to practice the various aspects described herein. Various modifications to these aspects will be apparent to those skilled in the art, and the general principles defined herein may be applied to other aspects. Therefore, the claims are not intended to be limited to the various aspects shown herein, but should be given the full scope consistent with the language of the claims, wherein unless otherwise specified, references to elements in the singular are not intended to mean "one and only one", but rather "one or more". The wording "exemplary" is used herein to mean "used as an example, instance, or illustration". Any aspect described herein as "exemplary" is not necessarily to be interpreted as being preferred or having advantages over other aspects.

[0123] Unless specifically stated otherwise, the term “some” refers to one or more, and the term “or” may be interpreted as “and / or” if the context does not dictate otherwise. Combinations such as “at least one of A, B, or C,” “one or more of A, B, or C,” “at least one of A, B and C,” “one or more of A, B, and C,” and “A, B, C, or any combination thereof” include any combination of A, B, and / or C, and may include multiple A, multiple B, or multiple C. Specifically, combinations such as “at least one of A, B, or C,” “one or more of A, B, or C,” “at least one of A, B, and C,” “one or more of A, B, and C,” and “A, B, C, or any combination thereof” may be only A, only B, only C, A and B, A and C, B and C, or A and B and C, wherein any such combination may include one or more members of A, B, or C. All structural and functional equivalents of the elements of various aspects described in this disclosure that are known or will be known to those of ordinary skill in the art are expressly incorporated herein by reference and are intended to be covered by the claims. In addition, nothing disclosed herein is intended to be disclosed to the public, regardless of whether such disclosure is explicitly stated in the claims. Words such as "module," "mechanism," "element," and "device" cannot replace the word "component." Therefore, no claim element will be understood as a component plus function unless the element is explicitly recorded using the phrase "component for..."

[0124] In one or more examples, the functions described herein can be implemented in hardware, software, firmware, or any combination thereof. For example, although the term "processing unit" is used throughout this disclosure, such processing unit can be implemented in hardware, software, firmware, or any combination thereof. If any function, processing unit, technique, or other module described herein is implemented in software, the function, processing unit, technique, or other module described herein can be stored or sent on a computer-readable medium as one or more instructions or codes.

[0125] According to the present disclosure, the term "or" may be understood as "and / or" in the absence of context dictating otherwise. Additionally, while phrases such as "one or more" or "at least one" may have been used with some features disclosed herein but not others, features not using such language may be understood to have such implicit meanings in the absence of context dictating otherwise.

[0126] In one or more examples, the functions described herein may be implemented in hardware, software, firmware, or any combination thereof. For example, although the term "processing unit" is used throughout this disclosure, such processing unit may be implemented in hardware, software, firmware, or any combination thereof. If any function, processing unit, technique, or other module described herein is implemented in software form, the function, processing unit, technique, or other module described herein may be stored on a computer-readable medium or sent on a computer-readable medium as one or more instructions or codes. A computer-readable medium may include a computer data storage medium or a communication medium, which includes any medium that facilitates the transmission of a computer program from one place to another. In this way, a computer-readable medium may generally correspond to (1) a non-transient tangible computer-readable storage medium or (2) a communication medium such as a signal or carrier wave. A data storage medium may be any available medium that can be accessed by one or more computers or one or more processors to retrieve instructions, codes, and / or data structures for implementing the techniques described in this disclosure. As an example and not limitation, such a computer-readable medium may include a RAM, a ROM, an EEPROM, a CD-ROM, or other optical disk storage device, a magnetic disk storage device, or other magnetic storage device. Disks and optical disks as used herein include compact discs (CDs), laser discs, optical discs, digital versatile discs (DVDs), floppy disks, and Blu-ray discs, where disks typically reproduce data magnetically, while optical discs reproduce data optically using lasers. Combinations of the above should also be included within the scope of computer-readable media. A computer program product may include a computer-readable medium.

[0127] The code may be executed by one or more processors, such as one or more digital signal processors (DSPs), general-purpose microprocessors, application-specific integrated circuits (ASICs), arithmetic logic units (ALUs), field programmable logic arrays (FPGAs), or other equivalent integrated or discrete logic circuits. Accordingly, the term "processor" as used herein may refer to any of the above structures or any other structure suitable for implementing the techniques described herein. In addition, these techniques may be fully implemented in one or more circuits or logic elements.

[0128] The technology of the present disclosure can be implemented in a variety of devices or apparatuses, including wireless mobile phones, integrated circuits (ICs) or IC groups (e.g., chipsets). Various components, modules or units are described in the present disclosure to emphasize the functional aspects of devices configured to perform the disclosed technology, but they do not necessarily need to be implemented by different hardware units. Specifically, as described above, the various units can be combined in any hardware unit, or provided by a collection of interoperable hardware units (including one or more processors as described above) in combination with suitable software and / or firmware. Accordingly, the term "processor" as used herein may refer to any of the above structures or any other structure suitable for implementing the technology described herein. In addition, these technologies can be fully implemented in one or more circuits or logic elements.

[0129] The following aspects are merely illustrative and may be combined with other aspects or teachings described herein without limitation.

[0130] Aspect 1 is a device for graphics processing, the device comprising at least one processor, the at least one processor coupled to a memory and configured to: obtain a bounding volume hierarchy (BVH) structure, the bounding volume hierarchy (BVH) structure comprising a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes comprising one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometric ID, or a set of floating-point coordinates; compress all the primitives of each of the plurality of primitives; The method comprises: converting a binary representation of each floating-point coordinate in the set of floating-point coordinates of each of the plurality of primitives into an integer value for each floating-point coordinate in the set of floating-point coordinates of each of the plurality of primitives; calculating a difference between the integer values ​​for each floating-point coordinate in the set of floating-point coordinates of each of the plurality of primitives; and storing at least one of the compressed primitive ID or the compressed geometry ID and the calculated difference between each floating-point coordinate in the set of floating-point coordinates of each of the plurality of primitives.

[0131] Aspect 2 is an apparatus according to Aspect 1, wherein the at least one processor is further configured to: retrieve at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference.

[0132] Aspect 3 is an apparatus according to any one of Aspects 1 and 2, wherein the at least one processor is further configured to: perform ray intersection on at least one of the multiple nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference.

[0133] Aspect 4 is an apparatus according to aspects 1 to 3, wherein at least one of the converted binary representation of each floating-point coordinate in the set of floating-point coordinates or the calculated difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is associated with a compression algorithm.

[0134] Aspect 5 is an apparatus according to any one of aspects 1 to 4, wherein the compression algorithm adjusts the order of the plurality of primitives, or adjusts one or more vertices of each of the plurality of primitives.

[0135] Aspect 6 is an apparatus according to any one of aspects 1 to 5, wherein the compression algorithm selects a first permutation of the adjusted order of the plurality of primitives or a second permutation of the adjusted one or more vertices of each of the plurality of primitives.

[0136] Aspect 7 is an apparatus according to any one of aspects 1 to 6, wherein the compression algorithm is associated with a lossy shift of each node in the plurality of nodes or each primitive in the plurality of primitives.

[0137] Aspect 8 is an apparatus according to any one of aspects 1 to 7, wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed into a plurality of bits.

[0138] Aspect 9 is an apparatus according to any one of aspects 1 to 8, wherein the at least one processor is further configured to: modify the difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates of each primitive in the plurality of primitives.

[0139] Aspect 10 is a device according to any one of Aspects 1 to 9, wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed to 32 bits, and the difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is modified to be less than 32 bits.

[0140] Clause 11 is an apparatus according to any one of clauses 1 to 10, wherein each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives is associated with an axis-aligned bounding box (AABB).

[0141] Aspect 12 is an apparatus according to any one of aspects 1 to 11, wherein each floating point coordinate in the set of floating point coordinates corresponds to a minimum AABB value or a maximum AABB value.

[0142] Aspect 13 is an apparatus according to any one of aspects 1 to 12, wherein each floating-point coordinate in the set of floating-point coordinates of each primitive in the plurality of primitives is associated with a prediction offset for each floating-point coordinate in the set of floating-point coordinates.

[0143] Aspect 14 is an apparatus according to any one of aspects 1 to 13, wherein the integer value of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives is a monotonic adjusted value.

[0144] Aspect 15 is an apparatus according to any one of aspects 1 to 14, wherein the calculated difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates is a signed integer difference.

[0145] Aspect 16 is an apparatus according to any one of aspects 1 to 15, wherein the one or more primitives included in each of the plurality of nodes include: one primitive, two primitives, three primitives, or four primitives.

[0146] Aspect 17 is an apparatus according to any one of aspects 1 to 16, wherein the BVH structure comprises a plurality of levels, and each level of the plurality of levels comprises at least one node of the plurality of nodes.

[0147] Aspect 18 is a device according to any one of Aspects 1 to 17, wherein the multiple nodes include multiple internal nodes and multiple leaf nodes, wherein the multiple internal nodes are associated with multiple bounding boxes of the multiple primitives, and wherein the multiple leaf nodes are associated with the geometric data of the multiple primitives.

[0148] Aspect 19 is an apparatus according to any one of Aspects 1 to 18, wherein the BVH structure is a data structure associated with a ray tracing process of the plurality of primitives in the scene, and wherein the ray tracing process includes a plurality of rays associated with the geometric data of the plurality of primitives.

[0149] Aspect 20 is a device according to any one of Aspects 1 to 19, wherein at least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating-point coordinate in the set of floating-point coordinates is stored in a graphics memory (GMEM) or a system memory.

[0150] Aspect 21 is an apparatus according to any one of aspects 1 to 20, wherein the apparatus is a wireless communication device, the apparatus further comprising at least one of an antenna or a transceiver coupled to the at least one processor.

[0151] Aspect 22 is a graphics processing method for implementing any one of aspects 1 to 21.

[0152] Aspect 23 is a device for graphics processing, the device comprising means for implementing any one of aspects 1 to 21.

[0153] Aspect 24 is a non-transitory computer readable medium storing computer executable code, which, when executed by at least one processor, causes the at least one processor to implement any one of aspects 1 to 21.

Claims

1. A device for graphics processing, the device include: Memory; and at least one processor coupled to the memory and configured to: Obtaining a bounding volume hierarchy (BVH) structure, the BVH structure comprising a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes comprising one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a set of floating-point coordinates; compressing at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives; converting a binary representation of each floating-point coordinate in the set of floating-point coordinates into an integer value; calculating a difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates; as well as At least one of a compressed primitive ID or a compressed geometry ID for each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates is stored.

2. The apparatus of claim 1 , wherein the at least one processor is further configured to: retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference; and A ray intersection is performed on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference.

3. The apparatus of claim 1 , wherein at least one of the converted binary representation of each floating-point coordinate in the set of floating-point coordinates or the calculated difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is associated with a compression algorithm, wherein the compression algorithm adjusts an order of the plurality of primitives or adjusts one or more vertices of each of the plurality of primitives. 4 . The apparatus of claim 3 , wherein the compression algorithm is associated with a lossy shift of each node in the plurality of nodes or each primitive in the plurality of primitives. 5 . The device of claim 1 , wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed into a plurality of bits.

6. The apparatus of claim 1, wherein the at least one processor is further configured to: The difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives is modified.

7. The apparatus of claim 6, wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed to 32 bits, and the difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is modified to be less than 32 bits.

8. The apparatus of claim 1, wherein each floating-point coordinate in the set of floating-point coordinates for each primitive in the plurality of primitives is associated with an axis-aligned bounding box (AABB). 9 . The apparatus of claim 8 , wherein each floating-point coordinate in the set of floating-point coordinates corresponds to a minimum AABB value or a maximum AABB value.

10. The apparatus of claim 1, wherein each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives is associated with a prediction offset for each floating point coordinate in the set of floating point coordinates.

11. The apparatus of claim 1, wherein the integer value of each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives is a single-scale value.

12. The apparatus of claim 1, wherein the calculated difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates is a signed integer difference. 13 . The apparatus of claim 1 , wherein the BVH structure comprises a plurality of levels, and each level of the plurality of levels comprises at least one node of the plurality of nodes.

14. The apparatus of claim 1, wherein the plurality of nodes comprises a plurality of internal nodes and a plurality of leaf nodes, wherein the plurality of internal nodes are associated with a plurality of bounding boxes of the plurality of primitives, and wherein the plurality of leaf nodes are associated with the geometric data of the plurality of primitives.

15. The apparatus of claim 1, wherein the BVH structure is a data structure associated with a ray tracing process for the plurality of primitives in the scene, and wherein the ray tracing process includes a plurality of rays associated with the geometric data for the plurality of primitives.

16. The apparatus of claim 1 , wherein at least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating-point coordinate in the set of floating-point coordinates is stored in graphics memory (GMEM) or system memory.

17. The apparatus of claim 1, wherein the apparatus is a wireless communication device, the apparatus further comprising at least one of an antenna or a transceiver coupled to the at least one processor.

18. A graphics processing method, the method include: Obtaining a bounding volume hierarchy (BVH) structure, the BVH structure comprising a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes comprising one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a set of floating-point coordinates; compressing at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives; converting a binary representation of each floating-point coordinate in the set of floating-point coordinates into an integer value; calculating a difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates; as well as At least one of a compressed primitive ID or a compressed geometry ID for each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates is stored.

19. The method according to claim 18, further comprising: include: retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference after storing at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference; as well as A ray intersection is performed on at least one of the plurality of nodes after retrieving at least one of the compressed primitive ID, the compressed geometry ID, or the calculated difference.

20. The method of claim 18, wherein at least one of the converted binary representation of each floating-point coordinate in the set of floating-point coordinates or the calculated difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is associated with a compression algorithm, wherein the compression algorithm adjusts an order of the plurality of primitives or adjusts one or more vertices of each of the plurality of primitives.

21. The method of claim 20, wherein the compression algorithm is associated with a lossy shift of each node in the plurality of nodes or each primitive in the plurality of primitives.

22. The method of claim 18, wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed into a plurality of bits.

23. The method according to claim 18, further comprising: include: The difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates of each primitive in the plurality of primitives is modified.

24. The method of claim 23, wherein at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives is compressed to 32 bits, and the difference between the integer values ​​of each floating-point coordinate in the set of floating-point coordinates is modified to be less than 32 bits.

25. The method of claim 18, wherein each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives is associated with an axis-aligned bounding box (AABB).

26. The method of claim 25, wherein each floating point coordinate in the set of floating point coordinates corresponds to a minimum AABB value or a maximum AABB value.

27. The method of claim 18, wherein each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives is associated with a prediction offset for each floating point coordinate in the set of floating point coordinates.

28. The method of claim 18, wherein the integer value of each floating point coordinate in the set of floating point coordinates for each primitive in the plurality of primitives is a monotonically adjusted value.

29. The method of claim 18, wherein the calculated difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates is a signed integer difference.

30. The method of claim 18, wherein the BVH structure comprises a plurality of levels, and each level of the plurality of levels comprises at least one node of the plurality of nodes.

31. The method of claim 18, wherein the plurality of nodes comprises a plurality of internal nodes and a plurality of leaf nodes, wherein the plurality of internal nodes are associated with a plurality of bounding boxes of the plurality of primitives, and wherein the plurality of leaf nodes are associated with the geometric data of the plurality of primitives.

32. The method of claim 18, wherein the BVH structure is a data structure associated with a ray tracing process for the plurality of primitives in the scene, and wherein the ray tracing process includes a plurality of rays associated with the geometric data for the plurality of primitives.

33. The method of claim 18, wherein at least one of the compressed primitive ID or the compressed geometry ID of each primitive in the plurality of primitives and the calculated difference between the integer value of each floating-point coordinate in the set of floating-point coordinates is stored in graphics memory (GMEM) or system memory.

34. A non-transitory computer readable medium storing computer executable code for graphics processing, the code when executed by a processor causing the processor to: Obtaining a bounding volume hierarchy (BVH) structure, the BVH structure comprising a plurality of nodes, the BVH structure being associated with geometric data of a plurality of primitives in a scene, each of the plurality of nodes comprising one or more primitives of the plurality of primitives, and each of the plurality of primitives being associated with at least one of a primitive identifier (ID), a geometry ID, or a set of floating-point coordinates; compressing at least one of the primitive ID or the geometry ID of each primitive in the plurality of primitives; converting a binary representation of each floating-point coordinate in the set of floating-point coordinates into an integer value; calculating a difference between the integer values ​​of each floating point coordinate in the set of floating point coordinates; as well as At least one of a compressed primitive ID or a compressed geometry ID for each primitive in the plurality of primitives and the calculated difference between the integer value of each floating point coordinate in the set of floating point coordinates is stored.