KR20090077432A - Method of processing opengl programmable shader by using off-line compiling - Google Patents

Abstract

A processing method of an OpenGL programmable shader by using the off-line compile is provided to perform the compile operation in the off-line state to save resources required for the compile. At least one shader source code is inputted and compiled(S210). A pre-compiled code is generated. The memory space of a shader object is generated(S220). The ID of the shader object is generated. The pre-compiled code is copied to the shader object(S230). The memory space of a program object is generated(S240). The ID of the program object is generated. The ID of the shader object is stored in the program object. The program object and shader object are connected(S250). The pre-compiled codes stored in the shader object are linked(S260).

Description

Process of OpenJule Programmable Shader Using Offline Compilation {METHOD OF PROCESSING OPENGL PROGRAMMABLE SHADER BY USING OFF-LINE COMPILING}

The present invention relates to a processing method of the OpenJU programmable shader, and more particularly, OpenJU to perform the compilation operation offline to save the resources required for compilation in embedded systems and mobile systems having a relatively small processing power How to handle programmable shaders.

Widely used as a 3D Graphic Library, OpenGL is a software interface for controlling graphics hardware and is a highly portable and fast execution 3D graphics and modeling library. This makes it relatively easy to create stunning 3D graphics with visual quality of ray tracer level. OpenGL has evolved to be more and more performance-optimized as it is used and improved by many vendors and developers based on algorithms developed and optimized by Silicon Graphics Incoporated (SGI) over the years. . Based on these developments, OpenGL has maintained a superior position as a 3D graphics API, and most of the recently developed 3D accelerated graphics hardware tend to support OpenGL drivers.

In particular, OpenGL has evolved to be optimized for hardware limitations of embedded systems and mobile systems, namely, low capacity and low computing power, while being mainly applied to high performance systems. This includes the OpenGL ES (Embedded System), which was developed to support standard 3D graphics programming. OpenGL ES, based on some of the features of OpenGL version 1.3, is an OpenGL API standard suitable for defined embedded systems with some additional extensions.

On the other hand, a programmable shader that allows for customizable pipe-line construction of existing fixed OpenGL rendering pipelines, contributing to the high programming efficiency and programming freedom that OpenGL has now achieved. (programmable shader). The shader uses vertex attribute input, transformation, lighting, texture coordinate generation and transformation, clipping, rasterize, fragment attribute input, texturing, color Allows customization of a series of actions such as sum, fog, anti-aliasing, and fragment target operations.

Figure 1 is a flow chart illustrating a programmable shader processing process of the OpenJulel according to the prior art.

The shader processing of OpenGL illustrated in FIG. 1 is a flowchart illustrated based on an API of OpenGL ES.

Referring to FIG. 1, a conventional shader processing process includes a shader object generation step S110, a shader source copying step S120, a shader source compilation step S130, a program object generation step S140, a program object and a shader object object. It comprises a attach step (S150) and a program link step (S160).

The shader object generation step S110 is a step of generating a memory space of the shader object and generating an ID of the shader object. For example, the shader object may be configured to be implemented by the glCreateShader API in the OpenGL ES API. . Here, the shader object refers to a vertex or fragment shader module, and is an object for storing shader source and compilation result.

Copying the shader source (S120) is a step of copying the shader source to the shader program source portion of the shader object generated through the shader object generation step (S110). For example, the OpenGL ES API is performed by the glShaderSource API. It can be configured to be implemented.

In the shader source compilation step (S130), the shader source copied to the program source portion of the shader object in the shader source copy step (S120) is generated to generate compiled code, and the generated compiled code is shaded. As a step of copying to an object, for example, the OpenGL ES API may be configured to be implemented by the glCompileShader API.

The program object generation step S140 is a step of generating a memory space of a program object and generating an ID of the program object. For example, the program object may be configured to be implemented by the glCreateProgram API in the OpenGL ES API. Here, the program object represents a single execution unit composed of vertices and fragment shaders, and is an object for connecting shader objects constituting the shader program and storing the generated object code.

The program object and the shader object attaching step (S150) is a step of attaching the generated shader object and the generated program object, and storing the ID of the shader object in the program object, thereby connecting the program object and the shader object. Perform the action. For example, the OpenGL ES API may be configured to be implemented by the glAttachShader API.

Finally, in the program linking step (S160), the executable code is generated to be executable in the graphic processing unit (GPU) of the graphics hardware by linking the compiled codes stored in the shader object, for example, OpenGL. ES API may be configured to be implemented by the glLinkProgram API.

On the other hand, this process has the advantage that it is easy to modify the shader source code to enable direct development and immediate test execution, but it requires a lot of processing time at runtime every time even after the development and testing is completed. There is a drawback to extending.

Also, since one vertex shader and one fragment shader are required to process data, the source must be read and compiled more than once during runtime. Thus, for embedded systems or mobile systems that lack computing power and memory, these runtime compilation tasks can be a significant load.

