CN107885597B - Method for managing graphics rendering resources - Google Patents
Method for managing graphics rendering resources Download PDFInfo
- Publication number
- CN107885597B CN107885597B CN201710846042.0A CN201710846042A CN107885597B CN 107885597 B CN107885597 B CN 107885597B CN 201710846042 A CN201710846042 A CN 201710846042A CN 107885597 B CN107885597 B CN 107885597B
- Authority
- CN
- China
- Prior art keywords
- resource
- rendering
- graphics
- graphic
- resources
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T1/00—General purpose image data processing
- G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T15/00—3D [Three Dimensional] image rendering
- G06T15/04—Texture mapping
Abstract
The invention discloses a management method of a graphic rendering resource, which comprises the following steps: when a scene is initialized, initializing various graphic resource managers of each graphic environment; in the scene updating or rendering process, acquiring a graphic resource manager through acquiring a graphic environment to allocate graphic resources; after the scene is updated, rendering data are uniformly submitted to a GPU before rendering, and a CPU memory occupied by the rendering data is released; recycling the rendering resources which are idle; before the rendering scene is finished, the graphics resource managers in the graphics environments release the rendering resources managed by the graphics environments, and the graphics environments destroy the rendering resource managers owned by the graphics environments. The invention solves the problems of random use of graphics rendering resources, high occupation rate of GPU video memory and low rendering efficiency when a rendering engine renders a large scene; the application and allocation of the graphics rendering resources are effectively controlled and managed, and the graphics rendering resources are used neatly and orderly.
Description
Technical Field
The invention relates to a method for efficiently organizing and managing OpenGL rendering resources in a rendering engine in the technical field of three-dimensional rendering, in particular to a method for managing graphics rendering resources.
Background
The user gives a three-dimensional scene graph structure, and the effect desired by the user is obtained through rendering by using different types of OpenGL rendering resources. When the data volume of the three-dimensional scene is huge, the texture data volume is especially huge, and the amount of graphics rendering resources applied to be used in the situation is also huge. If the graphics resource applicant can apply for, upload and release the graphics resources independently at will, the stability of the rendering engine and the control of the GPU video memory are very unfavorable, and in addition, the rendering efficiency of the rendering engine is greatly influenced by the frequent interaction time with the GPU. Therefore, it is important for the rendering engine to uniformly manage graphics rendering resources.
The management mechanism of the graphic rendering resources is added, so that the control of application, distribution, recovery and release of the rendering resources, the quantity control and the control of unified data submission can be realized, meanwhile, the interaction times with a GPU can be reduced, and the rendering efficiency is improved.
Disclosure of Invention
The invention provides a management method of graphics rendering resources, aiming at the phenomena of random use of the graphics rendering resources, high GPU video memory occupancy rate and low rendering efficiency when a rendering engine renders a large scene in the prior art.
In order to solve the technical problems, the invention is solved by the following scheme:
a method for managing graphics rendering resources, comprising the steps of:
when a scene is initialized, initializing various graphic resource managers of various graphic environments;
in the scene updating or rendering process, a resource applicant obtains a graphic resource manager by obtaining a graphic environment, and applies and allocates graphic resources through the graphic resource manager;
before rendering after scene updating, the graphics resource manager uniformly submits rendering data to a GPU and releases a CPU memory occupied by the rendering data;
the graphics resource manager will perform the operation of recovering the idle rendering resources released by the applicant in each frame;
before the rendering scene is finished, the graphics resource managers in the graphics environments release the rendering resources managed by the graphics environments, and the graphics environments destroy the rendering resource managers owned by the graphics environments.
The types of the graphics resource manager initialized in the step (1) are as follows: a texture resource manager (TextureResourceManager), a display list resource manager (ListResourceManager), a texture buffer resource manager (renderbuffereurcemanager), a frame buffer object resource manager (framebuffereurcemanager), a vertex buffer object resource manager (buffereurcemanager), a program resource manager (ProgramResourceManager), and a shader resource manager (shadereresourcemanager).
Wherein, each image resource manager in step (1) manages three graphics resource queues: an allocated data uncommitted resource queue, an allocated data committed queue, and a reclaimed free resource queue, each rendering resource having a rendering resource ID.
When the graphics resource manager applies for graphics rendering resources in step (2), firstly, fetching graphics resources from the idle resource queue, and if the idle resource queue is not empty, fetching the head of the queue to fetch a resource to allocate to the applicant; and if the idle resource queue is empty, calling an OpenGL resource application statement to apply for generating a new graphic resource from the GPU, and adding the graphic resource to the tail of the allocated data uncommitted resource queue.
And (4) in the process of uniformly submitting data by the graphic resource manager in the step (3), the graphic resource manager traverses the allocated data uncommitted resource queue, submits data to each graphic resource, releases memory operation, and then moves the graphic resource to the tail of the allocated data submitted queue.
In the step (4), the graphics resource manager traverses the allocated data submitted queue in the resource recovery stage, recovers the graphics resource if the applicant releases the occupation of the graphics resource, and moves the graphics resource to the tail of the recovered free resource queue.
The invention solves the problems of random use of graphics rendering resources, high occupation rate of GPU video memory and low rendering efficiency when a rendering engine renders a large scene; the application and allocation of the graphics rendering resources are effectively controlled and managed, and the graphics rendering resources are used neatly and orderly.
Drawings
FIG. 1 is a flow diagram of a method for managing graphics rendering resources consistent with an embodiment of the present invention;
FIG. 2 is a flow chart of a method for managing texture resources manager consistent with an embodiment of the present invention;
FIG. 3 is a flow chart of a method for managing resource managers for display lists consistent with an embodiment of the present invention
FIG. 4 is a flow chart of a method for managing a texture buffer (RenderBuffer) resource manager consistent with an embodiment of the present invention;
FIG. 5 is a flow chart of a method for managing a frame buffer object (FrameBufferObject) resource manager consistent with an embodiment of the present invention;
FIG. 6 is a flow chart of a method for managing a vertex buffer object (VertexBufferObject) explorer consistent with an embodiment of the present invention;
FIG. 7 is a flowchart of a method for managing a Program resource manager consistent with an embodiment of the present invention;
FIG. 8 is a flow diagram of a method for managing a shader resource (ShaderResource) manager consistent with embodiments of the invention;
FIG. 9 is a block diagram of a graphics rendering resource management system consistent with an embodiment of the present invention.
DETAILED DESCRIPTION OF EMBODIMENT (S) OF INVENTION
The invention discloses a method for effectively managing OpenGL graphics rendering resources, which comprises the following steps: (1) when a Scene (Scene) is initialized, initializing various graphic resource managers of each graphic environment (graphic context); (2) in the scene updating or rendering process, a graph resource manager (renderResourcemanager) is obtained by obtaining a graph environment to distribute graph resources (renderResource); (3) after the scene is updated, rendering data are uniformly submitted to a GPU before rendering, and a CPU memory occupied by the rendering data is released; (4) recycling the rendering resources which are idle; (5) before the rendering scene is finished, the graphics resource managers in the graphics environments release the rendering resources managed by the graphics environments, and the graphics environments destroy the rendering resource managers owned by the graphics environments.
Each type of graphics resource manager manages three resource queues respectively: an allocated data uncommitted resource queue (allocatederqueue), an allocated data committed queue (ActiveResourceQueue), and a reclaimed free resource queue (orphanederqueue), each rendering resource having a rendering resource ID. When applying for the graphics rendering resource, the graphics resource manager firstly fetches the graphics resource from the idle resource queue, if the idle resource queue is not empty, the head of the fetch queue fetches a resource to be allocated to the applicant; and if the idle resource queue is empty, calling an OpenGL resource application statement to apply for generating a new graphic resource from the GPU, and adding the graphic resource to the tail of the allocated data uncommitted resource queue. In the process of uniformly submitting data by the graphic resource manager, the graphic resource manager traverses the allocated data uncommitted resource queue, submits data to each graphic resource, releases memory operation, and then moves the graphic resource to the tail of the allocated data submitted queue. In the resource recycling stage, the graphics resource manager traverses the allocated data submitted queue, recycles the graphics resource if the applicant has released the occupation of the graphics resource, and moves the graphics resource to the tail of the recycled free resource queue.
The texture resource manager (TextureResourceManager) manages the use of texture resources (TextureResource) as follows:
the graphics environments generate respective texture resource managers TextureResourceMeanager when the scene is initialized, set the use upper limit of texture resources, prevent the GPU video memory from occupying too high, and initialize three queues managed by the texture resource managers: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The texture resource applicant obtains the TextureResourceManager of the graphics environment where the texture resource applicant is located. The TextureResourceEmanager fetches a TextureResource from the OrphanedResourceQueue header managed by the TextureResourceEmanager, regenerates a TextureResource if the OrphanedResourceQueue is empty, and applies a texture unit to the GPU for assignment to the TextureResource. The TextureResource sets its texture type and texture reference according to the incoming texture pointer, assigns itself to the texture resource reference of the texture, and adds the TextureResource to the tail of the AllocatedResourceQueue.
Executing an UploadResource function of the TextureResourceAnager, traversing the AllocatedResourceQueue, acquiring a texture pointer bound by the TextureResource, executing a data uploading function of the texture, deleting image data of the texture, releasing a memory, and adding the TextureResource to the tail of the ActiveResourceQueue.
And in the texture resource recycling stage, executing a ReleaseResource function of the TextureResourceManager, traversing the ActiveResourceQueue, acquiring a texture pointer bound by the TextureResource, setting the TextureResource reference bound by the texture to NULL if the reference count of the texture is 1, releasing the binding of the TextureResource and the texture, and adding the TextureResource to the tail of the OrphanedResourceQueue.
Before the rendering scene is finished, the TextureResourceMeanagers in the graphic environments release all the TextureResources managed by the graphic environments, and the graphic environments destroy the TextureResourceMeanagers owned by the graphic environments.
The display list resource manager (ListResourceManager) manages the use of the display list resource (ListResource) as follows:
each graphic environment generates a respective display list resource manager ListResourceMenager when a scene is initialized, sets the use upper limit of display list resources, prevents the GPU video memory from occupying too high, and initializes three queues managed by the display list resource managers: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The display list resource applicant obtains the ListResourceMenager of the graphic environment where the applicant is located. ListResourcemanager takes out a ListResource from the head of the OrphanedResourceQueue managed by the ListResourcemanager, and if the OrphanedResourceQueue is empty, a ListResource is regenerated and applies for a display list unit to be assigned to the ListResource from the GPU. ListResource sets its own geometry reference according to the incoming geometry pointer, assigns itself to the geometry's display list resource reference, and adds this ListResource to the AllocatedResourceQueue tail.
Executing the UplodResource function of ListResourcemanager, traversing AllocatedResourceQueue, acquiring a geometry pointer bound by ListResource, executing the data compiling function of geometry, and adding ListResource to the tail of the ActiveResourceQueue.
And in the display list resource recycling stage, due to the property that the display list units can not be reused, all display list units applied in ActiveResourceQueue are released in the stage, and the queue is emptied.
Before the rendering scene is finished, the ListResourceMeagers in the graphic environments release all the ListResources managed by the graphic environments, and the graphic environments destroy the ListResourceMeagers owned by the graphic environments.
The renderbufferuourcemanager (renderbufferumanager) manages the use of renderbufferuource (renderbufferusource) by the following operations:
each graphic environment generates a respective render buffer resource manager when a scene is initialized, sets an upper limit of the render buffer resource, prevents the GPU video memory from occupying too high, and initializes three queues managed by the render buffer resource manager: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The renderBuffer resource manager acquires the renderBufferResourcemanager of the graphic environment where the renderBuffer resource manager is located. The RenderBufferResourcemanager takes out a RenderBufferResource from the head of the OrphanedResourceQueue managed by the RenderBufferResourcemanager, and if the OrphanedResourceQueue is empty, a RenderBufferResource is regenerated and applies a RenderBufferUnit to the RenderBufferResource for the GPU. RenderBufferResource sets its own RenderTarget reference according to the incoming render target (RenderTarget) pointer and assigns itself to the RenderBuffer resource reference of RenderTarget, adding this RenderBufferResource to the AllocatedResourceQueue tail.
And in the RenderBuffer resource recycling stage, executing a ReleaseResource function of a RenderBufferResourcemanager, traversing ActiveResourceQueue, acquiring a RenderTarget pointer bound by the RenderBufferResource, setting the bound RenderBufferResource reference as NULL if the reference count of the RenderTarget is 1, releasing the binding between the RenderBufferResource and the RenderTarget, and adding the RenderBufferResource to the tail of the OrphanedResourceQueue.
Before the rendering scene is finished, all managed renderBufferResourceMeagers in the graphic environments are released, and the graphic environments destroy the renderBufferResourceMeagers owned by the graphic environments.
The framebufferoobject resource manager (framebufferoresourcemanager) manages the use of framebufferoobject resources (framebufferoresource) by:
each graphic environment generates a respective FrameBufferObject resource manager framebufferoresourcemanager when a scene is initialized, sets an upper limit of the usage of FrameBufferObject resources, prevents the video memory occupancy of the GPU from being too high, and initializes three queues managed by the FrameBufferObject resource manager: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The framebufferoobject resource manager obtains the framebufferoresourcemanager of the graphics environment where it is located. The FrameBufferResourcemanager takes out a FrameBufferResource from the OrphanedResourceQueue header managed by the FrameBufferResourcemanager, and if the OrphanedResourceQueue is empty, a FrameBufferResource is regenerated and applies a FrameBufferObject unit to the GPU to be assigned to the FrameBufferResource. The framebufferrResource sets its RenderTarget reference according to the incoming render target (RenderTarget) pointer and assigns itself to the renderObject resource reference of the RenderTarget, which is added to the allocatedResourceQueue tail.
In the resource recycling phase of the framebufferrObject, a ReleaseResource function of the framebufferrResourcemanager is executed, ActiveResourceQueue is traversed, a RenderTarget pointer bound by the framebufferrResource is obtained, if the reference count of the RenderTarget is 1, the FrameBufferResource reference bound by the RenderTarget is set to NULL, the binding between the FrameBufferResource and the RenderTarget is released, and the FrameBufferResource is added to the tail of the OrphanedResourceQueue.
Before the rendering of the scene is finished, all the FrameBufferResourceMeagers managed by the FrameBufferResourceMessargers in the graphic environments are released, and the FrameBufferResourceMeagerAgents owned by the graphic environments are destroyed.
The VertexBufferObject resource manager (BufferResourcemanager) manages the use of VertexBufferObject resources (BufferResource) as follows:
each graphic environment generates a respective VertexBufferObject resource manager BufferResourceMeanager when a scene is initialized, sets an upper limit of the VertexBufferObject resource, prevents the GPU video memory from occupying too high, and initializes three queues managed by the VertexBufferObject resource manager: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The VertexBufferObject resource manager acquires the BufferResourcemanager of the graphic environment where the VertexBufferObject resource manager is located. The BufferResourcemanager takes out one BufferResource from the head of the OrphanedResourceQueue managed by the BufferResourcemanager, and if the OrphanedResourceQueue is empty, the BufferResource is regenerated and applies a VertexBufferObject unit to the GPU. The bufferrResource sets its VertexAttribute reference according to the incoming vertex attribute (VertexAttribute) pointer, assigns itself to the VertexBufferObject resource reference of VertexAttribute, and adds this bufferrResource to the AllocatedResourceQueue tail.
And in the resource recycling stage of the VertexBufferObject, executing a ReleaseResource function of the BufferResourcemanager, traversing the ActiveResourceQueue, acquiring a VertexAttribute pointer bound by the BufferResource, setting the bound BufferResource reference to NULL if the reference count of the VertexAttribute is 1, releasing the binding of the BufferResource and VertexAttribute, and adding the BufferResource to the tail of the OrphanedResourceQueue.
Before the rendering of the scene is finished, the bufferResourceMeagers in the graphic environments release all the bufferResources managed by the graphic environments, and the graphic environments destroy the bufferResourceMeagers owned by the graphic environments.
A Program resource manager (Program resource manager) manages the use of a Program resource (Program resource) by:
each graphic environment generates a respective Program resource manager (Program resource manager) when a scene is initialized, sets an upper limit of the use of Program resources, prevents the GPU video memory from occupying too high, and initializes three queues managed by the Program resource managers: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The Program resource manager acquires the Program resource manager of the graphic environment where the Program resource manager is located. The ProgramResourceManager takes out a ProgramResource from the head of the OrphanedResourceQueue managed by the programResourcemanager, and if the OrphanedResourceQueue is empty, a ProgramResource is regenerated and applies for a Program unit to be assigned to the ProgramResource from the GPU. The Program resource sets its own Program reference according to the incoming Program pointer, assigns itself to the Program resource reference of the Program, and adds the Program resource to the tail of the allocated resource queue.
And in the Program resource recycling stage, executing a ReleaseResource function of a ProgramResourceMeanager, traversing ActiveResourceQueue, acquiring a Program pointer bound by the ProgramResource, setting the bound ProgramResource reference to NULL if the reference count of the Program is 1, releasing the binding between the ProgramResource and the Program, and adding the ProgramResource to the tail of the OrphanedResourceQueue.
Before the rendering scene is finished, the programresourcemanagers in the graphic environments release all the programresources managed by the graphic environments, and the graphic environments destroy the programresourcemanagers owned by the graphic environments.
The shader resource manager (shader resource manager) manages the use of shader resources (shader resource) by the following operations:
each graphics environment generates a respective shader resource manager ShaderResourceMeanager when a scene is initialized, sets the use upper limit of shader resources, prevents the GPU video memory from occupying too high, and initializes three queues managed by the shader resource managers: allocatedreurceQueue, ActiveResourceQueue, and OrphanedResourceQueue.
The shader resource manager obtains the ShaderResourceMeanager of the graphics environment in which it is located. ShaderResourcemanager fetches a ShaderResource from the OrphanedResourceQueue header it manages, and if OrphanedResourceQueue is empty, regenerates a ShaderResource and applies for a shader unit assignment to ShaderResource to the GPU. ShaderResource sets its shader references according to the incoming shader pointers and assigns itself to the shader resource references of the shaders, adding this ShaderResource to the AllocatedResourceQueue tail.
The seven types of graphics resource managers correspond to seven rendering resources of the GPU required for managing graphics rendering, and include: the texture rendering unit, the display list unit, the texture buffer unit, the frame buffer unit, the vertex buffer unit, the program unit and the shader unit are collectively called graphics rendering resources.
And in the shader resource recycling stage, executing a ReleaseResource function of the ShaderResourceAnager, traversing the ActiveResourceQueue, acquiring a shader pointer bound by the ShaderResource, setting the ShaderResource reference bound by the shader to NULL if the reference count of the shader is 1, unbinding the ShaderResource and the shader, and adding the ShaderResource to the tail of the OrphanedResourceQueue.
Before the rendering scene is finished, all the ShaderResourceMeanagers managed by the ShaderResourceMenagers in the graphic environments are released, and the ShaderResourceMenagers owned by the graphic environments are destroyed.
In the description herein, references to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., mean that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the invention. In this specification, the schematic representations of the terms used above do not necessarily refer to the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples.
While embodiments of the invention have been shown and described, it will be understood by those of ordinary skill in the art that: various changes, modifications, substitutions and alterations can be made to the embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the claims and their equivalents.
Claims (5)
1. A method for managing graphics rendering resources, comprising the steps of:
(1) initializing a scene, and initializing each graphics resource manager, wherein the graphics resource managers include: a texture resource manager, a display list resource manager, a texture buffer render buffer resource manager, a frame buffer object resource manager, a vertex buffer object resource manager, a Program resource manager and a shader resource manager;
(2) applying for and distributing the graphic resources;
(3) uniformly submitting the rendering data to a Graphics Processing Unit (GPU) and releasing a Central Processing Unit (CPU) memory;
(4) recovering GPU idle rendering resources;
(5) and after the rendering is finished, releasing all applied GPU rendering resources.
2. A method of managing graphics rendering resources as recited in claim 1, wherein: in the step (1), each image resource manager manages three image resource queues, wherein each image resource queue comprises an allocated data uncommitted resource queue, an allocated data committed queue and a recycled idle resource queue, and each rendering resource has a rendering resource ID.
3. A method of managing graphics rendering resources as recited in claim 1, wherein: when the graphics resource manager applies for graphics rendering resources in step (2), firstly obtaining graphics resources from an idle resource queue, and if the idle resource queue is not empty, taking out a graphics rendering resource from the head of the queue and allocating the graphics rendering resource to the graphics resource manager; and if the free resource queue is empty, applying for generating a new graphic resource from the GPU, and adding the graphic resource to the tail of the allocated data uncommitted resource queue.
4. A method of managing graphics rendering resources as recited in claim 1, wherein said step (3) comprises: in the process of uniformly submitting data to the GPU, the graphic resource manager traverses the allocated data uncommitted resource queue, submits data to each graphic resource, releases CPU memory operation, and then moves the graphic resource to the tail of the allocated data submitted queue.
5. A method of managing graphics rendering resources as recited in claim 1, wherein: in the step (4), the graphics resource manager traverses the allocated data submitted queue in the resource recovery stage, and if the graphics resource manager releases the occupation of the graphics resource, the graphics rendering resource is recovered, and the graphics rendering resource is moved to the tail of the recovered idle resource queue.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710846042.0A CN107885597B (en) | 2017-09-19 | 2017-09-19 | Method for managing graphics rendering resources |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710846042.0A CN107885597B (en) | 2017-09-19 | 2017-09-19 | Method for managing graphics rendering resources |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107885597A CN107885597A (en) | 2018-04-06 |
| CN107885597B true CN107885597B (en) | 2020-12-15 |
Family
ID=61780704
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710846042.0A Active CN107885597B (en) | 2017-09-19 | 2017-09-19 | Method for managing graphics rendering resources |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107885597B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110888637B (en) * | 2018-08-16 | 2023-09-26 | 龙芯中科技术股份有限公司 | Vertex attribute processing method, vertex attribute processing device, vertex attribute processing equipment and computer readable storage medium |
| CN109976741B (en) * | 2019-03-21 | 2022-06-14 | 深圳市腾讯信息技术有限公司 | Computer resource management method and device, intelligent terminal and storage medium |
| CN110058913B (en) * | 2019-03-25 | 2022-05-20 | 中国航空无线电电子研究所 | Display list management method |
| CN116149866B (en) * | 2023-04-14 | 2023-08-04 | 深圳市明源云科技有限公司 | Working space adaptive rendering method, device, equipment and readable storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102880464A (en) * | 2012-08-31 | 2013-01-16 | 中山市世宇动漫科技有限公司 | Three-dimensional game engine system |
| CN104102488A (en) * | 2014-07-18 | 2014-10-15 | 无锡梵天信息技术股份有限公司 | Multithread parallelization based 3D (three dimensional) engine system |
| CN105183566A (en) * | 2015-10-16 | 2015-12-23 | 上海恺英网络科技有限公司 | Resource management method for 3D game rendering engine |
| CN105413176A (en) * | 2015-11-10 | 2016-03-23 | 内蒙古工业大学 | 3D engine system applied to games |
-
2017
- 2017-09-19 CN CN201710846042.0A patent/CN107885597B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102880464A (en) * | 2012-08-31 | 2013-01-16 | 中山市世宇动漫科技有限公司 | Three-dimensional game engine system |
| CN104102488A (en) * | 2014-07-18 | 2014-10-15 | 无锡梵天信息技术股份有限公司 | Multithread parallelization based 3D (three dimensional) engine system |
| CN105183566A (en) * | 2015-10-16 | 2015-12-23 | 上海恺英网络科技有限公司 | Resource management method for 3D game rendering engine |
| CN105413176A (en) * | 2015-11-10 | 2016-03-23 | 内蒙古工业大学 | 3D engine system applied to games |
Non-Patent Citations (1)
| Title |
|---|
| 3D游戏引擎的设计与实现;阮复初;《西南交通大学硕士学位论文》;20101115;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107885597A (en) | 2018-04-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107885597B (en) | Method for managing graphics rendering resources | |
| JP5202319B2 (en) | Scalable multithreaded media processing architecture | |
| US9286119B2 (en) | System, method, and computer program product for management of dependency between tasks | |
| DE102013017640B4 (en) | Distributed tiled caching | |
| DE102013208554B4 (en) | Method and system for managing nested execution streams | |
| DE102013200991A1 (en) | Automatic dependent-task-launching | |
| TWI488118B (en) | Signaling, ordering, and execution of dynamically generated tasks in a processing system | |
| Steinberger et al. | Whippletree: Task-based scheduling of dynamic workloads on the GPU | |
| CN115100022B (en) | Graphic processing method and system | |
| DE102012220267A1 (en) | Computational work distribution reference counter | |
| DE112010003750T5 (en) | Hardware for parallel command list generation | |
| DE102013224160A1 (en) | System, method, and computer program product for optimizing thread stack memory management | |
| CN107292807A (en) | A kind of figure synthetic method, window method to set up and system | |
| DE102013208421A1 (en) | Sharing a graphics processing unit among many applications | |
| Ize et al. | Real-Time Ray Tracer for Visualizing Massive Models on a Cluster. | |
| DE102017109472A1 (en) | STEREO MULTIPLE PROJECTION IMPLEMENTED BY USING A GRAPHIC PROCESSING PIPELINE | |
| CN111316239B (en) | Wave creation control with dynamic resource allocation | |
| WO2016160035A1 (en) | Persistent memory versioning and merging | |
| TW201439762A (en) | Technique for performing memory access operations via texture hardware | |
| KR102114245B1 (en) | Graphics state manage apparatus and method | |
| JP6974510B2 (en) | Methods, devices, devices and media for processing data | |
| US20190163527A1 (en) | Precise suspend and resume of workloads in a processing unit | |
| US11734869B2 (en) | Graphics processing | |
| CN110084738B (en) | Techniques for representing and processing geometry in an extended graphics processing pipeline | |
| JP2022534438A (en) | graphics context bouncing |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |