JP5882367B2 - Runtime conversion of planar 3D to stereoscopic 3D - Google Patents

Description

  The present disclosure relates to graphics data processing, and more particularly to graphics data processing for stereoscopic views.

  A stereoscopic view refers to a perceptual image that appears to encompass a three-dimensional (3D) volume. To generate a stereoscopic view, the device displays two images on a two-dimensional (2D) area of the display. These two images contain substantially similar content, but with a slight displacement along the horizontal axis of one or more corresponding pixels in the two images. Simultaneous viewing of these two images on the 2D area causes the viewer to perceive an image that pops out of or is pushed into the 2D display displaying the two images. In this way, two images are displayed on the 2D area of the display, but the viewer perceives an image that appears to encompass a 3D volume.

  The two images of the stereoscopic view are called a left eye image and a right eye image, respectively. The left eye image is visible with the viewer's left eye, and the right eye image is not visible with the viewer's left eye. Similarly, the right eye image can be visually recognized by the viewer's right eye, and the left eye image cannot be visually recognized by the viewer's right eye. For example, the viewer can wear special glasses, the left lens of the glasses blocks the right eye image, passes the left eye image, the right lens of the glasses blocks the left eye image, and the right eye image Let it pass.

  The left-eye and right-eye images contain substantially similar content with slight displacement along the horizontal axis, but are not simultaneously visible by the viewer's eyes (eg, due to special glasses) Thus, the viewer's brain resolves slight displacements between corresponding pixels by communing the two images. By mixing, the viewer will perceive the two images as an image with a 3D volume.

  This application is filed on US Provisional Application No. 61 / 452,289, filed March 14, 2011, and April 12, 2011, each of which is incorporated herein by reference in its entirety. Claims the benefit of US Provisional Application No. 61 / 474,638.

  This disclosure describes techniques for modifying application program interface (API) calls in a manner that allows a device to render three-dimensional (3D) graphics content in stereoscopic 3D. The techniques of this disclosure may be implemented in a way that the API call itself is modified, but the API itself and the GPU hardware are not modified.

  In one example, a method for converting non-stereoscopic 3D content to S3D content is for intercepting an application program interface (API) call and for non-stereoscopic 3D content from an API call. Determining the model view projection matrix of the image, modifying the model view projection matrix to generate a modified model view projection matrix, and left view clipping coordinates based on the modified model view projection matrix Generating a right view clipping coordinates based on the modified model view projection matrix, generating a left view based on the left view clipping coordinates, and right view clipping Generate right view based on coordinates and left view And rendering the S3D image based on the right view.

  In another example, the device includes a memory that stores instructions, a graphics processing unit (GPU), and a processor. The processor intercepts an application program interface (API) call when executing instructions, determines a model view projection matrix for non-stereoscopic 3D content from the API call, and generates a modified model view projection matrix Modifying the model view projection matrix to cause the GPU to generate left view clipping coordinates based on the modified model view projection matrix, and allowing the GPU to generate right view clipping coordinates based on the modified model view projection matrix. Generating a left view based on the left view clipping coordinates, causing the GPU to generate a right view based on the right view clipping coordinates, and causing the GPU to generate a left view and a right view. Rendering an S3D image based on Sea urchin is operational.

  In another example, an apparatus for converting non-stereoscopic 3D content into S3D content comprises: means for intercepting an application program interface (API) call; and non-stereoscopic 3D content from an API call. Means for determining a model view projection matrix for 3D content; means for modifying the model view projection matrix to generate a modified model view projection matrix; and left view clipping based on the modified model view projection matrix Means for generating coordinates; means for generating right view clipping coordinates based on a modified model view projection matrix; means for generating a left view based on left view clipping coordinates; and right view clipping coordinates To generate a right view based on the left view and right view And means for rendering S3D image Zui.

  In another example, a computer-readable storage medium, when executed, intercepts an application program interface (API) call to one or more processors and from the API call, a model view for non-stereoscopic 3D content. Determining a projection matrix, modifying the model view projection matrix to generate a modified model view projection matrix, generating a left view clipping coordinate based on the modified model view projection matrix, and a modified model view Generating a right view clipping coordinate based on the projection matrix, generating a left view based on the left view clipping coordinate, generating a right view based on the right view clipping coordinate, and a left view And rendering the S3D image based on the right view That stores instructions.

  The details of one or more aspects of the disclosure are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the disclosure will be apparent from the description and drawings, and from the claims.