An object of the present invention for solving the above problems is to improve the runtime compilation of the programmable shader that acts as a load of work in the run-time operation of the programmable shader of OpenJule, embedded with insufficient computing power and memory The purpose of the present invention is to provide a method for processing OpenJell programmable shaders that can be applied to a system or a mobile system.

In order to achieve the above object, the present invention provides a precompile step of generating a precompiled code by receiving and compiling at least one shader source code, generating a shader object memory space, and generating a shader object ID. A copying of the shader binary to copy the precompiled code to the shader object, generating a memory space of a program object, generating a program object ID, and storing the shader object ID to the program object. Thereby generating a machine code by linking the program object and the shader object attaching step of connecting the program object and the shader object and the precompiled codes stored in the shader object. Provides a method of handling OpenJUSL programmable shaders using offline compilation, including program linking.

Here, the shader source code may be source code of a vertex shader.

Here, the shader source code may be source code of a fragment shader.

Here, the pre-compilation step, characterized in that the shader source code is received in the offline state to compile.

Here, the processing method of the OpenJUSL programmable shader using the offline compilation may be performed on the OpenGLES API. In this case, the shader binary copying step may be performed using the OpenGLLS glShaderBinary API or the corresponding API. By copying the precompile code into the shader object.

By using the OpenJEL programmable shader processing method using offline compilation according to the present invention as described above, the load of runtime operation is reduced in a small system that lacks computing power and memory such as an embedded system or a mobile system, thereby improving processing power. It becomes possible.

Therefore, by using the OpenJUSL programmable shader processing method using offline compilation according to the present invention, it is possible to significantly reduce the work time required to compile the source code of the programmable shader even in an embedded system having limited graphics acceleration. This can result in improved graphics processing.

As the invention allows for various changes and numerous embodiments, particular embodiments will be illustrated in the drawings and described in detail in the written description. However, this is not intended to limit the present invention to specific embodiments, it should be understood to include all modifications, equivalents, and substitutes included in the spirit and scope of the present invention. In describing the drawings, similar reference numerals are used for similar elements.

Terms such as first, second, A, and B may be used to describe various components, but the components should not be limited by the terms. The terms are used only for the purpose of distinguishing one component from another. For example, without departing from the scope of the present invention, the first component may be referred to as the second component, and similarly, the second component may also be referred to as the first component. The term and / or includes a combination of a plurality of related items or any item of a plurality of related items.

When a component is referred to as being "connected" or "connected" to another component, it may be directly connected to or connected to that other component, but it may be understood that other components may be present in between. Should be. On the other hand, when a component is said to be "directly connected" or "directly connected" to another component, it should be understood that there is no other component in between.

The terminology used herein is for the purpose of describing particular example embodiments only and is not intended to be limiting of the invention. Singular expressions include plural expressions unless the context clearly indicates otherwise. In this application, the terms "comprise" or "have" are intended to indicate that there is a feature, number, step, operation, component, part, or combination thereof described in the specification, and one or more other features. It is to be understood that the present invention does not exclude the possibility of the presence or the addition of numbers, steps, operations, components, components, or a combination thereof.

Unless defined otherwise, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art. Terms such as those defined in the commonly used dictionaries should be construed as having meanings consistent with the meanings in the context of the related art, and are not construed in ideal or excessively formal meanings unless expressly defined in this application. Do not.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

2 is a flow chart illustrating a processing method of an OpenJUSL programmable shader using offline compilation according to the present invention.

Referring to FIG. 2, a shader processing process of OpenGL when the online compilation method according to the present invention is applied may include a precompile step (S210), a shader object generation step (S220), a shader binary copy step (S230), and a program object. It may be configured to include a generation step (S240), a program object and shader object attach step (S250) and a program link step (S260).

Here, the pre-compilation step S210 refers to an operation that is performed in advance before the runtime operation separately from the shader object generation step S220 to the program linking step S260 performed at run-time. Therefore, in the development and debugging phase of the program, the conventional shader processing process of the prior art illustrated in FIG. 1 is used, and the final execution of the developed and debugged program is performed by the OpenJuel programmable shader using offline compilation according to the present invention. It would be desirable to use this.

The precompile step S210 is a step of receiving and compiling at least one shader source code to generate a precompile code, which will be described in detail with reference to the conceptual diagram of FIG. 3.

3 is a conceptual diagram illustrating a pre-compile step applied to the OpenJell programmable shader processing method according to the present invention.

The precompile step illustrated in FIG. 3, that is, the off-line compilation step, is an offline compilation method applied to the OpenJUSL programmable shader processing method according to the present invention, and is an OpenGL that operates in a conventional run-time compilation method. The execution time of the programmable shader is reduced by performing the offline compilation operation of the programmable shader.

Referring to FIG. 3, in the precompilation step (S210) according to the present invention, a source code 101 of a vertex shader and a source code 102 of a fragment shader are input and compiled. And generate pre-compiled pre-compiled code 200.

At this time, the source code 101 of the vertex shader is a program developed by the user and the vertex shader source code for processing three-dimensional data in graphics hardware. In detail, the vertex shader receives information of vertices located in three dimensions and outputs vertex positions, colors, and additional information. The user passes vertex data and vertex processing code to the graphics hardware through the API.

In addition, the source code 102 of the fragment shader similarly determines the color of the fragment with information such as color and texture coordinates transmitted to the fragment by a program developed by the user.

Therefore, in the pre-compile step (S210), the two shader source codes 101 and 102 received are compiled offline to generate the pre-compiled file 200. The generated pre-compiled file is a binary file, and as described with reference to FIG. 1 in the prior art, it means a code equivalent to the compiled code generated in the shader source compilation step S130. The pre-compiled file generated in the precompile step S210 is copied by the shader binary copy step S230 to be described later to the generated shader object.

Referring back to FIG. 2, the shader object generation step S220 is a step of generating a memory space of the shader object and generating an ID of the shader object. For example, the shader object may be configured to be implemented by the glCreateShader API in the OpenGL ES API. . Here, the shader object refers to a vertex or fragment shader module, and is an object for storing shader source and compilation result.

The shader binary copying step S230 is a step of copying a precompiled code binary file generated in advance by the precompiler step S210 of the shader source code described above with reference to FIG. 3 to a shader object. Here, the shader binary copy step S230 may be configured to be implemented by the glShaderBinary API or an equivalent API as the OpenGL ES API.

In the prior art shader processing described with reference to FIG. 1, the shader source is copied to the shader program source portion of the shader object in the shader source copy step (S120) and the shader source compilation step (S130), and copied to the program source portion. Compile the shader source to generate compiled code, and copy the generated compiled code to the constant data portion of the shader object at runtime.

However, when the shader processing method according to the present invention is applied, a step of directly copying the precompiled code 200 of the shader, which has been precompiled before the runtime execution in the precompile step (S210), is directly copied to the shader object. As a result, it is possible to drastically reduce the work time at runtime, which should be consumed during the shader source copying step S120 and the shader source compiling step S130.

The program object generation step S240 is a step of generating a memory space of a program object and generating an ID of a program object. For example, the OpenGL ES API may be configured to be implemented by the glCreateProgram API. Here, the program object represents a single execution unit composed of vertices and fragment shaders, and is an object for connecting shader objects constituting the shader program and storing the generated object code.

The program object and the shader object attaching step (S250) is a step of attaching the generated shader object and the generated program object, and storing the ID of the shader object in the program object, thereby connecting the program object and the shader object. Perform the action. For example, the OpenGL ES API may be configured to be implemented by the glAttachShader API.

Finally, in the program linking step S260, the executable code is generated to be executable in the graphic processing unit (GPU) of the graphics hardware by linking the compiled codes stored in the shader object, for example, OpenGL. ES API may be configured to be implemented by the glLinkProgram API.

Additional security measures as described above may be applied selectively or in combination, while the above has been described with reference to a preferred embodiment of the present invention, those skilled in the art will be described in the following claims It will be understood that various modifications and changes can be made in the present invention without departing from the spirit and scope of the invention.

1 is a flow chart illustrating an OpenJell programmable shader process according to the prior art.

2 is a flow chart illustrating a processing method of an OpenJUSL programmable shader using offline compilation according to the present invention.

3 is a conceptual diagram illustrating a pre-compile step applied to the OpenJell programmable shader processing method according to the present invention.

Claims (6)

A precompile step of receiving and compiling at least one shader source code to generate precompile code; A shader object generation step of generating a memory space of the shader object and generating an ID of the shader object; A shader binary copy step of copying the precompiled code to the shader object; Generating a memory space of the program object and generating an ID of the program object; A program object and a shader object attaching step of connecting the program object and the shader object by storing the ID of the shader object in the program object; And a program linking step of linking the precompiled codes stored in the shader object to generate machine code. The method of claim 1, The shader source code is a processing method of the OpenJule programmable shader using offline compilation, characterized in that the source code of the vertex shader. The method of claim 1, The shader source code is a method of processing open shader programmable shaders using offline compilation, characterized in that the source code of the fragment shader. The method of claim 1, In the precompilation step, the OpenJUEL programmable shader processing method using offline compilation may include compiling the shader source code in an offline state. The method of claim 1, The processing method of the OpenJU programmable shader using the offline compilation is performed on the OpenGL ES API. The method of claim 5, wherein The shader binary copying step may include copying the precompiled code into the shader object by using the glShaderBinary API of OpenJUSL ES.

Images