KR20190001209A - Toys for infant learning using 3D printer and learning method using it - Google Patents

Abstract

Disclosed are a device and a method for three-dimensional (3D) graphic processing which can simultaneously support a fixed pipeline and a programmable pipeline. A graphic processor includes: a fixed pipeline code generation unit for converting an application programming interface (API) supplying the fixed pipeline into a first micro code; a shader pipeline code generation unit for converting an API supporting the programmable pipeline into a second micro code; and a shader pipeline for processing the first micro code or the second micro code using a shader program.

Description

[Toys for infant learning using a 3D printer and learning method using the same]

The present invention relates to 3D (3-dimensional) <1> graphics processing.

Various 3D graphics applications are being implemented in mobile environments such as mobile phones, personal digital assistants (PDAs), and portable game consoles. To handle 3D applications, a 3D graphics API (Application Programming Interface) is provided for mobile environments. Some 3D graphics APIs support a fixed pipeline, while other 3D graphics APIs support a programmable pipeline.

A 3D graphics processing apparatus and method for simultaneously supporting a fixed pipeline and a programmable pipeline are provided.

In an aspect, a graphics processor for 3D graphics processing is provided. The graphics processor includes a fixed pipeline code generation unit for converting an application programming interface (API) supporting a fixed pipeline into a first microcode, a shader pipeline for converting an API supporting a programmable pipeline to a second microcode, And a shader pipeline processing unit coupled to the fixed pipeline code generation unit and the shader pipeline code generation unit to process at least one of the first microcode and the second microcode using a shader program, . The graphics processor may further include an API selection unit connected to the fixed pipeline code generation unit and the shader pipeline code generation unit and receiving an input API to determine whether a fixed pipeline or a programmable pipeline is supported . The shader pipeline may include a vertex shader and a fragment shader. Wherein the fixed pipeline code generation unit comprises: a state unit parsing an attribute of an object of the received input API and outputting state information according to a parsed attribute; a state code generation unit generating the first microcode based on the output state information; A code generator for storing the first microcode, and a code buffer for storing the first microcode.

Wherein the graphics processor is connected to the fixed pipeline code generation unit and the shader pipeline code generation unit to generate the first microcode and the second microcode to distinguish generation of a hazard representing a stall, And a process according to the occurrence of the hazard

And may further include a hazard controller to perform the operation. The hazard controller may include a hazard identification unit for confirming the processing order and the execution time of each microcode and confirming whether the hazard is generated, and the controller may include a rearrangement unit for rearranging the processing order of the microcode generated by the hazard have. The hazard controller may further include a forwarding unit for forwarding the result of the previous microcode of the microcode generated by the hazard for execution of another microcode.

The API supporting the fixed pipeline is OpenGL ES 1.x, and the API supporting the programmable pipeline may be OpenGL ES 2.x.

In another aspect, a 3D graphics processing method performed by a graphics processor is provided. The method includes converting an application programming interface (API) supporting a fixed pipeline to a first microcode that can be recognized by a shader that supports a programmable pipeline, and processing the first microcode to perform 3D graphics processing . The processed 3D graphics can be stored in a memory such as a buffer. In addition, the processed 3D graphics may be displayed on a display in a mobile environment. The method may further include converting from an API supporting a programmable pipeline to a second microcode recognizable by the shader. The step of performing the first microcode conversion of the API supporting the fixed pipeline and the step of performing the second microcode conversion of the API supporting the programmable pipeline may include obtaining status information according to an attribute of an object of the input API And generating the first and second microcode based on the status information. Wherein the step of performing the first microcode conversion of the API supporting the fixed pipeline and the step of performing the second microcode conversion of the API supporting the programmable pipeline include the steps of: stalled < / RTI > Wherein the step of performing the first microcode conversion of the API supporting the fixed pipeline and the step of performing the second microcode conversion of the API supporting the programmable pipeline include the steps of: And rearranging the data. Wherein the step of performing the first microcode conversion of the API supporting the fixed pipeline and the step of performing the second microcode conversion of the API supporting the programmable pipeline include the steps of transferring the microcode generated by the hazard when the hazard occurs, And forwarding the result of the microcode to another microcode. In yet another aspect, a computer device includes a central processing unit (CPU); And a graphics processor connected to the CPU for processing 3D graphics. The graphics processor includes a fixed pipeline code generator for converting an API supporting a fixed pipeline into a first microcode, a shader pipeline code generator for converting an API supporting a programmable pipeline into a second microcode, And a shader pipeline coupled to the fixed pipeline code generator and the shader pipeline code generator to process at least one of the first microcode and the second microcode using a shader program.

The proposed 3D graphics processing method and apparatus provides a small hardware size and low power consumption. Fixed pipelines or programmable pipelines do not require additional instructions or compilations, and can minimize memory requirements. In addition, the performance of 3D graphics can be improved by mitigating the stall of the shader due to the hazards.

This is a description of the 3D printer.

OpenGL for Embedded Systems is a subset of the OpenGL 3D graphics application programming interface (API) designed for embedded devices such as mobile phones, personal digital assistants (PDAs), and consoles. OpenGL ES is managed by the non-profit technology group "Khronos Group".

<16> There are several versions of OpenGL ES. For example, OpenGL ES 1.0 is based on OpenGL 1.3.

OpenGL ES 1.0 was written in conjunction with OpenGL 1.5. OpenGL ES 2.0 was written in conjunction with the OpenGL 2.0 version. Published in May 2007, OpenGL ES 2.0 removes the fixed rendering pipeline and introduces a programmable pipeline. Most rendering features of the transformation and light source pipeline, such as the specification of the material or light source parameters described by the fixed-function API, have been replaced by shaders written by the graphics programmer. OpenGL ES 1.x includes at least one version of OpenGL ES 1.0, 1.1, 1.5, OpenGL ES 2.x includes OpenGL ES 2.0

. OpenGL ES 1.x is designed for fixed-function hardware and provides acceleration, image quality, and performance. Also, OpenGL ES 1.x highlights the hardware acceleration of the API. Unlike OpenGL ES 1.x, OpenGL ES 2.x enables full programmable 3D graphics. In addition, OpenGL ES 2.x emphasizes the ability to create shaders and program objects, as well as the ability of vertices and fragment shaders. OpenGL ES 2.x does not support fixed feature translation and short pipelines in OpenGL ES 1.x. Therefore, OpenGL ES 2.x is not backward compatible with OpenGL ES 1.x.

As mentioned above, OpenGL ES 1.x supports a fixed pipeline, while OpenGL ES 2.x supports a programmable pipeline. The programmable pipeline supported by OpenGL ES 2.x uses shaders. A shader is a set of software instructions that are used primarily to compute rendering effects on graphics hardware with high flexibility.

For example, the Direct3D, OpenGL, and OpenGL ES graphics libraries use three types of shaders:

 (1) The vertex shader is executed once for each vertex in the graphics processor. This translates the 3D position on the virtual space of each vertex to the 2D coordinates (such as the depth value of the Z-buffer), which is the 3D location displayed on the screen. Vertex shaders can handle properties such as position, color, and texture coordinates. The output of the vertex shader is provided in the next stage pipeline, such as a geometry shader or rasterizer. (2) A geometry shader can add or remove vertices from a mesh. The geometry shader is used to create geometry procedurally or to add volumetric detail to heavier current meshes to be processed by the central processing unit (CPU). If a geometry shader is used, its output is provided as a rasterizer.

(3) A fragment shader, also called a pixel shader, can calculate the color of each fragment (or pixel). The input to this stage is provided by a rasterizer that fills the polygons sent through the graphics pipeline. The short shader can be used for effects such as bump mapping or color toning and for scene lighting. A fixed pipeline provides only limited types of operations by adjusting finite state variables to a fixed structure. However, the short shader allows general and complex operations through programming, and it can provide infinite state variables in theory.

 Figure 1 shows the structure of a programmable pipeline using a shader. The vertex shader 110 receives user defined attribute variables and calculates coordinate transformations and / or illumination. The output of the vertex shader 110 is transformed by the rasterizer 120 into a raster format. The fragment shader 130 performs processing such as texture operation and color toning. The output of the fragment shader 130 is sent to the frame buffer 140 to perform processing for display. OpenGL ES 2.x is not backward compatible with OpenGL ES 1.x due to the difference between fixed and programmable pipelines. Programmable pipelines can provide flexibility to the user, but also handle fixed pipelines

There is an advantage in terms of speed. Not all the objects in a scene in the graphics need shaders, but where graphics graphics are not needed or where computational processing is required to be fast, OpenGL ES 1.x Can be expressed by reference. Therefore, the proposed techniques, apparatuses, and methods can be used to support a programmable pipeline and a fixed pipeline simultaneously. Supporting both programmable pipelines and fixed pipelines reduces hardware size and power consumption, and can be efficient for specific mobile environments. The following techniques may be implemented in hardware and / or software for processing various 3D graphics APIs such as Direct3D, OpenGL, OpenGL ES, and the like. OpenGL ES 1.x includes at least one version of OpenGL ES 1.0, 1.1, 1.5, and OpenGL ES 2.x includes OpenGL ES 2.0. For clarity, we describe OpenGL ES 1.x as a graphics API (application programming interface) that supports a fixed pipeline, and OpenGL ES 2.x as a graphics API that supports a programmable pipeline. It is not, and is not a limitation. The technical spirit of the present invention may be applied to other graphics APIs that support fixed pipelines or programmable pipelines. The contents of the following documents may be referenced. "OpenGL ES 1.1 Open Patent 10-2009-0097816 Specification" obtained from http://www.khronos.org/registry/gles/specs/1.1/es_full_spec.1.1.12.pdf; And "OpenGL ES 2.0 Specification" obtained from http://www.khronos.org/registry/gles/specs/2.0/es_full_spec_2.0.23.pdf. Figure 2 shows a block diagram of a computing device capable of implementing 3D graphics processing. The computer device 200 may be a mobile device such as a cell phone, PDA, console, personnel computer, or the like. The computer device 200 includes a central processing unit (CPU) 210, a memory 220, a graphics processor 230, and an interface unit 240. Each element of the computer device 200 may be connected via a system bus 290. The CPU 210 executes a software application. The memory 220 stores applications and data used by the CPU 220. The graphics processor 230 performs 3D graphics processing. Graphics processor 230 may process graphics APIs that support fixed pipelines and graphics APIs that support programmable pipelines. For example, the graphics processor 230 may process APIs that support OpenGL ES 1.x and / or OpenGL ES 2.x. The graphics processor 230 will be described in detail with reference to FIGS. 3 to 8 below. 3 shows an example of a block diagram of a graphics processor according to an embodiment of the present invention. The graphic processor 300 includes an API selector 310, a fixed pipeline code generator 330, a shader pipeline code generator 340, a hazard controller 350, and a shader pipeline 360. The API selection unit 310 receives the API and determines whether or not the fixed pipeline and / or programmable pipeline is supported. If it is determined that the input API supports the fixed pipeline, the API selection unit 310 sends the pipeline code to the fixed pipeline code generation unit 330. If it is determined that the API supports the programmable pipeline, the API selection unit 310 outputs the pipeline code to the shader pipeline code generation unit 340 send. The fixed pipeline code generation unit 330 converts the API supporting the fixed pipeline into a microcode (i.e., a first microcode) that can be recognized by the shader pipeline 360. The first microcode is a code that indicates what operation to perform in the shader pipeline 360. For example, the fixed pipeline code generation unit 330 may convert an API based on OpenGL ES 1.x into shader-based microcode. The shader pipeline code generator 340 converts the API supporting the programmable pipeline into another microcode (i.e., a second microcode) that the shader pipeline 360 can recognize. The second microcode is a code indicating what operation is to be performed in the shader pipeline 360. For example, the shader pipeline code generation unit 340 may convert APIs based on OpenGL ES 2.x into shader-based microcode. The hazard controller 350 receives the shader pipeline 360 from the first microcode generated by the fixed pipeline code generator 330 and / or the second microcode generated by the shader pipeline code generator 340, And checks whether or not a stall occurs at the execution of the program. If a hazard occurs, it performs a process to mitigate the stall. The hazard controller 350 may perform reordering, forwarding, and / or inter-locking of the first and second microcodes when a hazard occurs. The shader pipeline 360 processes the shader program by reading and decoding the first and second microcode. The shader pipeline 360 may be composed of a vertex shader and a fragment shader as shown in the example of Fig. The vertex shader receives constants necessary for each vertex and vertex calculation, calculates coordinate transformations and illumination, and outputs the transformed values. The transformed value can be input to the fragment shader through clipping and rasterization. The fragment shader handles texture operations and color toning.

OpenGL ES 2.x, which supports the programmable pipeline, uses shader programs by default. Thus, the shader pipeline code generator 330 may generate a second microcode for the shader pipeline 360. [ However, it is not easy to generate shader-based microcode from OpenGL ES 1.x that supports a fixed pipeline. To support OpenGL ES 1.x, compilation can be done in real time whenever an object's attributes change, but this may require additional code memory in the hardware. If you use only one code memory, clear the old code memory command every time you switch from OpenGL ES 2.x to OpenGL ES 1.x and / or switch from OpenGL ES 1.x to OpenGL ES 2.x, The overhead of inserting the instructions may occur. The increase in additional memory or overhead in a mobile environment can result in increased hardware area, additional power consumption. Therefore, it is necessary to design the graphics processor 300 to have a small hardware size, low power, and high performance improvement. 4 is a block diagram of a fixed pipeline code generation unit according to an embodiment of the present invention. The fixed pipeline code generation unit 330 includes a state unit 331, a code generator 332, a code buffer 333, and a controller 334. [ The state unit 331 parses an attribute of an input object, and outputs state information according to the parsed attribute. The state unit 331 is a finite state machine, and changes state according to a user-defined attribute. Each state

And includes a plurality of sub-states. The code generator 332 generates microcode based on the status information. Each state is input to a microcode multiplexer (not shown) to select and output at least one microcode. One microcode may be 64 bits. The code buffer 333 stores the generated microcode, and sends the microcode stored in the shader according to an instruction from the controller 334. [ The controller 334 manages the state machine 311, the code generator 332 and the code buffer 333. The controller 334 can control the change or hold of the state of the state unit 331 according to the attribute of the object. The size of the fixed pipeline code generator 330 configured as described above is only 5% of the size of a general code memory. Thus, the size of the hardware can be reduced and low power consumption can be provided. Now, a more specific example of the operation of the fixed pipeline code generation unit 330 will be described. Figure 5 shows an example of states according to attributes. Depending on the input attribute, the current state may be a state of at least one of an initial state, a vertex state, a texture state, a light state, and a fog state Is changed. Each state may include 50 to 170 sub-states that are mutually hierarchically associated. For example, consider the fog state in OpenGL ES 1.1. Once set, the fog state blends the fog color with the post-texture color of the rasterized fragment using a blending factor f. The blending factor f is calculated by one of the following three equations.

A description of 3D Printers for Early Learning.

Claims (1)

A graphics processor for 3D graphics processing, the method comprising: fixing (API) an application programming interface (API) supporting a fixed pipeline to a first microcode
A pipeline code generation unit; A shader pipeline code generator for converting an API supporting a programmable pipeline to a second microcode; And a shader pipeline code generation unit coupled to the fixed pipeline code generation unit and the shader pipeline code generation unit,
And a shader pipeline for processing at least one of the first microcode and the second microcode.

Images