1 is a block diagram illustrating functions of an example system that may implement one or more example techniques described in this disclosure. FIG. 1 is a block diagram illustrating an example of an apparatus that may implement one or more exemplary techniques described in this disclosure. FIG. 3 shows a geometric representation of an S3D viewing area generated using the techniques of this disclosure. FIG. 6 illustrates a geometric representation of a viewport shift that can be performed in accordance with the techniques of this disclosure. FIG. 3 is a block diagram illustrating the exemplary device of FIG. 2 in further detail. 6 is a flowchart illustrating example operations in accordance with one or more example techniques described in this disclosure.

  The exemplary techniques described in this disclosure are directed to rendering stereoscopic 3D (S3D) graphics during execution or runtime. In conventional 3D graphics rendering, a graphics processing unit (GPU) generates 3D graphics from a single viewpoint (eg, a mono view). This single viewpoint may mean a single image that is visible by both the viewer's right and left eyes.

  S3D graphics differ from 3D graphics in that S3D graphics generates a stereoscopic view. The term stereoscopic view refers to an image generated from a binocular viewpoint. In a binocular viewpoint, there can be two images, one image visible by one eye, not visible by the other eye, and vice versa. For example, when a viewer wears binoculars, light that enters through the left lens of the binoculars is visible with the left eye, not visible with the right eye, and vice versa. The binocular viewpoint is sometimes called a stereoscopic view.

  For example, in S3D graphics, the GPU may generate an image for the left eye and another image for the right eye, i.e., generate a stereoscopic view. The term stereoscopic view refers to two images (eg, a left eye image and a right eye image) that are each displayed on a display, while a mono view refers to a single image that is displayed on a display. . The combination of the left eye image and the right eye image can appear to the viewer as if the image is popping out of the display displaying the image or being pushed into the display. This can result in a more realistic and richer viewing experience.

  In the present disclosure, the concepts of S3D images (eg, stereoscopic views) and 3D images (eg, mono views) should not be confused. A 3D image is an image that is limited to a two-dimensional (2D) area of the display. For example, objects in a 3D image may appear farther away or closer than other objects in the 3D image. However, all of these objects are limited to the 2D area of the display. The S3D image is a perceptual image that results from the combination of the right eye image and the left eye image by the viewer's brain. The resulting image (ie, S3D image) appears not to be limited to the 2D area of the display. Instead, the S3D image appears to encompass a 3D volume where the image appears to jump out of the display or be pushed into the display. For example, objects in an S3D image appear farther away or closer than other objects in a 3D volume, and appear not to be 2D areas as in the case of 3D images.

  The right eye image and the left eye image that form the S3D image with each other may be 3D images. When the viewer's brain combines the 3D right-eye image and the 3D left-eye image, it is the brain that causes the viewer to perceive the S3D image. The content of the right eye image and the left eye image can be substantially similar to the content of a single 3D image. This disclosure describes techniques for converting 3D graphics content to S3D content. By using the techniques of this disclosure, many existing 3D graphics content can be converted to S3D graphics content and displayed on a stereoscopic display.

  The present disclosure also describes techniques for modifying application program interface (API) calls in a manner that allows a GPU to perform the described 3D-S3D conversion. The techniques of this disclosure may be implemented in a way that only the API call itself is modified, as opposed to the API or GPU being modified.

  In order to generate S3D content from native 3D content, the techniques of this disclosure include techniques for 3D-S3D conversion. The technique includes software for intercepting a selected API call from a 3D application to a 3D graphics API. The intercepted API call can be modified in a way that causes the system for generating graphics to create a binocular view that can be displayed on the S3D display during runtime, thereby allowing the user to view the rendered content. Can create S3D effects. Two images, a left eye image and a right eye image, can be rendered by the same graphics pipeline based on an analysis of natural 3D content. The two images can be generated using different setups for viewing position and / or orientation. A system implementing the techniques of this disclosure may be placed in the upper right corner of a graphics API, such as the OpenGL ES API used in mobile devices, allowing API calls from 3D graphics applications to be intercepted. . In some embodiments, the 3D-S3D conversion system can only be implemented using software without requiring changes to GPU hardware, graphics driver code, or 3D graphics application content. Can be implemented. The techniques of this disclosure may be applied with OpenGL, OpenGL ES, and other graphics APIs.

  Techniques for converting natural 3D content to S3D content currently exist in the art, but many of these techniques require the knowledge of information that they are not always known to API. Since the call is requested, the application is limited, or they make assumptions about the S3D viewing space that are not always accurate, resulting in poor S3D image quality. This disclosure describes 3D-S3D conversion techniques that, in some cases, are widely available and produce good image quality.

  FIG. 1 is a functional diagram of an exemplary 3D-S3D conversion system 100 in which the techniques of this disclosure may be implemented. The system 100 of FIG. 1 provides a functional overview. The system 100 includes 3D graphics content 112, a system command 116 for enabling 3D-S3D conversion, an enable S3D module 120, a 3D-S3D conversion module 124, an API 128, a vertex processing module 132, A left binning unit 136, a right binning unit 140, a pixel processing module 144, a left frame buffer 148, a right frame buffer 152, a left image 156, and a right image 160. Including. Portions of system 100 are described in more detail later in this disclosure with respect to additional hardware and software components. Further, as will be described in more detail below, some parts of the system 100 may be implemented as part of the GPU, such as the vertex processing module 132, the left binning unit 136, the right binning unit 140, and the pixel processing module 144. .

  The 3D graphics content 112 and system commands 116 may be stored in system memory in the form of computer code. The 3D graphics content 112 can include, for example, graphics commands that are used to generate a 3D image. When using the OpenGL ES API, for example, graphics commands can include glDraw commands such as glDrawArrays () and glDrawElements (), which are described in more detail below.

  3D-S3D conversion may be enabled by system command 116. System command 116 may represent, for example, a user input command or may be a command included in an application being executed by an application processor. When 3D-S3D is not enabled, 3D graphics content 112 can be processed in the usual way to generate 3D images. In such a case, the portion of the system 100 shown as a dotted line may or may not be utilized, but other portions of the system 100 may be a single mono object as opposed to the left and right images. Process the view image. When 3D-S3D conversion is not enabled (see, for example, 120 no), an unmodified API call is sent to API 128. An unmodified API call generally refers to an API call from 3D graphics content 112 that is sent to API 128 in their original form.

  When 3D-S3D conversion is enabled (see eg, 120 for yes), the 3D-S3D conversion module 124 intercepts the API calls for graphics content 112 and is opposed to them as a single mono view The API call can be modified in a way that causes the left eye view and right eye view to be generated. The modified API call generated by the 3D-S3D conversion module 124 may then be required by the API 128 to cause the GPU to render the left eye image and the right eye image. The modified API call generates a left eye image to be stored in the left frame buffer 148 and a right eye image to be stored in the right frame buffer 152, a vertex processing module 132, a left binning unit 136, It can be executed by the right binning unit 140 and the pixel processing module 144. In the example system 100, the 3D-S3D conversion module 124 represents an application running on an application processor that is configured to intercept API calls and perform modifications to those API calls. Modification to the API call allows 3D graphics content to be rendered as S3D graphics content by the GPU.

  In a typical 3D graphics pipeline, 3D graphics content is primarily in the form of basic data that describes geometric primitives. For both the left and right images, the vertex processing unit 132 can generate a set of pixel positions in the 2D display plane based on the geometric primitive data. The left binning unit 136 can assemble a geometric basis associated with the left image for each tile, with the tile corresponding to a portion of the left image. Similarly, the right binning unit 140 can assemble the geometric basis associated with the right image for each tile. For each of the left and right image tiles, the pixel processing unit 144 can calculate attributes for the pixels determined by the vertex processing unit 132. The pixel processing module 144 can output a left image (eg, the left image 156) to the left frame buffer 148 and can output a right image (eg, the right image 160) to the right frame buffer 152. The left image 156 and the right image 160 can be displayed simultaneously on the S3D display to generate an S3D image. In this way, 3D graphics content 112 does not include S3D graphics content, but the output of system 100 may still be an S3D image.

  The functions performed by the vertex processing module 132, the left binning unit 136, the right binning unit 140, and the pixel processing module 144 are described in more detail below with respect to FIG. In some configurations, the system may include various hardware components dedicated to the right eye image and various hardware components dedicated to the left eye image. However, in other embodiments, the same components can be used for both the right eye image and the left eye image. In the system 100 of FIG. 1, for example, the vertex processing module 132 and the pixel processing module 144 may be implemented in software, but the left binning unit 136, the right binning unit 140, the left frame buffer 148, and the right frame buffer 150 Is implemented in hardware. However, in other configurations, the vertex processing module 132 and the pixel processing module 144 may be implemented in hardware, or the left frame buffer 148 and the right frame buffer 152 hold both the left and right images. It can be replaced by a single frame buffer. Further, as described above, the system 100 only provides a functional overview of the system in which the techniques of this disclosure can be implemented, and some aspects of the graphics pipeline are simplified or described for purposes of illustration. It is omitted.

  FIG. 2 is a block diagram illustrating an example of an apparatus that may implement one or more exemplary techniques described in this disclosure. For example, FIG. Examples of equipment 210 include, but are not limited to, mobile wireless telephones, personal digital assistants (PDAs), video gaming consoles including video displays, mobile video conferencing units, laptop computers, desktop computers, television set top boxes, etc. There is. As shown in FIG. 2, the device 210 may include an application processor 212, a graphics processing unit (GPU) 220, and a system memory 226. The device 210 may include components in addition to the components shown in FIG. Although portions of this disclosure generally describe 3D-S3D conversion techniques for systems that utilize both an application processor and a GPU, the techniques described in this disclosure are not necessarily limited to such systems. . For example, some of the 3D-S3D conversion techniques of this disclosure may be performed only by an application processor without a GPU in some cases.

  Application processor 212 may be a central processing unit (CPU) of device 210. The GPU 220 may be a processing unit operable to output graphics data for presentation on a display. Examples of application processor 212 and GPU 220 include, but are not limited to, a digital signal processor (DSP), a general purpose microprocessor, an application specific integrated circuit (ASIC), a field programmable logic array (FPGA), or other equivalent integrated circuit. Or there are discrete logic circuitry.

  System memory 226 can be an example of a computer-readable storage medium. For example, in the present disclosure, the system memory 226 may store instructions that cause the application processor 212 and the GPU 220 to execute functions attributable to each. In this manner, system memory 226 can be considered a computer-readable storage medium comprising instructions that cause one or more processors, eg, application processor 212 or GPU 220 to perform various functions.

  Examples of system memory 226 include, but are not limited to, random access memory (RAM), read only memory (ROM), electrically erasable ROM (EEPROM), CD-ROM or other optical disk storage device, magnetic disk storage device. Or any other medium that can be used to carry or store the desired program code in the form of instructions or data structures and accessed by a computer or processor. System memory 226 may be considered a non-transitory storage medium in some examples. The term “non-transitory” may indicate that the storage medium is not implemented with a carrier wave or a propagated signal. However, the term “non-transitory” should not be construed to mean that the system memory 226 is non-movable. As an example, system memory 226 may be removed from device 210 and transferred to another device. As another example, a storage device that is substantially similar to the system memory 226 may be inserted into the device 210. In some examples, the non-transitory storage medium may store data (eg, in RAM) that may vary over time.

  Although GPU 220 illustrates an example of a GPU with a fixed function pipeline, the techniques of this disclosure may also be implemented using a GPU that includes programmable elements. The GPU 220 includes a vertex processor 222 and a pixel processor 224. The vertex processor 222 may include a hardware unit that performs vertex processing functions, while the pixel processor may include a hardware unit that performs pixel processing functions. In other words, the vertex processor 222 and the pixel processor 224 may include hardware units with fixed functions and minimal functional flexibility. However, as described above, the techniques of this disclosure are not limited to GPUs with fixed function pipelines.

  The example techniques described in this disclosure may utilize a software application executed by application processor 212 to intercept an API call and modify the API call to generate a modified API call. This software application is shown as a graphics driver wrapper 216 in FIG. Using the modified API call, GPU 220 can render S3D graphics.

  As described above, the stereoscopic view includes a left eye image and a right eye image. A left eye image and a right eye image include substantially similar image content as a monoview image, however, one or more corresponding pixels of the left eye image and the right eye image are on a horizontal axis relative to each other. Can be displaced along. For example, consider that the right eye image is placed on the left eye image. In this case, all of the content in the right eye image may not be perfectly aligned with the equivalent content in the left eye image. Rather, one or more objects in the right eye can be to the left or right of an equivalent object in the left eye image.

  The left eye image is visible by the viewer's left eye, and the right eye image is blocked from the viewer's left eye. The right eye image can be visually recognized by the viewer's right eye, and the left eye image is blocked from the viewer's right eye. In some examples, the viewer may wear special glasses that prevent the left eye image from being visible by the right eye and prevent the right eye image from being visible by the left eye. However, aspects of the present disclosure do not necessarily require viewers to wear special glasses. For example, some displays do not require the viewer to wear special glasses to experience a stereoscopic view. The techniques of this disclosure may be extended to such situations.

  When the viewer views both the left-eye image and the right-eye image at the same time, the viewer's brain pops out of the display displaying the two images or is pushed into the display The GPU 220 may generate graphics data for the left eye image and the right eye image so that the image is perceived (eg, appears to be in front of or behind the display). This popping or being pushed is due to the viewer's brain resolving a horizontal discrepancy in the two images of the stereoscopic view with substantially similar content.

  As an example, application processor 212 may execute one or more applications, such as application 232 stored in system memory 226. Examples of application 232 include, but are not limited to, web browsers, email applications, spreadsheets, video games, or other applications that generate viewable objects for display. For example, application 232 may be a video game that, when executed, outputs 3D graphical content that is displayed on a display.

  Application 232 may be designed by a developer for mono view. For example, application 232 may generate 3D graphics content when executed, and 3D graphics content is limited to the 2D area of the display. Application 232, when executed on application processor 212, may divide the generated 3D graphics content into basic shapes such as triangles, rectangles, or other types of polygons. Each of these basic forms can be used to render the pixels to be displayed on the display. Application 232, when executed on application processor 212, may also render pixel values for each of the base shape vertices. For example, the values may include vertex 3D coordinates, vertex color values, and vertex transparency values. The value need not include all of the exemplary components described above in every aspect of the present disclosure.

  Application processor 212 may then transfer the pixel values for the vertices to GPU 220 for further processing. For example, the application processor 212 may include a graphics driver 214 that may be software running on the application processor 212. Graphics driver 214 may be designed to send commands to GPU 220, and in response, GPU 220 may perform functions according to the received commands. For example, the graphics driver 214 functions as an interface between the GPU 220 and the application processor 212. When the application processor 212 issues a command to the GPU 220, the GPU 220 receives the command through the graphics driver 214. For example, an application 232 executing on the application processor 212 may instruct the GPU 220 to perform a specific task. In this case, graphics driver 214 may receive instructions for a particular task from application 232 and may provide the instructions to GPU 220. In response, GPU 220 may perform a task.

  In some examples, graphics driver 214 may be designed according to a specific API. For example, the graphics driver 214 may be designed according to the OpenGL or OpenGL ES (Embedded Systems) API, which is an API of the Khronos group, and their specifications are publicly available. However, the techniques of this disclosure may be extensible to Microsoft's DirectX system, such as DirectX 9, 10, or 11, or other graphics systems and APIs. For purposes of explanation, the techniques of this disclosure will be described in the context where the API is an OpenGL EX 1.1 API. However, aspects of the present disclosure are not so limited and can be extended to other APIs or graphics systems.

  In order to render the basic shape received from application processor 212, GPU 220 may include one or more vertex processors, such as vertex processor 222, and one or more, such as pixel processor 224, for generating pixel values for display pixels. Other pixel processors. The GPU 220 may also include other elements not shown. The techniques of this disclosure are not limited to a specific GPU architecture. Developers may develop graphics applications depending on the capabilities of vertex processor 222 and pixel processor 224 and on APIs such as the OpenGL EX 1.1 API used in this disclosure for purposes of illustration.

  Application 232 may generate coordinates for the vertices of the basic shape. These coordinates may be referred to as the world coordinate system and may be specific to the application 232. In other words, the coordinates of the vertices defined by the application 232 may not necessarily be the coordinates of the indicator on which the basic shape is displayed, and in some cases, for vertices outside the visible region. Can be coordinates. Vertex processor 222 may be designed to convert a world coordinate system, which may be 3D, to 2D coordinates (eg, display coordinates) of the display. To perform this function, vertex processor 222 may convert the world coordinate system to eye coordinates and then to clipping coordinates. For example, the output of vertex processor 222, when executed, may be the vertex clipping coordinates. Final display coordinates, eg, display coordinates, can then be determined by the pixel processor 224.

  Clipping coordinates may define a view frustum. The view frustum may define the visible region of 3D graphics content. The GPU 220 may use the field frustum to select pixels that exist outside the field frustum. For example, a fixed functional unit of GPU 220 (such as pixel process 224) may screen pixels that exist outside the view frustum defined by the clipping coordinates generated by application 232.

The equation for calculating the clipping coordinate system from the world coordinate system may be as follows:

Where Vclip is the vertex clip coordinate system, Veye is the vertex eye coordinate, Vworld is the vertex world coordinate system given by the application 232, PRJ is the projection matrix, and MVT is the model view transformation matrix ( Or world view transformation matrix). In some examples, the PRJ and MVT matrices may be combined into a single matrix, sometimes referred to as the model view projection matrix or MVP shown above in Equation 1, where MVP = PRJ * MVT.

Projection matrix (PRJ) and model view, or world view, transformation matrix (MVT) can be defined by API. The terms model view and world view may be used interchangeably. Vclip, Veye, and Vworld may include four components (eg, x coordinate, y coordinate, z coordinate, and w coordinate). For example, Vclip, Veye, and Vworld can be expressed as:

OpenGL and OpenGL ES API define a PRJ matrix as follows.

Where L and R specify the coordinates for the left and right vertical clipping planes, B and T specify the coordinates for the lower and upper horizontal clipping planes, and z _near and z _far specifies the distance to the near and far depth clipping planes. Thus, L and R specify the width of the viewport, while B and T specify the height of the viewport. For a symmetric viewport, -L can be equal to R and -B can be equal to T.

In some examples, the clipping plane can be symmetric. For example, -L can be equal to R and -B can be equal to T. In these cases, the PRJ matrix can be simplified as follows:

OpenGL and OpenGL ES API define the MVT matrix as follows.

  All of the variables in the PRJ matrix and the MVT matrix may be defined by the application 232 running on the application processor 212, and the graphics driver 214 may provide these variables to the vertex processor 222. As can be seen from Equation 1, Equation 4, and Equation 5, using these variables, vertex processor 222 may determine the Vclip coordinates for each of the vertices. GPU 220 may utilize clip coordinates for vertices and perform additional functions to render the image for display. In this way, GPU 220 may generate a mono view for 3D graphics content generated by application 232.

  In one or more exemplary techniques described in this disclosure, graphics driver wrapper 216, which may be software running on application processor 212, provides clipping coordinates for a stereoscopic view (eg, clipping for a left eye image). The API call that defines the clipping coordinates for the mono view may be modified to define the coordinates and the clipping coordinates for the right eye image. In addition to modifying the API call that defines the clipping coordinates, the graphics driver wrapper 216 also modifies the API call that defines the viewport for the mono view to define the viewport for the stereoscopic view. Can do. For example, application 232 may define the size and position of a single image (eg, mono view) on a display that displays the image. The graphics driver wrapper 216 converts an API call that defines the size and position of a single image into a modified API call that defines the size and position of the left and right eye images (eg, a viewport for the left eye image). And instructions for the viewport for the right eye image). In this way, graphics driver wrapper 216 may intercept a single API call for mono view and generate a modified API call for both left view and right view.

As an example of how the graphics driver wrapper 216 can modify an API call, the graphics driver wrapper can intercept an API call with the variables for PRJ and MVT described above. As explained above, the variables for PRJ and MVT can be used by GPU 220 to render a mono 3D view with clipping coordinates Vclip. Graphics driver wrapper 216 can modify the API call so as to generate the right image with the left image and the clipping coordinates Vclip _{Right_eye} with clipping coordinates _Vclip left_eye.

As shown above in equation (1), Vclip = PRJ * Veye = PRJ * MVT * Vworld. The equation for Vclip can be modified to generate clipping coordinates for the left eye and clipping coordinates for the right eye. For example, the clipping coordinates for the left eye and the right eye can be as follows:

VT _{left_eye} and VT _{right_eye} may be 4 × 4 view transformation matrices based on the assumed distance between the left eye and the right eye from the mono view. For example, if the monoview coordinates are assumed to be (0,0,0), the left eye may be considered to be located at (−D, 0,0) and the right eye will be (D, 0,0). 0). In other words, the (0, 0, 0) position can be considered to be in the middle between the viewer's right eye and left eye. If the left eye is considered to be located −D away from the middle of the right and left eyes, and the right eye is considered to be located + D away from the middle of the right and left eyes, then D is viewed The half of the distance between a person's right eye and left eye is shown.

The view transformation matrix for VT _{left_eye} and VT _{right_eye} may be defined as follows:

VT _{left_eye} and VT _{right_eye} can be rewritten as the sum of two matrices. For example, VT _{left_eye} can be rewritten as follows.

VT _{right_eye} can be rewritten as follows.

By _{replacing the} VT _{left_eye} matrix with the equation for Vclip _{left_eye} (Equation 6), Vclip _{left_eye} becomes equal to:

By _{replacing the} VT _{right_eye} matrix with the equation for Vclip _{right_eye} (Equation 7), Vclip _{right_eye} is equal to:

In both Expression 10 and Expression 11, for example, Vclip _{left_eye} and Vclip _{right_eye} are as follows.

As described above in Equation 1, PRJ * MVT * Vworld is equal to MVP * Vworld. Thus, the expressions for Vclip _{left_eye} and Vclip _{right_eye} (eg, Expression 10 and Expression 11, respectively) can be rewritten as follows:

as well as

By replacing the matrix for PRJ (Equation 3 or Equation 4) and MVT (Equation 5) and performing the matrix multiplication of Equation 10, the equation for Vclip _{left_eye} can be simplified as follows:

More details are as follows.

Using the same permutation and substitution for Vclip _{Left_eye,} expression Vclip _{Right_eye} may simplified as follows.

Using the left view transform matrix (VT _{left_eye} ) described above, the graphics driver wrapper 216 can modify the API call for the 3D image to generate the left eye 3D image. Similarly, using the right view transformation matrix (VT _{right_eye} ) described above, the graphics driver wrapper 216 can modify the API call for a 3D image to generate a right eye 3D image. . By simultaneously displaying the left eye 3D image and the right eye 3D image, the device 210 can render the S3D image.

The techniques described above with respect to Equations 7-16 may be implemented without modification to GPU 220 or graphics driver 214 by modifying the API call. The techniques described with respect to Equations 7-16 may be used for frustum-independent S3D rendering approximation. The described techniques are considered frustum-independent because they do not require knowledge of specific frustum parameters, such as parameters that may be included in a glFrustum () call. The techniques of this disclosure are the same as defined by the original content when determining Vclip _{left_eye} and Vclip _{right_eye} for the right view and the left view, respectively, except shifting the viewing position by D and D, respectively. Including using a frustum of view. As a result of assuming a parallel viewing direction for each eye, both left and right view transformations are shifted in the horizontal direction as described above with respect to Equations 8a and 8b and Equations 9a and 9b. Can be assumed to be close to the identity matrix with The same projection matrix (eg, PRJ described by either Equation 3 or Equation 4 above) can be determined and used for both the left eye and the right eye. In order to create an S3D image according to the techniques of this disclosure, it is not necessary to know the parameters used to determine the effective value for PRJ or PRJ. Similarly, according to the techniques of this disclosure, it is not necessary to know the parameters used to determine MVT or the effective value for MVT. Whatever parameters PRJ and MVT contain, the parameters can be treated as a single matrix, ie MVP. To create an S3D image, a constant, ie 2 * Z _near * D / (R−L), can be added to or subtracted from the elements in the first row and fourth column of the MVP matrix. . For a given 3D content, the value of Z _near / (R−L) may be a constant. Thus, combining Z _near / (R−L) with D produces more constants. In some embodiments, different constants may be tried until a constant is created that creates a correct and comfortable S3D effect. Since only MVP is modified, the techniques of this disclosure can operate with or without receiving separate matrices for PRJ and MVT.

  As shown in FIG. 3A, when rendered on the display plane 330, a portion of the left image 320 and a portion of the right image 310 may be cropped from the final S3D image. For clarity, FIG. 3A shows a left image 320 slightly in front of the display plane 330 and a right image 310 slightly behind the display plane 330. However, this only creates FIG. 3A such that the left image 320 and the right image 310 are actually rendered on the display plane 330. The zero disparity plane (ZDP) of the S3D image appears to be in front of the display plane 330 so that the same field frustum is used to generate the left image 320 and the right image 310 And make the viewer perceive a popped out effect. As described in more detail below, this effect can be reversed by shifting the viewport offset between the left eye image and the right eye image.

  In some embodiments, the amount of shift applied to the viewport offset between the left eye image and the right eye image may be based on user input parameters. This disclosure includes generating a left eye view and a right eye view for an S3D image by using a symmetrical projection matrix, a parallel viewing direction, and a viewport offset shift. The technique can in some cases render a high quality S3D image in a runtime environment, a richer and more complete experience compared to viewing an image limited by the 2D area of the display. It is possible to provide the viewer with the S3D experience.

  FIG. 3B shows an example of how an object (object A) may be shifted using the techniques described in this disclosure. FIG. 3B shows a diagram of ZDP changes with corresponding viewport shifts. In FIG. 3B, lines 301A and 301B represent the right eye viewport before the viewport shift, and lines 303A and 303B represent the right eye viewport after the viewport shift. Lines 302A and 302B represent the left eye viewport before the viewport shift, and lines 304A and 304B represent the viewport after the viewport shift. The mathematical relationship of the viewport shift depth change can be derived as follows.

Δ represents ½ of the projected viewport distance of the object located at point A;
VP _s indicates the viewport shift amount for the viewport,
E indicates a distance of ½ of the eye interval.

First, based on point A, point A ′ and the trigonometry of the left eye position and right eye position,

Combining Equation 17 and Equation 18 above, the object distance in the viewer space after the viewport shift can be derived as follows.

Based on Equation 19 above, a new ZDP position in the viewer space can be obtained based on Equation 20.

  FIG. 4 is a block diagram illustrating the exemplary device of FIG. 2 in more detail. For example, FIG. 4 shows the device 210 of FIG. 2 in more detail. For example, as described above, examples of device 210 include, but are not limited to, mobile wireless telephones, PDAs, video gaming consoles including video displays, mobile video conferencing units, laptop computers, desktop computers, television set tops There are boxes.

  As shown in FIG. 4, the device 210 includes an application processor 412, a GPU 420, a system memory 426 including a frame buffer 452, a transceiver module 456, a user interface 458, a display 460, and a display processor 462. obtain. Application processor 412, GPU, and system memory 426 may be substantially similar to application processor 212, GPU 220, and system memory 226, respectively, of FIG. For brevity, only those components shown in FIG. 4 but not shown in FIG. 2 will be described in detail.

  The device 210 shown in FIG. 4 may include additional modules or units not shown in FIG. 4 for clarity. For example, device 210 may include a speaker and microphone, both of which are not shown in FIG. 4, or a speaker where device 210 is a media player, in order to implement telephone communication in an example where device 210 is a mobile wireless phone. . Further, the various modules and units shown in device 210 may not be necessary in every example of device 210. For example, user interface 458 and display 460 may be external to device 210 in examples where device 210 is a desktop computer or other device capable of interfacing with an external user interface or display.

  Examples of user interface 458 include, but are not limited to, a trackball, a mouse, a keyboard, and other types of input devices. User interface 458 may also be a touch screen and may be incorporated as part of display 460. The transceiver module 456 may include circuitry for enabling wireless or wired communication between the device 410 and another device or network. The transceiver module 46 may include modulators, demodulators, amplifiers and other such circuits for wired or wireless communications. The display 460 may comprise a liquid crystal display (LCD), an organic light emitting diode display (OLED), a cathode ray tube (CRT) display, a plasma display, a polarization display, or another type of display device.

  Display processor 462 may be configured to cause display 460 to display a stereoscopic view. There may be various techniques that the display processor 462 may utilize to cause the display 460 to display a stereoscopic view, and aspects of the present disclosure may utilize any of these techniques. For example, the display processor 462 may retrieve the left eye image from the left half of the frame buffer 452 and the right eye image from the right half of the frame buffer 452 to interleave the two images together to provide a stereoscopic view. .

  As another example, display processor 462 may control the refresh rate of display 460. In this example, during each refresh cycle, the display processor 462 may cycle between the left eye image and the right eye image. For example, the display processor 462 retrieves the left eye image from the left half of the frame buffer 452, extends the left eye image to the entire display 460, and displays the left eye image on the display 460 for one refresh cycle. Can do. Then, during the next refresh cycle, display processor 462 may perform a substantially similar function if there is no right eye image stored in the right half of frame buffer 452. In other words, the display 460 may display a left eye image, then a right eye image, then a left eye image, and so on.

  The viewer may be wearing special glasses that synchronize with the refresh rate of the display processor 462. For example, while the display 460 is displaying the left eye image, special glasses may shutter close the right lens so that only the viewer's left eye captures the left eye image. Then, while the display 460 displays the right eye image, the special glasses can shutter close the left lens so that only the viewer's right eye captures the right eye image, and so on. If the refresh rate is fast enough, the viewer will perceive a stereoscopic view in which the image pops out of the display 460 and encompasses the 3D volume.

  In some examples, some conventional display processors may not be configured to cause the display 460 to display a stereoscopic view. In these examples, the viewer may couple device 210 to a display that includes a display processor, such as display processor 462, configured to cause the display to present a stereoscopic view. For example, the viewer may couple the device 210 to a stereoscopic view enabled television via the transceiver module 456. For example, a viewer may couple the transceiver module 456 to a television via a high resolution multimedia interface (HDMI®) wire. In this example, the application processor 412 or GPU 420 may instruct the transceiver module 456 to transmit the pixel values stored in the frame buffer 452 to the television display processor. The television display processor may then cause the television to display a left eye image and a right eye image to form a stereoscopic view.

  In these examples, it may still be possible for the display of device 210 to display a left eye image and a right eye image. However, because the display processor 462 of the device 210 may not be able to cause the display 460 of the device 410 to present a stereoscopic view, in this example, the display 460 is configured to display the left eye image, the right eye image, and the right eye image. Can be displayed in parallel. For example, the left half of the display 460 may display a left eye image, and the right half of the display 460 may display a right eye image. This may be due to the viewport conversion described above. In this case, even when special glasses are used, the viewer cannot experience the stereoscopic view simply by visually recognizing the display 460, but can view the stereoscopic view by viewing the television corresponding to the stereoscopic view. Will experience.

  FIG. 5 is a flowchart illustrating an exemplary 3D-S3D conversion operation in accordance with one or more exemplary techniques described in this disclosure. As described above, the 3D-S3D conversion techniques described in this disclosure, including the technique of FIG. 5, may be performed by a system with a GPU, such as the device 210 of FIGS. 2 and 4 described above.

  According to the technique of FIG. 5, a graphics driver wrapper, such as graphics driver wrapper 214 of FIG. 2, intercepts the API call (510). The API call can be, for example, from an application configured to generate 3D graphics content (ie, non-stereoscopic 3D content). From the API call, graphics driver wrapper 216 determines a model view projection matrix for 3D content (520). As explained above, the values for the entries in the model view projection matrix can be determined even if the individual parameters used to determine those values are not specifically known. In some cases, graphics driver wrapper 216 may determine the model view projection matrix based on PRJ * MVT as described above. However, in other examples, PRJ and MVT may not be known to graphics driver wrapper 216. Graphics driver wrapper 216 modifies the model view projection matrix to generate a modified model view projection matrix (530).

  Graphics driver wrapper 216 generates left view clipping coordinates based on the modified model view projection matrix (540). The left view clipping coordinate can be determined, for example, according to Equation 6 described above, where PRJ * MVT is equal to MVP. Graphics driver wrapper 216 generates right view clipping coordinates based on the modified model view projection matrix (550). The right view clipping coordinates can be determined, for example, according to Equation 7 described above, where PRJ * MVT = MVP. The GPU 220 generates a left view based on the left view clipping coordinates (560), and the GPU 220 generates a right view based on the right view clipping coordinates (570). The GPU 220 renders an S3D image based on the left view and the right view (580). Prior to rendering on the display, the GPU 220 can apply a viewport shift to the left view and a viewport shift to the right view.

  In one or more examples, the functions described can be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored on a computer-readable medium as one or more instructions or code. The computer readable medium may include a computer data storage medium. A data storage medium is any available medium that can be accessed by one or more computers or one or more processors to retrieve instructions, code, and / or data structures for implementation of the techniques described in this disclosure. possible. By way of example, and not limitation, such computer readable media can be random access memory (RAM), read only memory (ROM), EEPROM, CD-ROM or other optical disk storage device, magnetic disk storage device or other magnetic storage device. It may comprise device equipment or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. The disc and disc used in this specification are a compact disc (CD), a laser disc (registered trademark) (disc), an optical disc (disc), and a digital versatile disc (DVD). ), Floppy® disk and Blu-ray® disk, the disk normally reproducing data magnetically, and the disk using a laser Reproduce optically. Combinations of the above should also be included within the scope of computer-readable media.

  The code may be one or more processors, such as one or more digital signal processors (DSPs), a general purpose microprocessor, an application specific integrated circuit (ASIC), a field programmable logic array (FPGA), or other equivalent integrated circuit or Can be implemented by discrete logic. Thus, as used herein, the term “processor” can refer to either the foregoing structure or other structure suitable for the implementation of the techniques described herein. Also, the techniques may be fully implemented in one or more circuits or logic elements.

  The techniques of this disclosure may be implemented in a wide variety of devices or apparatuses, including a wireless handset, an integrated circuit (IC), or a set of ICs (eg, a chip set). Although this disclosure has described various components, modules or units in order to highlight the functional aspects of an apparatus configured to perform the disclosed techniques, these components, modules or units may be It does not necessarily have to be realized by different hardware units. Rather, as described above, the various units can be combined in a hardware unit, including one or more processors described above, with suitable software and / or firmware, or interoperating hardware units. Can be given by a set of

Various examples have been described. These and other examples are within the scope of the following claims.
The invention described in the scope of the claims at the beginning of the present application is added below.
[1] A method for converting non-stereoscopic three-dimensional (3D) content into stereoscopic 3D (S3D) content, in which an application program interface (API) call is intercepted and the non-stereoscopic view is obtained from the API call Determining a model view projection matrix for 3D content; modifying the model view projection matrix to generate a modified model view projection matrix; and based on the modified model view projection matrix, left view clipping coordinates Generating a right view clipping coordinate based on the modified model view projection matrix, generating a left view based on the left view clipping coordinate, and based on the right view clipping coordinate Generating the right view, the left view and the right view Rendering an S3D image based on.
[2] The method of claim 1, further comprising applying a viewport shift to the left view and applying a viewport shift to the right view.
[3] The amount of the viewport shift to the left view and the amount of the viewport shift to the right view are determined based on one or more user input parameters. The method described.
[4] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view determine the depth range for the scene of the previously generated image. The method of claim 2, wherein
[5] The method of claim 1, wherein modifying the model view projection matrix to generate the modified model view projection matrix comprises adding a constant to the model view projection matrix.
[6] The method of claim 5, wherein the constant is added to an element in a first row, a fourth column of the model view projection matrix.
[7] The method of claim 1, wherein the model view projection matrix is defined for the non-stereoscopic 3D content.
[8] The method of claim 1, further comprising receiving a system command, wherein the system command enables an operation mode in which 3D content is converted to S3D content.
[9] A value for the modified model view projection matrix used to generate the left view clipping coordinates is a value for the modified model view projection matrix used to generate the right view clipping coordinates; The method of claim 1, which is the same.
[10] Memory for storing instructions, a graphics processing unit (GPU), intercepting an application program interface (API) call when executing the instructions, and for non-stereoscopic 3D content from the API call Determining a model view projection matrix, modifying the model view projection matrix to generate a modified model view projection matrix, and providing the GPU with left view clipping coordinates based on the modified model view projection matrix. Generating a right view clipping coordinate based on the modified model view projection matrix; causing the GPU to generate a left view based on the left view clipping coordinate; and The right view based on the right view clipping coordinates And a processor operable to cause the GPU to render an S3D image based on the left view and the right view.
[11] The processor is further operable to cause the GPU to apply a viewport shift to the left view and to apply a viewport shift to the right view. The device described in 1.
[12] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view are determined based on one or more user input parameters. The device described.
[13] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view determine a depth range for the scene of the previously generated image. The apparatus of claim 11, wherein
[14] The apparatus of claim 10, wherein the processor modifies the model view projection matrix by adding a constant to the model view projection matrix.
[15] The apparatus of claim 14, wherein the constant is added to an element in a first row, a fourth column of the model view projection matrix.
[16] The apparatus of claim 10, wherein the model view projection matrix is defined for the non-stereoscopic 3D content.
[17] The method of claim 10, wherein the processor is further operable to perform receiving a system command, the system command enabling an operation mode in which 3D content is converted to S3D content. apparatus.
[18] A value for the modified model view projection matrix used to generate the left view clipping coordinates is a value for the modified model view projection matrix used to generate the right view clipping coordinates; The apparatus of claim 10, which is the same.
[19] An apparatus for converting non-stereoscopic three-dimensional (3D) content into stereoscopic 3D (S3D) content, means for intercepting an application program interface (API) call, and from the API call, Means for determining a model view projection matrix for the non-stereoscopic 3D content; means for modifying the model view projection matrix to generate a modified model view projection matrix; and the modified model view projection matrix Means for generating a left view clipping coordinate based on, a means for generating a right view clipping coordinate based on the modified model view projection matrix, and a left view based on the left view clipping coordinate And generating a right view based on the right view clipping coordinates. And means for rendering an S3D image based on the left view and the right view.
[20] The apparatus of claim 19, further comprising: means for applying a viewport shift to the left view; and means for applying a viewport shift to the right view.
[21] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view are determined based on one or more user input parameters. The device described.
[22] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view determine a depth range for the scene of the previously generated image. 21. The apparatus of claim 20, wherein:
[23] The apparatus of claim 19, wherein the means for modifying the model view projection matrix to generate the modified model view projection matrix comprises means for adding a constant to the model view projection matrix. .
[24] The apparatus of claim 23, wherein the means for adding the constant adds the constant to an element in a first row, a fourth column of the model view projection matrix.
[25] The apparatus of claim 19, wherein the model view projection matrix is defined for the non-stereoscopic 3D content.
[26] The apparatus of claim 19, further comprising means for receiving a system command, wherein the system command enables an operating mode in which 3D content is converted to S3D content.
[27] A value for the modified model view projection matrix used to generate the left view clipping coordinates is a value for the modified model view projection matrix used to generate the right view clipping coordinates; 20. The device according to claim 19, which is the same.
[28] When executed, intercepting an application program interface (API) call to one or more processors and determining a model view projection matrix for the non-stereoscopic 3D content from the API call. Modifying the model view projection matrix to generate a modified model view projection matrix, generating left view clipping coordinates based on the modified model view projection matrix, and adding the modified model view projection matrix to the modified model view projection matrix Generating a right view clipping coordinate, generating a left view based on the left view clipping coordinate, generating a right view based on the right view clipping coordinate, and the left view And rendering the S3D image based on the right view. A computer-readable storage medium storing instructions to be executed.
[29] Stored further instructions that when executed cause the one or more processors to apply a viewport shift to the left view and to apply a viewport shift to the right view A computer-readable storage medium according to claim 28.
[30] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view are determined based on one or more user input parameters. The computer-readable storage medium described.
[31] The amount for the viewport shift to the left view and the amount for the viewport shift to the right view determine the depth range for the scene of the previously generated image. 30. The computer readable storage medium of claim 29, determined as described above.
[32] The computer-readable storage medium of claim 28, wherein the one or more processors modify the model view projection matrix by adding a constant to the model view projection matrix.
[33] The computer-readable storage medium of claim 32, wherein the constant is added to an element in a first row, a fourth column of the model view projection matrix.
[34] The computer-readable storage medium of claim 28, wherein the model view projection matrix is defined for the non-stereoscopic 3D content.
[35] Stores further instructions that, when executed, cause the one or more processors to receive a system command, the system command allowing an operating mode in which 3D content is converted to S3D content 30. The computer readable storage medium of claim 28.
[36] A value for the modified model view projection matrix used to generate the left view clipping coordinates is a value for the modified model view projection matrix used to generate the right view clipping coordinates; 30. The computer readable storage medium of claim 28, which is the same.

Claims (28)

A method of converting non-stereoscopic 3D (3D) content into stereoscopic 3D (S3D) content,
Intercepting application program interface (API) calls;
Determining from the API call a model view projection matrix for the non-stereoscopic 3D content;
Shifting the model view projection matrix to generate a first modified model view projection matrix;
Shifting the model view projection matrix to generate a second modified model view projection matrix;
Generating left view clipping coordinates based on the first modified model view projection matrix;
Generating right view clipping coordinates based on the second modified model view projection matrix;
Generating a left view based on the left view clipping coordinates;
Generating a right view based on the right view clipping coordinates, wherein a viewing direction of the left view is parallel to a viewing direction of the right view;
Rendering an S3D image based on the left view and the right view;
Applying a first viewport shift to the left view;
Applying a second viewport shift to the right view . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view are determined based on one or more user input parameters. Item 2. The method according to Item 1 . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view determine the depth range for the scene of the previously generated image. particular basis is determined, the method according to claim 1.   Shifting the model view projection matrix to generate the first modified model view projection matrix comprises adding a first constant to the model view projection matrix, the second modified model view projection. The method of claim 1, wherein shifting the model view projection matrix to generate a matrix comprises adding a second constant to the model view projection matrix. The first constant is added to the elements in the first row and fourth column of the model view projection matrix, and the second constant is the first row and fourth column of the model view projection matrix. The method of claim 4 , wherein the method is added to the elements in.   The method of claim 1, wherein the model view projection matrix is defined for the non-stereoscopic 3D content.   The method of claim 1, further comprising receiving a system command, wherein the system command enables an operation mode in which 3D content is converted to S3D content. A memory for storing instructions;
A graphics processing unit (GPU);
When executing the instruction,
Intercepting application program interface (API) calls;
Determining a model view projection matrix for non-stereoscopic 3D content from the API call;
Shifting the model view projection matrix to generate a first modified model view projection matrix;
Shifting the model view projection matrix to generate a second modified model view projection matrix;
Causing the GPU to generate left view clipping coordinates based on the first modified model view projection matrix;
Causing the GPU to generate right view clipping coordinates based on the second modified model view projection matrix;
Causing the GPU to generate a left view based on the left view clipping coordinates;
Causing the GPU to generate a right view based on the right view clipping coordinates, wherein a viewing direction of the left view is parallel to a viewing direction of the right view;
Causing the GPU to render a stereoscopic 3D ( S3D ) image based on the left view and the right view ;
An apparatus comprising: a processor operable to apply a first viewport shift to the left view and a second viewport shift to the right view on the GPU . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view are determined based on one or more user input parameters. Item 9. The apparatus according to Item 8 . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view determine the depth range for the scene of the previously generated image. 9. The apparatus of claim 8 , wherein the apparatus is determined based on the above. The processor shifts the model view projection matrix to generate the first modified model view projection matrix by adding a first constant to the model view projection matrix, and the processor includes the model view projection matrix. 9. The apparatus of claim 8 , wherein the model view projection matrix is shifted to generate the second modified model view projection matrix by adding a second constant to the. The first constant is added to the elements in the first row and fourth column of the model view projection matrix, and the second constant is the first row and fourth column of the model view projection matrix. The apparatus of claim 11 , wherein the apparatus is added to the elements in. The apparatus of claim 8 , wherein the model view projection matrix is defined for the non-stereoscopic 3D content. The processor is
9. The apparatus of claim 8 , further operable to perform receiving a system command, wherein the system command enables an operation mode in which 3D content is converted to S3D content. An apparatus for converting non-stereoscopic 3D (3D) content into stereoscopic 3D (S3D) content,
Means for intercepting application program interface (API) calls;
Means for determining a model view projection matrix for the non-stereoscopic 3D content from the API call;
Means for shifting the model view projection matrix to generate a first modified model view projection matrix;
Means for shifting the model view projection matrix to generate a second modified model view projection matrix;
Means for generating left view clipping coordinates based on the first modified model view projection matrix;
Means for generating right view clipping coordinates based on the second modified model view projection matrix;
Means for generating a left view based on the left view clipping coordinates;
Means for generating a right view based on the right view clipping coordinates, wherein a viewing direction of the left view is parallel to a viewing direction of the right view;
Means for rendering an S3D image based on the left view and the right view;
Means for applying a first viewport shift to the left view;
Means for applying a second viewport shift to the right view . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view are determined based on one or more user input parameters. Item 15. The device according to Item 15 . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view determine the depth range for the scene of the previously generated image. 16. The apparatus of claim 15 , wherein the apparatus is determined based on the above. Means for shifting the model view projection matrix to generate the first modified model view projection matrix comprises means for adding a first constant to the model view projection matrix; The apparatus of claim 15 , wherein means for shifting the model view projection matrix to generate a modified model view projection matrix comprises means for adding a second constant to the model view projection matrix. The means for adding the first constant adds the first constant to an element in a first row and a fourth column of the model view projection matrix, and the second constant is added to the model. The apparatus of claim 18 , wherein the apparatus adds to the elements in the first row, fourth column of a view projection matrix. The apparatus of claim 15 , wherein the model view projection matrix is defined for the non-stereoscopic 3D content. 16. The apparatus of claim 15 , further comprising means for receiving a system command, wherein the system command enables an operating mode in which 3D content is converted to S3D content. When executed, one or more processors
Intercepting application program interface (API) calls;
Determining a model view projection matrix for non-stereoscopic 3D content from the API call;
Shifting the model view projection matrix to generate a first modified model view projection matrix;
Shifting the model view projection matrix to generate a second modified model view projection matrix;
Generating left view clipping coordinates based on the first modified model view projection matrix;
Generating right view clipping coordinates based on the second modified model view projection matrix;
Generating a left view based on the left view clipping coordinates;
Generating a right view based on the right view clipping coordinates ;
Before based on said right view and Kihidari views, and rendering a stereoscopic 3D (S3D) image,
Applying a first viewport shift to the left view;
A computer readable storage medium storing instructions for applying a second viewport shift to the right view . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view are determined based on one or more user input parameters. Item 23. The computer-readable storage medium according to Item 22 . The amount for the first viewport shift to the left view and the amount for the second viewport shift to the right view determine the depth range for the scene of the previously generated image. 23. The computer readable storage medium of claim 22 , wherein the computer readable storage medium is determined based on the above. The one or more processors shift the model view projection matrix by adding a first constant to the model view projection matrix and add a second constant to the model view projection matrix. 23. The computer readable storage medium of claim 22 , wherein the projection matrix is shifted. The first constant is added to the elements in the first row and fourth column of the model view projection matrix, and the second constant is the first row and fourth column of the model view projection matrix. 26. The computer readable storage medium of claim 25 , added to the elements in. 23. The computer readable storage medium of claim 22 , wherein the model view projection matrix is defined for the non-stereoscopic 3D content. When executed, the one or more processors include:
23. The computer-readable storage medium of claim 22 , storing further instructions that cause a system command to be received, wherein the system command enables an operating mode in which 3D content is converted to S3D content.

Images