KR101556835B1 - 셰이더 기반 그래픽 콘텐츠를 위한 입체 변환 - Google Patents

Abstract

본 개시물의 예의 기법들은 모노 뷰를 생성하도록 설계된 애플리케이션으로부터 입체 뷰를 생성하는 것을 위한 것이다. 예를 들어, 그 기법들은, 수정된 정점 셰이더가, 실행되는 경우, 입체 뷰의 이미지들을 위한 그래픽 콘텐츠를 생성하게, 정점 셰이더의 소스 코드를 수정할 수도 있다. 다른 예로서, 그 기법들은 모노 뷰를 위한 뷰포트를 정의하는 커맨드를, 입체 뷰의 이미지들을 위한 뷰포트들을 정의하는 커맨드로 수정할 수도 있다.

Description

셰이더 기반 그래픽 콘텐츠를 위한 입체 변환{STEREOSCOPIC CONVERSION FOR SHADER BASED GRAPHICS CONTENT}

본 출원은 2011년 3월 14일자로 출원된 미국가출원 제61/452,289호와 2011년 4월 12일자로 출원된 미국가출원 제61/474,638호를 우선권 주장하며, 각각의 내용들은 그것들 개개의 전부가 참조에 의해 본원에 통합된다.

기술 분야

본 개시물은 그래픽 데이터 프로세싱에 관한 것이고, 더 상세하게는, 입체 뷰를 위한 그래픽 데이터 프로세싱에 관한 것이다.

입체 뷰 (stereoscopic view) 는 3 차원 (3D) 볼륨을 이룬 것으로 보여지는 인식된 이미지를 말한다. 입체 뷰를 생성하기 위해, 디바이스는 디스플레이의 2 차원 (2D) 영역 상에 두 개의 이미지들을 디스플레이한다. 이들 두 개의 이미지들은 실질적으로 유사한 콘텐츠를 포함하지만, 두 개의 이미지들에서 하나 이상의 대응하는 화소들의 수평 축을 따라 약간의 변위를 가진다. 2D 영역에서의 이들 두 개의 이미지들의 동시 관람은, 관람자가 두 개의 이미지들을 디스플레이하고 있는 2D 디스플레이 밖으로 튀어나오거나 그 속으로 밀려들어간 이미지를 인식하게 한다. 이런 식으로, 두 개의 이미지들이 디스플레이의 2D 영역 상에 디스플레이됨에도 불구하고, 관람자는 3D 볼륨을 이룬 것으로 보이는 이미지를 인식한다.

입체 뷰의 두 개의 이미지들은 각각 왼쪽 눈 이미지 및 오른쪽 눈 이미지이라고 지칭된다. 왼쪽 눈 이미지는 관람자의 왼쪽 눈으로 볼 수 있고, 오른쪽 눈 이미지는 관람자의 왼쪽 눈으로 볼 수 없다. 마찬가지로, 오른쪽 눈 이미지는 관람자의 오른쪽 눈으로 볼 수 있고, 왼쪽 눈 이미지는 관람자의 오른쪽 눈으로 볼 수 없다. 예를 들어, 관람자는 안경의 좌측 렌즈가 오른쪽 눈 이미지를 차단하고 왼쪽 눈 이미지를 통과시키며 안경의 오른쪽 렌즈가 왼쪽 눈 이미지를 차단하고 오른쪽 눈 이미지를 통과시키는 특수 안경을 착용할 수도 있다.

왼쪽 눈 및 오른쪽 눈 이미지들이 수평 축을 따르는 약간의 변위를 갖는 실질적으로 유사한 콘텐츠를 포함하지만 (예컨대, 특수 안경 때문에) 관람자의 양쪽 모두의 눈들로는 동시에 볼 수 없기 때문에, 관람자의 뇌는 두 개의 이미지들을 합침으로써 대응하는 화소들 사이의 약간의 변위를 해결한다. 이 합침 (commingling) 은 관람자가 두 개의 이미지들을 3D 볼륨을 갖는 이미지로서 인식하게 한다.

대체로, 본 개시물의 기법들은 입체 뷰를 생성하기 위해 모노 뷰를 생성하는 명령들을 수정하는 것을 위한 것이다. 예를 들어, 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로그램은 모노 뷰를 생성하도록 설계될 수도 있다. 본 개시물에서 설명된 기법들은 이러한 셰이더 프로그램의 명령들을 수정할 수도 있다. 예를 들면, 예의 기법들은 셰이더 프로그램들에 의해 생성된 값들을 수정하는 명령들을 추가할 수도 있다. 그 기법들은 또한 모노 뷰 대신에 입체 뷰를 위한 이미지들을 GPU가 생성하게 하기 위해 애플리케이션에 의해 발행된 명령들을 수정할 수도 있다. 예를 들어, 본 개시물에서 설명된 기법들은 뷰포트 (viewport) 를 정의하는 커맨드들을 수정할 수도 있다. 뷰포트는 디스플레이 상의 이미지의 사이즈 및 로케이션을 정의할 수도 있다. 예를 들어, 수정 전에, 커맨드가 모노 뷰를 위한 뷰포트를 정의할 수도 있다. 예의 기법들은 입체 뷰의 이미지들의 각각을 위한 뷰포트를 정의하기 위해 모노 뷰를 위한 뷰포트를 정의하는 커맨드를 수정할 수도 있다.

하나의 예에서, 본 개시물은 모노 뷰의 이미지를 생성하도록 구성되고 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로세서 상에서 실행될 정점 셰이더 (vertex shader) 에 대한 명령들을, 프로세서를 이용하여, 수신하는 단계를 포함하는 방법을 설명한다. 그 방법은 또한, 정점 셰이더가, GPU의 셰이더 프로세서 상에서 실행되는 경우, 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 그리고 정점 셰이더의 제 2 실행 후에 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하도록 정점 셰이더의 명령들을 프로세서를 이용하여 수정하는 단계를 포함한다. 그 방법은 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를 프로세서를 이용하여, 제 1 이미지에 대한 뷰포트를 정의하는, 셰이더 프로세서와는 상이한 GPU의 고정 기능 유닛에 대한 제 1 커맨드, 및 제 2 이미지에 대한 뷰포트를 정의하는, GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정하는 단계를 더 포함한다.

다른 예에서, 본 개시물은 셰이더 프로세서 및 셰이더 프로세서와는 상이한, 고정 기능 파이프라인의 고정 기능 유닛을 구비한 그래픽 프로세싱 유닛 (GPU) 과, 프로세서를 포함하는 장치를 설명한다. 프로세서는, 모노 뷰의 이미지를 생성하도록 구성되고 GPU의 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하도록 동작가능하다. 그 프로세서는 또한, 정점 셰이더가, GPU의 셰이더 프로세서 상에서 실행되는 경우, 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 그리고 정점 셰이더의 제 2 실행 후에 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하게 정점 셰이더의 명령들을 수정하도록 동작가능하다. 그 프로세서는 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 제 1 이미지에 대한 뷰포트를 정의하는, 셰이더 프로세서와는 상이한 GPU의 고정 기능 유닛에 대한 제 1 커맨드, 및 제 2 이미지에 대한 뷰포트를 정의하는, GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정하도록 추가로 동작가능하다.

다른 예에서, 본 개시물은 셰이더 프로세서 및 셰이더 프로세서와는 상이한, 고정 기능 파이프라인의 고정 기능 유닛을 구비한 그래픽 프로세싱 유닛 (GPU) 과, 프로세서를 포함하는 장치를 설명한다. 프로세서는, 모노 뷰의 이미지를 생성하도록 구성되고 GPU의 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하는 수단을 포함한다. 그 프로세서는 또한, 정점 셰이더가, GPU의 셰이더 프로세서 상에서 실행되는 경우, 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 그리고 정점 셰이더의 제 2 실행 후에 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하도록 정점 셰이더의 명령들을 수정하는 수단을 포함한다. 그 프로세서는, 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 제 1 이미지에 대한 뷰포트를 정의하는, 셰이더 프로세서와는 상이한 GPU의 고정 기능 유닛에 대한 제 1 커맨드, 및 제 2 이미지에 대한 뷰포트를 정의하는, GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정하는 수단을 더 포함한다.

다른 예에서, 본 개시물은 명령들을 포함하는 비일시적 컴퓨터 판독가능 저장 매체를 설명한다. 그 명령들은, 실행되는 경우, 하나 이상의 프로세서들로 하여금, 모노 뷰의 이미지를 생성하도록 구성되고 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하도록 한다. 그 프로세서는 또한 하나 이상의 프로세서들로 하여금, 정점 셰이더가, GPU의 셰이더 프로세서 상에서 실행되는 경우, 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 그리고 정점 셰이더의 제 2 실행 후에 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하게 정점 셰이더의 명령들을 수정하도록 동작가능하다. 그 명령들은 또한 하나 이상의 프로세서들로 하여금, 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 제 1 이미지에 대한 뷰포트를 정의하는, 셰이더 프로세서와는 상이한 GPU의 고정 기능 유닛에 대한 제 1 커맨드, 및 제 2 이미지에 대한 뷰포트를 정의하는, GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정하도록 한다.

본 개시물의 하나 이상의 양태들의 상세는 첨부 도면들 및 다음의 설명에서 언급된다. 본 개시물의 다른 특징들, 목적들, 및 이점들은 상세한 설명 및 도면들로부터, 그리고 청구항들로부터 명확하게 될 것이다.

도 1은 본 개시물에서 설명되는 하나 이상의 예의 기법들을 구현할 수도 있는 디바이스의 일 예를 도시하는 블록도이다.
도 2는 본 개시물에서 설명되는 하나 이상의 예의 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 일 예를 도시하는 블록도이다.
도 3은 도 1의 예의 디바이스를 더 상세히 도시하는 블록도이다.
도 4는 본 개시물에서 설명되는 하나 이상의 예의 기법들에 따른 일 예의 동작을 도시하는 흐름도이다.

본 개시물에서 설명되는 예의 기법들은 실행 또는 런 타임 동안에 입체 3 차원 (stereoscopic 3-dimensional; S3D) 그래픽들을 랜더링하는 것에 관한 것이다. 기존의 3D 그래픽 랜더링에서, 그래픽 프로세싱 유닛 (GPU) 은 단일 시점 (예컨대, 모노 뷰) 에서 3D 그래픽들을 생성한다. 이 단일 시점은 관람자의 오른쪽 눈 및 왼쪽 눈 양쪽 모두로 볼 수 있는 단일 이미지를 의미할 수도 있다.

S3D 그래픽은 S3D 그래픽이 입체 뷰를 생성한다는 점에서 3D 그래픽과는 상이하다. 용어 입체 뷰는 양안 시점 (binocular point of view) 에서 생성되는 이미지들을 말한다. 양안 시점에서, 하나의 이미지가 눈들 중 하나로 볼 수 있고 다른 하나로는 볼 수 없고, 그 반대로도 마찬가지인 두 개의 이미지들이 있을 수도 있다. 예를 들어, 관람자가 쌍안경을 착용한 경우, 쌍안경에 대해 좌측 렌즈를 통해 들어오는 광은 왼쪽 눈으로 볼 수 있지만 오른쪽 눈으로는 볼 수 없고, 그 반대의 경우도 마찬가지이다. 양안 시점은 입체 뷰라고 지칭될 수도 있다.

예를 들어, S3D 그래픽에서, GPU는 왼쪽 눈을 위한 이미지 및 오른쪽 눈을 위한 다른 이미지, 즉, 입체 뷰를 생성할 수도 있다. 용어 입체 뷰는 디스플레이 상에서 각각 디스플레이되는 두 개의 이미지들 (예컨대, 왼쪽 눈 이미지 및 오른쪽 눈 이미지) 을 말하는 반면, 모노 뷰는 디스플레이 상에서 디스플레이되는 단일 이미지를 말한다. 왼쪽 눈 이미지 및 오른쪽 눈 이미지의 조합은 이미지가 이미지들을 디스플레이하고 있는 디스플레이 밖으로 튀어나오거나 또는 그 속으로 밀려들어간 것처럼 관람자에게 보일 수도 있다. 이는 더 사실적이고 풍부한 관람 경험을 하게 할 수도 있다.

본 개시물에서, S3D 이미지 (예컨대, 입체 뷰) 및 3D 이미지 (예컨대, 모노 뷰) 의 개념이 혼동되지 않아야 한다. 3D 이미지는 디스플레이의 2 차원 (2D) 영역으로 제한되는 이미지이다. 예를 들면, 3D 이미지 내의 오브젝트들은 3D 이미지 내의 다른 오브젝트들보다 더 멀리 또는 더 가까이에 있는 것처럼 보일 수도 있다. 그러나, 이들 오브젝트들의 모두는 디스플레이의 2D 영역으로 제한된다. S3D 이미지는 관람자의 뇌가 오른쪽 눈 및 왼쪽 눈 이미지들을 조합한 결과로 인식된 이미지이다. 결과적인 이미지 (즉, S3D 이미지) 는 디스플레이의 2D 영역으로 제한되지 않은 것처럼 보인다. 오히려, S3D 이미지는 이미지가 디스플레이 밖으로 튀어나오거나 또는 그 속으로 밀려들어가는 것으로 보이는 3D 볼륨을 완성한 것처럼 보인다. 예를 들면, S3D 이미지 내의 오브젝트들은 3D 볼륨 내의 다른 오브젝트들보다 멀리 있거나 또는 더 가까이 있는 것처럼 보이고, 3D 이미지들의 경우처럼 2D 영역으로 보이지 않는다.

S3D 이미지를 함께 형성하는 오른쪽 눈 및 왼쪽 눈 이미지들은, 3D 이미지들일 수도 있다. 관람자의 뇌는 그 뇌가 3D 오른쪽 눈 이미지 및 3D 왼쪽 눈 이미지를 조합하는 경우에 관람자가 S3D 이미지를 인식하게 한다. 오른쪽 눈 이미지 및 왼쪽 눈 이미지들의 내용은 단일 3D 이미지의 콘텐츠와 실질적으로 유사할 수도 있다. 본 개시물에서 설명된 기법들은 GPU가 모노 뷰를 위한 그래픽 콘텐츠를 생성하게 하는 명령들을 GPU가 입체 뷰를 위한 그래픽 콘텐츠를 생성하게 하는 명령들로 수정할 수도 있다. 다르게 말하면, 수정 전에, 그 명령들은 GPU가 단일 3D 이미지를 생성하게 할 수도 있다. 수정에 후속하여, 명령들은 GPU가 두 개의 3D 이미지들 (예컨대, 3D 왼쪽 눈 이미지 및 3D 오른쪽 눈 이미지) 을 생성하게 할 수도 있다.

본 개시물에서 설명된 기법들이 3D 이미지들을 위해 일반적으로 개시되지만 본 개시물의 양태들은 그렇게 제한되지 않는다는 것에 주의해야 한다. 본 개시물의 기법들은 2D 그래픽로도 확장될 수도 있다. 예를 들어, 모노 뷰의 단일 이미지는 2D 이미지일 수도 있고, 본 개시물의 기법들은 입체 뷰를 위한 두 개의 2D 이미지들을 GPU가 생성하게 하기 위해 명령들을 수정할 수도 있다. 이 경우, 관람자는 입체 뷰를 위한 두 개의 이미지들을 디스플레이하고 있는 디스플레이 밖으로 튀어나오거나 그 속으로 밀려들어간 단일 이미지를 인식할 것이다. 혼동을 피하기 위해, 아래에서 설명되는 기법들은 모노 뷰를 위한 단일 이미지와, 입체 뷰를 위한 왼쪽 눈 및 오른쪽 눈 이미지들을 언급하며, 이들 이미지들이 3D 이미지들 또는 2D 이미지들일 수 있다고 이해한다.

본 개시물에서 설명되는 예의 기법들은 GPU에 의해 수행될 것들인 애플리케이션에 의해 발행된 명령들과 GPU에 의해 실행될 정점 셰이더 프로그램의 명령들을 수정할 수도 있다. 예를 들어, 애플리케이션 프로세서는 애플리케이션을 실행할 수도 있다. 애플리케이션은 단일 이미지 (예컨대, 모노 뷰) 를 생성하도록 설계되어 있을 수도 있고, 복수의 프리미티브들 (primitives) 로서 단일 이미지의 그래픽 콘텐츠를 생성할 수도 있다. 덧붙여서, 애플리케이션은 프리미티브들의 각각의 정점에 대해 화소 값들, 이를테면 컬러, 투명도, 및 좌표 값들을 결정할 수도 있다.

애플리케이션의 실행 동안 (예컨대, 런 타임에서), 애플리케이션은 정점 셰이더 프로그램의 명령들을 취출하는 커맨드를 발행한다. 정점 셰이더 프로그램의 출력은, 실행되는 경우, 단일 이미지 (예컨대, 모노 뷰) 에 대해 애플리케이션에 의해 생성된 프리미티브들의 정점들에 대한 클리핑 좌표들일 수도 있다. 예의 기법들은 왼쪽 눈 이미지 및 오른쪽 눈 이미지 (예컨대, 입체 뷰) 를 위한 프리미티브들의 정점들에 대한 클리핑 좌표들을 생성하기 위해 정점 셰이더 프로그램의 명령들을 수정할 수도 있다.

또한, 애플리케이션의 실행 동안, 애플리케이션은 GPU가 단일 이미지 내의 프리미티브들 중 하나 이상을 그릴 것을 지시하기 위해 그리기 명령을 GPU로 발행한다. 예를 들면, 본 개시물의 기법들에서, 애플리케이션 프로세서 상에서 실행중인 애플리케이션은 GPU가 단일 이미지에 대한 그래픽 콘텐츠를 생성하려는 것처럼 명령들을 출력한다. 본원에서 설명되는 기법들은 왼쪽 눈 및 오른쪽 눈 이미지들을 위한 그래픽 콘텐츠를 생성하기 위해, 애플리케이션에 의해 발행된 명령들 중 하나 이상, 이를테면 그리기 명령을 수정한다. 이런 식으로, 애플리케이션의 측면에서 명령들에 대한 수정은 없다.

예를 들면, 본 개시물에서 설명된 기법들은 애플리케이션에 의해 발행된 명령들을 모니터링한다. 애플리케이션이 그리기 명령을 발행하는 경우, 기법들은 이러한 그리기 명령을 캡처하고, 하나의 명령이 왼쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하기 위한 것이고 하나의 명령이 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하기 위한 것인 두 개의 그리기 명령들을 발행한다.

덧붙여서, 그 기법들은 애플리케이션에 의해 발행된 뷰포트 명령을 수정한다. 예를 들어, 애플리케이션은 단일 이미지의 뷰포트를 정의하는 뷰포트 명령을 발행한다. 뷰포트는 디스플레이 상의 이미지의 사이즈 및 로케이션을 정의한다. 예를 들어, 뷰포트는 이미지의 시작 좌표들과, 이미지의 폭 및 길이를 정의할 수도 있다. 이미지의 폭 및 길이는 이미지에 의해 포함된 수평 거리 및 수직 거리를 나타내는 값들일 수도 있다. 그 폭 및 길이는 반드시 좌표 값들일 필요는 없고; 오히려, 그 폭 및 길이는 이미지의 시작 좌표들로부터 시작하는 거리를 정의한다. 애플리케이션은 단일 이미지에 대한 뷰포트의 정의를 GPU에 제공할 수도 있다.

본 개시물의 기법들은 디스플레이 상의 왼쪽 눈 및 오른쪽 눈 이미지들의 각각의 사이즈 및 로케이션을 정의하는, 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트 명령들을 생성하기 위해 뷰포트 명령을 수정한다. 이런 식으로, 수정된 뷰포트 명령은 왼쪽 눈 이미지를 디스플레이의 하나의 부분으로, 그리고 오른쪽 눈 이미지를 디스플레이의 다른 부분으로 제한할 수도 있다. 일부 예들에서, 수정된 뷰포트 명령은 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로, 그리고 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한할 수도 있다. 그러나, 본 개시물의 양태들은 그렇게 제한되지 않고, 다른 비제한적 예로서, 수정된 뷰포트 명령은 왼쪽 눈 이미지를 디스플레이의 상부 절반으로, 그리고 오른쪽 눈 이미지를 디스플레이의 하부 절반으로 제한할 수도 있다. 일부 경우들에서, 예의 기법들은 잠정적으로 양호한 관람 경험을 제공하기 위해 오른쪽 눈 이미지 및 왼쪽 눈 이미지에 대한 뷰포트들을 추가로 수정할 수도 있다. 예를 들어, 그 기법들은 오른쪽 눈 이미지 및 왼쪽 눈 이미지에 대한 뷰포트들을 시프트 또는 스트레치할 수도 있다.

뷰포트를 수정하는 명령들은 셰이더 프로그램을 수정하는 명령들의 부분이 아닐 수도 있다. 예를 들어, GPU는 셰이더 코어라고 종종 지칭되는 셰이더 프로세서, 및 하나 이상의 고정 기능 유닛들을 포함할 수도 있다. 정점 셰이더 프로그램은 셰이더 프로세서 상에서 실행될 수도 있고, 이미지를 정의된 뷰포트로 제한하기 위한 뷰포트의 애플리케이션은 고정 기능 유닛들 중 적어도 하나 (예컨대, 고정 기능 유닛들 중 뷰포트 변환 유닛) 에 의해 수행될 수도 있다. 예의 기법들에서, 셰이더 프로세서는 입체 뷰를 위한 그래픽 콘텐츠를 생성하기 위해 수정된 셰이더 프로그램을 실행할 수도 있고, 적어도 하나의 고정 기능 유닛은 이들 이미지들을 디스플레이의 개별 절반들로 제한하기 위해 정의된 뷰포트를 왼쪽 눈 및 오른쪽 눈 이미지들의 각각에 적용할 수도 있다. 다르게 말하면, 뷰포트 수정은 수정된 셰이더 프로그램의 실행 외부에서 일어날 수도 있다.

도 1은 본 개시물에서 설명되는 하나 이상의 예의 기법들을 구현할 수도 있는 디바이스의 일 예를 도시하는 블록도이다. 예를 들면, 도 1은 디바이스 (10) 를 예시한다. 디바이스 (10) 의 예들은, 모바일 무선 전화기들, 개인휴대 정보단말들 (PDAs), 비디오 디스플레이들을 구비한 비디오 게이밍 콘솔들, 모바일 비디오 회의 유닛들, 랩톱 컴퓨터들, 데스크톱 컴퓨터들, 텔레비전 셋톱 박스들, 디지털 미디어 플레이어들, 스마트폰들 등을 포함하지만 그것들로 제한되지는 않는다. 도 1에 예시된 바와 같이, 디바이스 (10) 는 애플리케이션 프로세서 (12), 그래픽 프로세싱 유닛 (GPU) (20), 및 시스템 메모리 (26) 를 구비할 수도 있다. 디바이스 (10) 는 도 1에 예시된 것들 외의 컴포넌트들을 구비할 수도 있다. 이들 컴포넌트들은 명료함을 위해 도 1에 도시되진 않았고, 도 3에서 추가로 예시된다.

애플리케이션 프로세서 (12) 는 디바이스 (10) 의 중앙 처리 유닛 (CPU) 일 수도 있다. GPU (20) 는 디스플레이 상의 프레젠테이션을 위한 그래픽 데이터를 출력하도록 동작가능한 프로세싱 유닛일 수도 있다. 애플리케이션 프로세서 (12) 및 GPU (20) 의 예들은, 디지털 신호 프로세서 (DSP), 범용 마이크로프로세서, 주문형 집적회로 (ASIC), 필드 프로그램가능 로직 어레이 (FPGA), 또는 기타 동등한 집적 또는 개별 로직 회로를 포함하지만 그것들로 제한되지는 않는다.

시스템 메모리 (26) 는 컴퓨터 판독가능 저장 매체의 일 예일 수도 있다. 예를 들어, 시스템 메모리 (26) 는 애플리케이션 프로세서 (12) 및 GPU (20) 로 하여금 본 개시물에서 각각에 주어진 기능들을 수행하게 하는 명령들을 저장할 수도 있다. 이런 식으로, 시스템 메모리 (26) 는 하나 이상의 프로세서들, 예컨대, 애플리케이션 프로세서 (12) 또는 GPU (20) 로 하여금, 다양한 기능들을 수행하게 하는 명령들을 포함하는 컴퓨터 판독가능 저장 매체로서 간주될 수도 있다.

시스템 메모리 (26) 의 예들은, 랜덤 액세스 메모리 (RAM), 판독 전용 메모리 (ROM), 전기 소거가능 프로그램가능 판독 전용 메모리 (EEPROM), CD-ROM 또는 다른 광 디스크 스토리지, 자기 디스크 스토리지, 또는 다른 자기 저장 디바이스들, 플래시 메모리, 또는 소망의 프로그램 코드를 명령들 또는 데이터 구조들의 형태로 운반하거나 저장하는데 사용될 수 있고 컴퓨터 또는 프로세서에 의해 액세스될 수 있는 임의의 다른 매체를 포함하지만 그것들로 제한되지는 않는다. 시스템 메모리 (26) 는, 일부 예들에서, 비일시적 저장 매체로서 간주될 수도 있다. 용어 "비일시적 (non-transitory)"은 저장 매체가 반송파 또는 전파되는 신호로 실시되지 않음을 나타낼 수도 있다. 그러나, 용어 "비일시적"은 시스템 메모리 (26) 가 이동가능하지 않은 것을 의미하도록 해석되지 않아야 한다. 하나의 예로서, 시스템 메모리 (26) 는 디바이스 (10) 로부터 제거되고, 다른 디바이스로 이동될 수도 있다. 다른 예로서, 시스템 메모리 (26) 에 실질적으로 유사한 저장 디바이스는, 디바이스 (10) 속에 삽입될 수도 있다. 특정 예들에서, 비일시적 저장 매체는 (예컨대, RAM 내에서) 시간 경과에 따라 변화할 수 있는 데이터를 저장할 수도 있다.

GPU (20) 는 셰이더 프로세서 (22) 및 고정 기능 파이프라인 (24) 을 구비할 수도 있다. 셰이더 코어라고 때때로 지칭되는 셰이더 프로세서 (22) 는, 정점 셰이더들 및 프래그먼트 셰이더들과 같은 셰이더 프로그램들이 실행될 GPU (20) 의 코어일 수도 있다. 고정 기능 파이프라인 (24) 은 고정된 기능들을 수행하는 하드웨어 유닛들을 구비할 수도 있다. 다르게 말하면, 정점 셰이더들 및 프래그먼트 셰이더들과 같은 셰이더 프로그램들은 셰이더 프로세서 (22) 상에서 실행되고 기능적 유연성을 허용하는 소프트웨어 유닛들일 수도 있지만, 고정 기능 파이프라인 (24) 은 고정된 기능들 및 최소 기능적 유연성을 갖는 하드웨어 유닛들을 포함한다.

본 개시물에서 설명되는 예의 기법들은 (예컨대, 모노 뷰를 위한) 단일 3 차원 (3D) 이미지를 생성하도록 설계되는 셰이더 프로그램들을 수정할 수도 있어서, 수정된 셰이더 프로그램들이 셰이더 프로세서 (22) 상에서 실행되는 경우, GPU (20) 는 S3D 이미지들 (예컨대, 입체 뷰) 을 위한 그래픽 데이터를 생성한다. 다시, 위에서 논의된 바와 같이, 입체 뷰는 왼쪽 눈 이미지와 오른쪽 눈 이미지를 포함한다. 왼쪽 눈 이미지와 오른쪽 눈 이미지는 모노 뷰 이미지와 실질적으로 유사한 그래픽 콘텐츠를 포함한다; 그러나, 왼쪽 눈 및 오른쪽 눈 이미지들의 하나 이상의 대응하는 화소들은 서로에 대해 수평 축을 따라 변위될 수도 있다. 예를 들어, 오른쪽 눈 이미지가 왼쪽 눈 이미지의 상단에 위치된다고 상상한다. 이 경우, 오른쪽 눈 이미지에서의 콘텐츠의 모두는 왼쪽 눈 이미지에서의 동일한 콘텐츠와 완전히 일렬로 되지 않을 수도 있다. 오히려, 오른쪽 눈에서의 하나 이상의 오브젝트들은 왼쪽 눈 이미지에서의 동일한 오브젝트들의 왼쪽 또는 오른쪽에 있을 수도 있다.

왼쪽 눈 이미지는 관람자의 왼쪽 눈으로 볼 수 있고, 오른쪽 눈 이미지는 관람자의 왼쪽 눈으로부터 차단된다. 오른쪽 눈 이미지는 관람자의 오른쪽 눈으로 볼수 있고, 왼쪽 눈 이미지는 관람자의 오른쪽 눈으로부터 차단된다. 일부 예들에서, 관람자는 왼쪽 눈 이미지를 오른쪽 눈으로 볼 수 있게 되는 것으로부터 그리고 오른쪽 눈 이미지를 왼쪽 눈으로부터 볼 수 있게 되는 것으로부터 차단하는 특수 안경을 착용할 수도 있다. 그러나, 본 개시물의 양태들은 관람자가 특수 안경을 착용하는 것을 필요로 하지 않을 수도 있다. 예를 들어, 일부 디스플레이들은 입체 뷰를 경험하기 위해 관람자가 특수 안경을 착용하는 것을 필요로 하지 않는다. 본 개시물의 기법들은 이러한 디스플레이들로 확장될 수도 있다.

GPU (20) 는, 관람자가 왼쪽 눈 이미지 및 오른쪽 눈 이미지 양쪽 모두를 동시에 보는 경우 관람자의 뇌는 두 개의 이미지들을 디스플레이하는 디스플레이 밖으로 튀어나오거나 디스플레이 속으로 밀려들어간 (예컨대, 디스플레이 앞 또는 뒤에 있는 것으로 보이는) 이미지를 관람자가 인식하게 하도록, 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 그래픽 데이터를 생성할 수도 있다. 이 밖으로 튀어나옴 또는 속으로 밀려들어감은 관람자의 뇌가 입체 뷰의 두 개의 이미지들의 실질적으로 유사한 콘텐츠와의 수평 불일치들을 해소하기 때문이다.

일 예로서, 애플리케이션 프로세서 (12) 는 시스템 메모리 (26) 에 저장된 하나 이상의 애플리케이션들, 이를테면 애플리케이션 (32) 을 실행할 수도 있다. 애플리케이션 (32) 의 예들은, 웹 브라우저들, 사용자 인터페이스들, 이메일 애플리케이션들, 스프레드시트 애플리케이션들, 워드 프로세싱 애플리케이션들, 그래픽 저작 (authoring) 애플리케이션들, 비디오 게임들, 또는 디스플레이를 위한 가시 (viewable) 오브젝트들을 생성하는 다른 애플리케이션들을 포함하지만 그것들로 제한되지는 않는다. 예를 들면, 애플리케이션 (32) 은 실행되는 경우 디스플레이 상에 디스플레이되는 그래픽 콘텐츠를 출력하는 비디오 게임일 수도 있다.

애플리케이션 (32) 은 모노 뷰를 위해 개발자에 의해 설계될 수도 있다. 예를 들어, 애플리케이션 (32) 은, 실행 시, 3D 그래픽 콘텐츠가 디스플레이의 2D 영역으로 제한되는 3D 그래픽 콘텐츠를 생성할 수도 있다. 애플리케이션 (32) 은, 애플리케이션 프로세서 (12) 상에서의 실행 시, 생성된 3D 그래픽 콘텐츠를 삼각형들, 직사각형들, 또는 다른 유형들의 다각형들과 같은 프리미티브들로 분할할 수도 있다. 이들 프리미티브들의 각각은 디스플레이 상에 디스플레이될 화소들을 포함할 수도 있다. 애플리케이션 (32) 은, 애플리케이션 프로세서 (12) 상에서의 실행 시, 또한 화소 값들을 프리미티브들의 정점들의 각각에 할당할 수도 있다. 예를 들어, 화소 값들은 정점들의 3D 좌표들, 정점들의 컬러 값들, 및 정점들의 투명도 값들을 포함할 수도 있다. 화소 값들은 본 개시물의 모든 양태에서 위의 예의 성분들의 모두를 포함할 필요는 없다.

애플리케이션 프로세서 (12) 는 그 다음에 정점들에 대한 화소 값들을 추가의 프로세싱을 위해 GPU (20) 로 포워딩할 수도 있다. 예를 들어, 애플리케이션 프로세서 (12) 는 그래픽 드라이버 (14) 를 구비할 수도 있으며, 그 드라이버는 애플리케이션 프로세서 (12) 상에서 실행되는 소프트웨어일 수도 있다. 그래픽 드라이버 (14) 는 커맨드들을 GPU (20) 로 송신하도록 설계될 수도 있고, 응답하여, GPU (20) 는 수신된 커맨드들에 따라 기능들을 수행할 수도 있다. 예를 들어, 그래픽 드라이버 (14) 는 GPU (20) 및 애플리케이션 프로세서 (12) 사이의 인터페이스로서 기능을 한다. 애플리케이션 프로세서 (12) 가 GPU (20) 로 커맨드를 발행하는 경우, 그래픽 드라이버 (14) 를 통하여 GPU (20) 가 커맨드를 수신한다. 예를 들면, 애플리케이션 (32) 은, 애플리케이션 프로세서 (12) 상에서 실행되면, GPU (20) 에게 특정 태스크를 수행할 것을 지시할 수도 있다. 이 경우, 그래픽 드라이버 (14) 는 특정 태스크에 대해 애플리케이션 (32) 으로부터 명령을 수신할 수도 있고, 그 명령을 GPU (20) 에 제공할 수도 있다. 응답하여, GPU (20) 는 그 태스크를 수행할 수도 있다.

일부 예들에서, 그래픽 드라이버 (14) 는 특정 애플리케이션 프로그래밍 인터페이스 (API) 에 따라 설계될 수도 있다. 예를 들어, 그래픽 드라이버 (14) 는 크로노스 그룹 (Khronos Group) 의 API들인 OpenGL 또는 OpenGL ES (내장형 시스템) API들에 따라 설계될 수도 있고, 그것들의 사양들은 공개적으로 입수가능하다. 그러나, 본 개시물의 기법들은 마이크로소프트 DirectX 시스템, 이를테면 DirectX 9, 10, 또는 11, 또는 임의의 다른 셰이더 기반 그래픽 시스템 및 API들로 확장가능할 수도 있다. 예시의 목적을 위해, 본 개시물의 기법들은 API가 OpenGL ES 2.0 API인 상황에서 설명된다. 그러나, 본 개시물의 양태들은 그렇게 제한되지 않고, 다른 API들 또는 셰이더 기반 그래픽 시스템들로 확장될 수 있다.

애플리케이션 프로세서 (12) 로부터 수신된 프리미티브들을 랜더링하기 위해, GPU (20) 의 셰이더 프로세서 (22) 는 정점 셰이더들 및 프래그먼트 셰이더들과 같은 하나 이상의 셰이더 프로그램들을 실행하여 디스플레이의 화소들에 대한 화소 값들을 생성할 수도 있다. 개발자가 이들 정점 셰이더들 및 프래그먼트 셰이더들을 API, 이를테면 예시의 목적을 위해 본 개시물에서 이용되는 OpenGL ES 2.0 API에 따라 개발할 수도 있다. 이들 정점 및 프래그먼트 셰이더들에 대한 소스 코드는 시스템 메모리 (26) 에 저장될 수도 있다.

예를 들어, 애플리케이션 (32) 은, 모노 뷰를 생성하도록 설계될 수도 있는 정점 셰이더 (28) 를 활용할 수도 있다. 예를 들면, 애플리케이션 (32) 에 의해 생성된 화소 값들은 정점 셰이더 (28) 를 사용하여 셰이더 프로세서 (22) 에 의해 처리되는 것을 필요로 할 수도 있다. 하나의 예로서, 정점 셰이더 (28) 는 특히 애플리케이션 프로세서 (12) 상의 애플리케이션 (32) 의 실행 동안에 애플리케이션 (32) 에 의해 호출된 정점 셰이더일 수도 있다. 정점 셰이더 (28) 는 GPU (20) 의 셰이더 프로세서 (22) 상에서 실행될 수도 있고, 애플리케이션 (32) 은 애플리케이션 프로세서 (12) 상에서 실행될 수도 있지만, 정점 셰이더 (28) 및 애플리케이션 (32) 은 애플리케이션 (32) 에 의해 생성된 이미지들을 디스플레이할 목적을 위해 서로 관련될 수도 있다.

정점 셰이더 (28) 의 소스 코드는 시스템 메모리 (26) 내에 저장될 수도 있다. 그래픽 드라이버 (14) 는 정점 셰이더 (28) 의 소스 코드를 취출하고 정점 셰이더 (28) 에 대한 소스 코드를 컴파일러 (18) 로 제공할 수도 있다. 컴파일러 (18) 는 정점 셰이더 (28) 의 소스 코드를 컴파일하여 정점 셰이더 (28) 의 오브젝트 코드를 생성하고, 그 오브젝트 코드를 시스템 메모리 (28) 에 저장할 수도 있다. 그래픽 드라이버 (14) 는 그 다음에 시스템 메모리 (26) 로부터 정점 셰이더 (28) 의 오브젝트 코드를 취출할 것을 GPU (20) 에 지시하고, 셰이더 프로세서 (22) 상에서 정점 셰이더 (28) 의 오브젝트 코드를 실행할 것을 GPU (20) 에 지시할 수도 있다. 셰이더 프로세서 (22) 는 그 다음에 애플리케이션 (32) 의 실행에 의해 생성된 정점들에 대한 화소 값들을 처리하기 위해 정점 셰이더 (28) 의 오브젝트 코드를 실행할 수도 있다. GPU (20) 는, 고정 기능 파이프라인 (24) 및 셰이더 프로세서 (22) 와 연계하여, 디스플레이를 위해 애플리케이션 (32) 에 대한 그래픽 콘텐츠를 생성할 수도 있다.

시스템 메모리 (26) 가 하나의 정점 셰이더 (28) 만을 위한 소스 코드를 저장하는 것으로 보이고 있지만, 본 개시물의 양태들은 그렇게 제한되지 않는다. 예를 들어, 애플리케이션 (32) 은 다수의 상이한 정점 셰이더들을 어쩌면 활용할 수도 있고, 이들 정점 셰이더들의 각각에 대한 소스 코드는 시스템 메모리 (26) 에 저장될 수도 있다. 또한, 애플리케이션 (32) 은 정점 셰이더 (28) 의 다수의 인스턴스화물들 (instantiations) 의 실행을 요구할 수도 있다. 예를 들어, 셰이더 프로세서 (22) 는, 정점 셰이더 (28) 의 각각의 인스턴스화물이 실질적으로 유사한 기능들을 수행하지만 상이한 화소 값들에 대해 수행하는, 정점 셰이더 (28) 의 다수의 인스턴스화물들을 동시에 (예컨대, 병렬로) 실행할 수도 있다. 시스템 메모리 (26) 는 프래그먼트 셰이더들에 대한 소스 코드를 유사하게 저장할 수도 있다. 그래픽 드라이버 (14) 는 프래그먼트 셰이더들에 대한 소스 코드를 취출할 수도 있고, 컴파일러 (18) 는 정점 셰이더 (28) 에 대해 위에서 설명된 것과 유사한 방식으로 프래그먼트 셰이더들에 대한 오브젝트 코드를 생성하기 위해 소스 코드를 컴파일할 수도 있다.

더 상세히 설명될 바와 같이, 본 개시물의 하나 이상의 예의 기법들은 정점 셰이더 (28) 의 소스 코드를 컴파일하기 전에 수정할 수도 있다. 컴파일러 (18) 는 수정된 소스 코드를 컴파일하여 수정된 정점 셰이더 (30) 의 오브젝트 코드를 생성할 수도 있다. 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행할 수도 있으며, 이는 GPU (20) 가 입체 3D 그래픽 콘텐츠 (예컨대, S3D의 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 그래픽 콘텐츠) 를 생성하게 할 수도 있다. 그러나, 정점 셰이더 (28) 의 소스 코드에 대한 수정을 설명하기 전에, 다음에서는 정점 셰이더 (28) 의 소스 코드에 적용되는 수정의 이해를 도울 수도 있는 예의 정점 셰이더 (28) 의 기능을 설명한다.

위에서 설명된 바와 같이, 애플리케이션 (32) 은 프리미티브들의 정점들에 대한 좌표들을 생성할 수도 있다. 이들 좌표들은 월드 좌표들이라고 지칭될 수도 있고, 애플리케이션 (32) 에 특정될 수도 있다. 다르게 말하면, 정점들의 좌표들은, 애플리케이션 (32) 에 의해 정의된 바와 같이, 프리미티브들이 반드시 디스플레이되는 디스플레이의 좌표들일 필요는 없을 수도 있고, 또한 어쩌면 가시 영역 밖에 있는 정점들에 대한 좌표들일 수도 있다. 정점 셰이더 (28) 는 3D로 있을 수도 있는 월드 좌표들을 디스플레이의 2D 좌표들 (예컨대, 디스플레이 좌표들) 로 변환하도록 설계될 수도 있다. 이 기능을 수행하기 위해, 정점 셰이더 (28) 는 월드 좌표들을 눈 좌표들로 변환한 다음, 클리핑 좌표들로 변환할 수도 있다. 예를 들어, 정점 셰이더 (28) 의 출력은, 실행되는 경우, 정점들의 클리핑 좌표들일 수도 있다. 최종 디스플레이 좌표들, 예컨대, 디스플레이의 좌표들은, 그 뒤에 고정 기능 파이프라인 (24) 의 부분으로서 결정될 수도 있다.

클리핑 좌표들은 뷰 프루스텀(frustum) 을 정의할 수도 있다. 뷰 프루스텀은 3D 그래픽 콘텐츠의 가시 영역을 정의할 수도 있다. GPU (20) 는 뷰 프루스텀 외부에 존재하는 화소들을 컬링 (culling) 하기 위해 뷰 프루스텀을 활용할 수도 있다. 예를 들어, 고정 기능 파이프라인 (24) 의 고정 기능 유닛 (예컨대, 고정 기능 파이프라인 (24) 의 프루스텀유닛) 은 정점 셰이더 (28) 에 의해 생성된 클리핑 좌표들에 의해 정의된 바와 같이, 뷰 프루스텀밖에 존재하는 화소들을 컬링할 수도 있다.

월드 좌표들로부터 클리핑 좌표들을 계산하기 위한 수학식은 다음과 같을 수도 있으며:

, (수학식 1)

여기서 Vclip 는 정점 클리프 좌표들이며, Veye 는 정점 눈 좌표들이며, Vworld 는 애플리케이션 (32) 에 의해 제공된 정점 월드 좌표들이며, PRJ 는 투영 행렬 (projection matrix) 이고, MVT 는 모델 뷰 변환 행렬 (또는 월드 뷰 변환 행렬) 이다. 일부 예들에서, PRJ 및 MVT 행렬들은 단일 행렬로 결합될 수도 있다. 그러나, 이해의 용이함을 위해, 이들 행렬들은 따로따로 설명된다.

투영 행렬 (PRJ) 및 모델 뷰, 또는 월드 뷰, 변환 행렬 (MVT) 은 API에 의해 정의될 수도 있다. 용어들인 모델 뷰 및 월드 뷰는 교환적으로 사용될 수도 있다. Vclip, Veye, 및 Vworld 는 네 개의 컴포넌트들 (예컨대, x, y, z, 및 w 좌표들) 을 포함할 수도 있다. 예를 들어, Vclip, Veye, 및 Vworld 는 다음과 같이 표현될 수도 있다:

,

,

(수학식 2)

OpenGL, OpenGL ES, 및 OpenGL ES 2.0 API들은, 프로그램가능 셰이더들과 함께, PRJ 행렬을 다음과 같이 정의한다:

(수학식 3)

여기서 L 및 R은 왼쪽 및 오른쪽 수직 클리핑 평면들에 대한 좌표들을 각각 특정하며, B 및 T는 각각 하부 및 상부 수평 클리핑 평면들에 대한 좌표들을 각각 특정하고, z_near 및 z_far 는 니어 및 파 깊이 클리핑 평면들에 대한 거리들을 각각 특정한다.

일부 예들에서, 클리핑 평면들은 대칭적일 수도 있다. 예를 들어, -L 은 R과 동일할 수도 있고, -B 는 T와 동일할 수도 있다. 이들 인스턴스들에서, PRJ 행렬은 다음과 같이 단순화될 수도 있다:

(수학식 4)

OpenGL, OpenGL ES, 및 OpenGL ES 2.0 API들은, 프로그램가능 셰이더들과 함께, MVT 행렬을 다음과 같이 정의한다:

(수학식 5)

PRJ 및 MVT 행렬들의 변수들의 모두는 애플리케이션 프로세서 (12) 상에서 실행되는 애플리케이션 (32) 에 의해 정의될 수도 있고, 그래픽 드라이버 (14) 는 이들 변수들을 정점 셰이더 (28) 의 오브젝트 코드를 실행하는 셰이더 프로세서 (22) 에 제공할 수도 있다. 수학식 1, 4, 및 5로부터 알 수 있듯이, 이들 변수들을 이용하여, 정점 셰이더 (28) 는 정점들의 각각에 대한 Vclip 좌표들을 결정할 수도 있다. GPU (20) 는 정점들에 대한 클립 좌표들을 활용하고, 고정 기능 파이프라인 (26) 및 프래그먼트 셰이더들의 기능에 연계하여, 추가의 기능을 수행하여, 디스플레이를 위해 이미지를 랜더링할 수도 있다. 이런 식으로, GPU (20) 는 애플리케이션 (32) 에 의해 생성된 그래픽 콘텐츠에 대해 모노 뷰를 생성할 수도 있다.

본 개시물의 기법들에 따라서, 정점 셰이더 (28) 가 Vclip 좌표들을 결정하기 위해 MVT 및 PRJ 행렬들에 대한 변수들을 활용할 수도 있지만, MVT 및 PRJ 행렬들은 입체 뷰를 생성하기 위해 정점 셰이더 (28) 의 소스 코드를 수정할 필요가 없을 수도 있다. 오히려, 본 개시물의 기법들은 입체 뷰 (예컨대, 왼쪽 눈 이미지 및 오른쪽 눈 이미지) 를 위한 클리핑 좌표들을 생성하기 위해, 모노 뷰를 위해 생성되는 클리핑 좌표들 (Vclip) 를 수정하는 명령들을 정점 셰이더 (28) 에 저장할 수도 있다.

위의 예는 모노 뷰를 위한 Vclip 좌표들을 결정하는 하나의 방법을 설명한다. 클리핑 좌표들을 계산하기 위한 많은 상이한 기법들이 있을 수도 있고, 일반적으로, 클리핑 좌표들을 계산하는데 활용되는 특정 기법이 중요하지 않을 수도 있다. 그러나, 여하튼, 3D 그래픽 콘텐츠에 대해, 클리핑 좌표들 (Vclip) 은 클리핑 좌표들을 계산하는데 이용되는 기법에 무관하게 계산되는 것이 필요할 수도 있다. 예를 들어, 심지어 애플리케이션 프로세서 (12) 가 클리핑 좌표들을 결정하는 것도 가능할 수도 있고, 그래픽 드라이버 (14) 는 그 클리핑 좌표들을 정점 셰이더 (28) 의 오브젝트 코드를 실행하는 셰이더 프로세서 (22) 에 제공할 수도 있다. 이 예에서, PRJ 및 MVT 행렬들은 단위 (unity) 행렬들일 수도 있다. 예를 들어, 애플리케이션 프로세서 (12) 는 수학식 1의 행렬 곱셈을 수행하고 그 결과들을 셰이더 프로세서 (22) 에 제공할 수도 있다. 이 예에서, 셰이더 프로세서 (22) 는 수신된 값들과 단위 행렬을 곱하여, 애플리케이션 (32) 에 의해 생성된 정점들의 각각에 대한 Vclip 좌표들을 생성할 수도 있다.

그러나, 어느 경우에나 (예컨대, 정점 셰이더 (28) 가 클리핑 좌표들을 결정하는 경우 또는 정점 셰이더 (28) 가 클리핑 좌표들을 수신하는 경우), 정점 셰이더 (28) 는 클리핑 좌표들을 저장하기 위해 특정 변수를 활용할 수도 있다. 특정 변수는 정점 셰이더 (28) 가 설계되는 API에 특별할 수도 있다. 예를 들어, 정점 셰이더 (28) 가 프로그램가능 셰이더들과 함께, OpenGL, OpenGL ES, 또는 OpenGL ES 2.0 API들에 따라 설계된다면, 정점 셰이더 (28) 는 gl_Position 변수 내에 클리핑 좌표들을 저장할 수도 있다. 유사한 변수가 다른 그래픽 API들에 있을 수도 있다. 예를 들면, 정점 셰이더 (28) 가 프로그램가능 셰이더들과 함께, OpenGL, OpenGL ES, 또는 OpenGL ES 2.0 API들에 따라 설계된다면, 정점 셰이더 (28) 는 gl_Position.x = x_clip, gl_Postion.y = y_clip, gl_Position.z = z_clip, 및 gl_Position.w = w_clip 과 같은 명령들을 포함할 수도 있으며, 여기서, 위의 수학식 2에서 나타낸 바와 같이,

이다.

본 개시물에서는 설명되는 하나 이상의 예의 기법들에서, 애플리케이션 프로세서 (12) 상에서 실행 중인 소프트웨어일 수도 있는 그래픽 드라이버 래퍼 (16) 는, 입체 뷰에 대한 클리핑 좌표들 (예컨대, 왼쪽 눈 이미지에 대한 클리핑 좌표들 및 오른쪽 눈 이미지에 대한 클리핑 좌표들) 을 정의하기 위해 모노 뷰에 대한 클리핑 좌표들을 정의하는 정점 셰이더 (28) 의 명령들을 수정할 수도 있다. 또한, 그래픽 드라이버 래퍼 (16) 는, 클리핑 좌표들을 정의하는 정점 셰이더 (28) 의 명령들을 수정하는 것 외에도, 입체 뷰를 위한 뷰포트들을 정의하기 위해 모노 뷰를 위한 뷰포트를 정의하는 명령들을 수정할 수도 있다.

용어 "뷰포트"는 디스플레이 상에서 이미지가 포함하는 영역을 말한다. 예를 들어, 애플리케이션 (32) 은 이미지를 디스플레이하는 디스플레이 상의 단일 이미지 (예컨대, 모노 뷰) 의 사이즈 및 로케이션을 정의할 수도 있다. 이 단일 이미지의 사이즈 및 로케이션의 정의는 단일 이미지에 대한 뷰포트로서 간주될 수도 있다. 뷰포트를 정의하기 위해, 애플리케이션 (32) 은 변수들이 디스플레이 상의 모노 뷰 이미지의 사이즈 및 로케이션을 정의하는 glViewport 커맨드를 발행할 수도 있다. 그래픽 드라이버 래퍼 (16) 는 단일 이미지의 사이즈 및 로케이션을 정의하는 커맨드, 예컨대, 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를, 왼쪽 눈 이미지 및 오른쪽 눈 이미지의 사이즈 및 로케이션을 정의하는 커맨드 (예컨대, 왼쪽 눈 이미지에 대한 뷰포트 및 오른쪽 눈 이미지에 대한 뷰포트를 정의하는 glViewport 커맨드들) 로 수정할 수도 있다. 왼쪽 눈 이미지에 대한 glViewport 커맨드는 왼쪽 눈 이미지를 디스플레이의 하나의 부분으로 제한할 수도 있고, 오른쪽 눈 이미지에 대한 glViewport 커맨드는 오른쪽 눈 이미지를 디스플레이의 다른 하나의 부분으로 제한할 수도 있다.

본 개시물의 예들에서, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 명령들을 수정하는 명령들 외부에 있는 뷰포트를 정의하는 명령들을 수정할 수도 있다. 다르게 말하면, 그래픽 드라이버 래퍼 (16) 는 입체 뷰의 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트를 수정하기 위해 정점 셰이더 (28) 의 명령들을 수정할 필요가 없을 수도 있다. 오히려, 그래픽 드라이버 래퍼 (16) 는, 고정 기능 파이프라인 (24) 의 고정 기능 유닛 (예컨대, 뷰포트 변환 유닛) 이 왼쪽 눈 이미지를 제한하는 왼쪽 눈 이미지에 대한 뷰포트를 디스플레이의 하나의 부분에 적용하고, 오른쪽 눈 이미지를 제한하는 오른쪽 눈 이미지에 대한 뷰포트를 디스플레이의 다른 하나의 부분에 적용하여 왼쪽 눈 및 오른쪽 눈 이미지들이 디스플레이되도록 뷰포트를 정의하는 명령을 수정할 수도 있다.

일부 예들에서, 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛은 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로, 그리고 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한할 수도 있다; 그러나, 본 개시물의 양태들은 그렇게 제한되지는 않는다. 뷰포트 변환 유닛은 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 디스플레이의 왼쪽 절반 및 오른쪽 절반 이외의 부분들로 제한할 수도 있다. 대체로, 뷰포트 변환 유닛은, 상세히 설명되는 바와 같이, 뷰포트 변환 유닛이 수신하는 수정된 뷰포트 명령에 기초하여 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 디스플레이의 부분들로 제한할 수도 있다.

하나의 예로서, GPU (20) 가 이미지를 랜더링하게 하기 위해, 애플리케이션 (32) 은 glShaderSource 커맨드를 실행할 수도 있다. glShaderSource 커맨드는 그래픽 드라이버 (14) 에게 시스템 메모리 (26) 로부터 정점 셰이더 (28) 의 소스 코드를 취출할 것을 지시한다. 본 개시물의 예들에서, 애플리케이션 (32) 에 의해 발행된 glShaderSource 커맨드에 응답하여, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 소스 코드가 그래픽 드라이버 (14) 에 도달하기 전에 그것을 인터셉트할 수도 있다. 그래픽 드라이버 래퍼 (16) 는 수정된 정점 셰이더 (28) 가, 실행되는 경우, 입체 뷰를 위한 그래픽 콘텐츠를 생성하게 하는 명령들을 포함하게 정점 셰이더 (28) 의 소스 코드를 수정할 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 수정된 정점 셰이더 (28) 가 ２ 번 실행되게 할 수도 있다. 제 1 실행에서, 수정된 정점 셰이더 (28) 는 왼쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성할 수도 있고, 제 2 실행에서, 수정된 셰이더 (28) 는 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성할 수도 있거나, 또는 그 반대로 생성할 수도 있다.

그래픽 드라이버 래퍼 (16) 는, 애플리케이션 프로세서 (12) 에 의해 실행될 때, 소스 코드 편집기로서 기능을 할 수도 있다. 하나의 예로서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 명령들을 모니터링할 수도 있다. 애플리케이션 (32) 가 glShaderSource 커맨드를 발행하였다는 것을 그래픽 드라이버 래퍼 (16) 가 인식하는 경우, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 명령들 (예컨대, 정점 셰이더 (28) 의 소스 코드) 을 캡처하고 수정할 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 클리핑 좌표들 (예컨대, 입체 뷰) 를 생성하기 위한 명령들을 단일 이미지 (예컨대, 모노 뷰) 에 대해 생성된 클리핑 좌표들의 값을 수정하는 정점 셰이더 (28) 의 명령들에 포함시킬 수도 있다.

예를 들어, 위에서 나타낸 바와 같이, 정점 셰이더 (28) 는 x_clip 좌표에 대한 값을 저장하는 gl_Position.x 커맨드를 포함할 수도 있다. 아래에서 더 상세히 논의될 바와 같이, 그래픽 드라이버 래퍼 (16) 는 gl_Position.x의 값 (예컨대, x_clip 좌표) 을 업데이트하는 명령을 정점 셰이더 (28) 속에 포함시킬 수도 있다. 왼쪽 눈 이미지를 생성하기 위해, 그래픽 드라이버 래퍼 (16) 에 의해 정점 셰이더 (28) 속에 추가된 명령은 정점 셰이더 (28) 가 상수를 x_clip 값에 가산하게 한다. 오른쪽 눈 이미지를 생성하기 위해, 그래픽 드라이버 래퍼 (16) 에 의해 정점 셰이더 (28) 에 추가된 명령은 정점 셰이더 (28) 가 x_clip 값으로부터 상수를 감산하게 한다.

예를 들어, 그래픽 드라이버 래퍼 (16) 는 gl_Position.x 변수에 저장된 값 (예컨대, x_clip 좌표) 을 gl_Position.x 변수 더하기 (z_near*w_world/(R-L)/2)*X의 현재 값으로 변화시키는 명령을 추가하기 위해 정점 셰이더 (28) 의 소스 코드를 수정할 수도 있으며, 여기서 z_near, R, 및 L 은 모두가 PRJ 행렬 (수학식 4) 로부터의 변수들이고, w_world 는 V_world 행렬 (수학식 2) (예컨대, 애플리케이션 (32) 에 의해 정의된 바와 같은 정점 좌표들) 로부터의 변수이다. X 의 값은 +D 또는 -D 일 수도 있으며, 여기서 D 는 관람자의 오른쪽 눈 및 왼쪽 눈 사이의 거리의 절반의 근사값이고, 사용자 정의가능 또는 사전프로그래밍된 (preprogrammed) 값일 수도 있다.

하나의 예로서, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 명령들의 세트에 다음의 명령을 추가할 수도 있다: gl_Position.x+ = (z_near*w_world/(R-L)/2)*X. 이는 gl_Position.x = gl_Position.x + (z_near*w_world/(R-L)/2)*X 과 등가일 수도 있다. 예를 들어, gl_Position.x+= 커맨드는 gl_Position.x+= 명령에 의해 정의된 값을 gl_Position 커맨드에 의해 저장된 값에 가산한다 (예컨대, 그 값을 x_clip 에 가산한다). 일부 상황들에서, gl_Position.x+= 명령은 gl_Position.x+ = X로 단순화할 수도 있다. gl_Position.x+ 변수가 (z_near*w_world/(R-L)/2)*X 또는 그냥 X일 수도 있는 이유들은 아래에서 더 상세히 설명된다.

본 개시물의 기법들에 따라, 왼쪽 눈 이미지를 생성하기 위해, 그래픽 드라이버 래퍼 (16) 는 변수 X 의 값이 +D 가 되도록 정의할 수도 있다. X 가 +D 인 경우, gl_Position.x+= 커맨드는 상수 (예컨대 (z_near*w_world/(R-L)/2)*D 또는 그냥 D) 와 애플리케이션 (32) 에 의해 생성된 정점들의 각각의 x_clip 좌표가 가산되게 하며 이는 정점들이 D의 값만큼 왼쪽으로 이동하게 한다. 오른쪽 눈 이미지를 생성하기 위해, 그래픽 드라이버 래퍼 (16) 는 변수 X의 값이 -D 가 되도록 정의할 수도 있다. X가 -D 인 경우, gl_Position.x+= 커맨드는 애플리케이션 (32) 에 의해 생성된 정점들의 각각의 x_clip 좌표로부터 상수가 감산 (예컨대, (z_near*w_world/(R-L)/2)*-D 또는 그냥 -D) 되게 하며 이는 정점들이 -D 의 값만큼 오른쪽으로 이동하게 한다.

정점 셰이더 (28) 의 소스 코드를 수정한 후, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 수정된 소스 코드를 시스템 메모리에 저장할 수도 있다. 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는 시스템 메모리 (26) 에서 정점 셰이더 (28) 의 비수정 소스 코드가 저장되는 동일한 로케이션에 정점 셰이더 (28) 의 수정된 소스를 저장할 수도 있다. 대체 예들에서, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 비수정 소스 코드가 저장되는 로케이션과는 상이한 시스템 메모리 (26) 의 로케이션에 정점 셰이더 (28) 의 수정된 소스를 저장할 수도 있다.

glShaderSource 커맨드를 발행한 뒤, 애플리케이션 (32) 은 glCompileShader 커맨드를 발행한다. glCompileShader 커맨드는 애플리케이션 프로세서 (12) 상에서 실행 중인 컴파일러 (18) 가 정점 셰이더 (28) 의 수정된 소스 코드를 컴파일하게 한다. 예를 들어, glCompileShader 커맨드는 컴파일러 (18) 가 시스템 메모리 (26) 로부터 수정된 정점 셰이더 (28) 에 대한 소스 코드를 취출하고, 수정된 정점 셰이더 (28) 를 컴파일하게 할 수도 있다. 컴파일한 후, 컴파일러 (18) 는 결과적 오브젝트 코드를 시스템 메모리 (26) 에 저장한다. 예를 들어, 예시된 바와 같이, 시스템 메모리 (26) 는 수정된 정점 셰이더 (30) 를 포함한다. 수정된 정점 셰이더 (30) 는 컴파일러 (18) 가 정점 셰이더 (28) 의 수정된 소스 코드를 컴파일한 결과로 생기는 오브젝트 코드이다.

더구나, 위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 가 왼쪽 눈 이미지를 생성하기 위해 상수를 gl_Position.x 변수에 가산하게 하고 오른쪽 눈 이미지를 생성하기 위해 gl_Position.x 변수로부터 상수를 감산하게 하는 명령들을 정점 셰이더 (28) 의 소스 코드 내에 포함할 수도 있다. 수정된 정점 셰이더 (30) 의 오브젝트 코드는 수정된 정점 셰이더 (30) 가 왼쪽 눈 이미지를 생성하기 위해 gl_Position.x 변수에 상수를 가산하게 하고 오른쪽 눈 이미지를 생성하기 위해 gl_Position.x 변수로부터 상수를 감산하게 하는 명령들을 포함한다. 더 상세히 설명되는 바와 같이, 수정된 정점 셰이더 (30) 는 그리기 커맨드에 응담하여 그래픽 드라이버 래퍼 (16) 로부터 상수의 값을 수신한다.

애플리케이션 (32) 은, 프로세서 (12) 에 의해 실행 시, 단일 이미지의 뷰포트를 정의하는 커맨드 (예컨대, 디스플레이 상의 단일 이미지의 사이즈 및 로케이션을 정의하는 커맨드) 를 또한 발행할 수도 있다. 이 커맨드는 glViewport 커맨드일 수도 있다. glViewport 커맨드는 이미지에 대한 시작 좌표들 (예컨대, x 및 y 좌표들) 및 이미지의 폭 및 길이를 정의한다. glViewport 커맨드의 시작 좌표들과 폭 및 길이 값들은 이미지의 사이즈 및 로케이션을 정의한다.

본 개시물의 예들에서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 캡처할 수도 있다. 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는 그래픽 드라이버 (14) 가 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 GPU (20) 로 송신하는 것을 차단할 수도 있다. 대신, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 것과 같은 glViewport 커맨드의 시작 좌표들과 폭 및 길이 값들을 시스템 메모리 (26) 에 저장할 수도 있다.

대체 예에서, 그래픽 드라이버 래퍼 (16) 는 그래픽 드라이버 (14) 가 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 GPU (20) 로 송신하는 것을 허용할 수도 있다. 이 예에서, 위와 유사하게, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 것과 같은 glViewport 커맨드의 시작 좌표들과 폭 및 길이 값들을 저장할 수도 있다. 이 대체 예에서, GPU (20) 가 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 적용하기 전에, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수정하고, 수정된 glViewport 커맨드를 GPU (20) 로 송신할 수도 있다. 이런 방식으로, GPU (20) 가 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수신하였지만, GPU (20) 는 그래픽 드라이버 래퍼 (16) 에 의해 수정된 것인 수정된 glViewport 커맨드를 실행할 수도 있다.

어느 하나의 예에서, 그래픽 드라이버 래퍼 (16) 는 그 다음에 애플리케이션 (32) 이 하나 이상의 프리미티브들을 그릴 것을 지시하는 커맨드를 GPU (20) 에 발행하기까지 대기할 수도 있다. 이 그리기 커맨드는 glDraw 커맨드일 수도 있다. glDrawArrays 및 glDrawElements와 같이 glDraw 커맨드들의 다양한 예들이 있다. 그리기 커맨드들의 이들 다양한 예들의 각각은 보통 glDraw 커맨드라고 지칭된다.

애플리케이션 (32) 이 glDraw 커맨드를 발행하는 경우, 그래픽 드라이버 래퍼 (16) 는 glDraw 커맨드를 캡처하고, 그래픽 드라이버 (14) 가 glDraw 커맨드를 GPU (20) 로 송신하는 것을 차단한다. 그래픽 드라이버 래퍼 (16) 는 그 다음에 GPU (20) 가 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하게 하는 명령들을 생성한다. 하나의 예로서, 그래픽 드라이버 래퍼 (16) 는, GPU (20) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 2 번 실행하게 하는 명령들을 생성하며, 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트를 정의하기 위한 두 개의 glViewport 커맨드들을 발행하고, 두 개의 glDraw 커맨드들을 발행한다.

기법들의 개관으로서, 애플리케이션 (32) 에 의해 발행된 glDraw 커맨드를 그래픽 드라이버 (14) 가 송신하는 것을 그래픽 드라이버 래퍼 (16) 가 차단한 후, 그래픽 드라이버 래퍼 (16) 는 입체 뷰의 제 1 이미지 (예컨대, 왼쪽 눈 이미지) 에 대한 클리핑 좌표들을 생성할 준비를 수정된 정점 셰이더 (20) 에게 셰이더 프로세서 (22) 가 시키게 하는 커맨드를 GPU (20) 로 발행한다. 그 다음에, 그래픽 드라이버 래퍼 (16) 는 디스플레이 상의 제 1 이미지의 사이즈 및 로케이션을 정의하는 제 1 glViewport 커맨드를 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛으로 발행할 수도 있다. 그래픽 드라이버 래퍼 (16) 는 그 다음에 GPU (20) 가 제 1 glViewport 커맨드에 의해 정의된 바와 같은 디스플레이의 제 1 부분으로 제한된 제 1 이미지를 랜더링하게 하는 제 1 glDraw 커맨드를 GPU (20) 로 발행할 수도 있다.

그래픽 드라이버 래퍼 (16) 는 그 다음에 입체 뷰의 제 2 이미지 (예컨대, 오른쪽 눈 이미지) 에 대한 클리핑 좌표들을 생성할 준비를 수정된 정점 셰이더 (30) 에게 셰이더 프로세서 (22) 가 시키게 하는 커맨드를 GPU (20) 로 발행한다. 그 다음에, 그래픽 드라이버 래퍼 (16) 는 디스플레이 상의 제 2 이미지의 사이즈 및 로케이션을 정의하는, 뷰포트에 대한 제 2 glViewport 커맨드를 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛으로 발행할 수도 있다. 그래픽 드라이버 래퍼 (16) 는 그 다음에 GPU (20) 가 제 2 glViewport 커맨드에 의해 정의된 바와 같은 디스플레이의 제 2 부분으로 제한된 제 2 이미지를 랜더링하게 하는 제 2 glDraw 커맨드를 GPU (20) 로 발행할 수도 있다.

위에서 개관된 바와 같은 본 개시물의 기법들은, 다음의 예들에서 더 상세히 설명된다. 이해의 용이만을 위해, 다음의 예들에서, GPU (20) 가 왼쪽 눈 이미지에 대한 그래픽 콘텐츠를 먼저 생성하고, 뒤이어서 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하는 기법들이 설명된다; 그러나, 그 반대도 또한 가능하다. 또한, 이해의 용이만을 위해, 왼쪽 눈 이미지에 대한 뷰포트가 디스플레이의 왼쪽 절반으로 제한되고, 오른쪽 눈 이미지에 대한 뷰포트가 디스플레이의 오른쪽 절반으로 제한되는 기법들이 설명되지만, 이는 제한이라고 간주되지 않아야 한다.

예를 들어, 그래픽 드라이버 래퍼 (16) 가 glViewport 커맨드를 인터셉트한 다음 애플리케이션 (32) 에 의해 발행된 glDraw 커맨드를 차단한 후, 그래픽 드라이버 래퍼 (16) 는 GPU (20) 가 왼쪽 눈 이미지에 대한 클리핑 좌표들을 생성할 것을 지시하는 명령을 생성한다. 다시, 일부 예들에서 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드의 GPU (20) 로의 송신을 차단할 수도 있다는 것에 주의해야 한다. 다른 예들에서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드가 GPU (20) 로 송신되는 것을 허용할 수도 있다. 그러나, 예들 중 어느 하나에서, 그래픽 드라이버 래퍼 (16) 는 수정된 glViewport 커맨드들을 GPU (20) 로 송신할 수도 있다. 이런 방식으로, GPU (20) 가 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수신했던 경우에도, GPU (20) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 실행하지 않을 수도 있고, 그래픽 드라이버 래퍼 (16) 에 의해 발행된 수정된 glViewport 커맨드들을 실행할 수도 있다. 다르게 말하면, 그래픽 드라이버 래퍼 (16) 에 의해 수정되는, 수정된 glViewport 커맨드들은, 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 리셋시킨다.

하나의 예로서, 그래픽 드라이버 래퍼 (16) 는 GPU (20) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하게 하는 명령을 생성한다. 응답하여, GPU (20) 의 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행한다. 덧붙여서, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지에 대한 클리핑 좌표들을 생성하기 위해 수정된 정점 셰이더 (30) 가 gl_Position.x 변수에 가산하는 상수 값을 송신한다. 셰이더 프로세서 (22) 의 출력은, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 실행으로 인해, 왼쪽 눈 이미지의 정점들에 대한 클리핑 좌표들이다.

예를 들면, 위에서 논의된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 소스 코드 속에 다음의 명령: gl_Position.x+ = (z_near*w_world/(R-L)/2)*X, 또는 그냥 gl_Position.x+ = X 을 포함시킬 수도 있으며, 그 이유는 설명될 것이다. z_near, w_world, R, 및 L 변수들은, 어쩌면 셰이더 프로세서 (22) 에 수학식 (2) 및 (4) 에 관해 위에서 설명된 바와 같이 알려져 있을 수도 있다. 그러나 본 개시물의 양태들은 z_near, w_world, R, 및 L 변수들의 값들을 알기 위해 셰이더 프로세서 (22) 를 필요로 하지 않는다. 예를 들어, z_near, w_world, R, 및 L 변수들은 각각 상수들일 수도 있고, 그러므로 (z_near*w_world/(R-L)/2) 의 결과는 상수 값이 될 것이다. 이 경우, (z_near*w_world/(R-L)/2) 의 값은 추정되거나 또는 사용자 제공되고, X의 값에 곱해질 수도 있다. 더 상세히 설명되는 바와 같이, 일부 예들에서, (z_near*w_world/(R-L)/2) 은 1로 단순화할 수도 있다.

일부 예들에서, 셰이더 프로세서 (22) 는 X의 값을 알지 못할 수도 있다. 왼쪽 눈 이미지에 대해, 그래픽 드라이버 래퍼 (16) 는 셰이더 프로세서 (22) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하게 하는 명령에 더하여 X의 값을 셰이더 프로세서 (22) 로 송신할 수도 있다. 일부 예들에서, X의 값은, 왼쪽 눈 이미지에 대해, D가 관람자의 눈들 사이의 대략 절반 거리인 +D 일 수도 있고, 사용자 정의되거나 또는 사전프로그래밍될 수도 있다. 변수 X의 값이 +D 이기 때문에, gl_Position.x+= 커맨드는 셰이더 프로세서 (22) 가 D의 값을 gl_Position.x 변수에 저장된 값에 가산 (예컨대, D를 x_clip의 값에 가산) 하게 한다.

그래픽 드라이버 래퍼 (16) 는 또한 왼쪽 눈 이미지에 대한 뷰포트를 정의한다. 예를 들어, 애플리케이션 (32) 가 glDraw 커맨드를 발행했던 때보다 전에, 애플리케이션 (32) 은 그래픽 드라이버 래퍼 (16) 가 인터셉트했던 glViewport 커맨드를 발행했다. 그래픽 드라이버 래퍼 (16) 는 또한 시작 좌표들 및 폭 및 길이 값들을 시스템 메모리 (32) 에 저장했다. 왼쪽 눈 이미지에 대한 뷰포트를 정의하기 위해, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 인터셉트된 glViewport 커맨드를 수정할 수도 있다.

예를 들어, glViewport 커맨드는, 처음 두 개의 변수들이 디스플레이 상의 이미지에 대한 시작 좌표를 정의하고 마지막 두 개의 변수들이 이미지의 폭 및 길이를 정의하는 네 개의 변수들을 포함한다. 폭 및 길이 변수들은 반드시 좌표 값들은 아니다. 오히려, 폭 및 길이 변수들은 이미지가 시작 좌표들로부터 연장되는 양을 정의한다. 예를 들면, 애플리케이션 (32) 은 glViewport (0, 0, 폭, 길이) 를 서술하는 glViewport 커맨드를 발행할 수도 있다. 이 예에서, (0, 0) 은 디스플레이의 왼쪽 하부를 말한다. 변수 "폭"은 디스플레이의 폭을 말하고, 변수 "길이"는 디스플레이의 길이를 말한다. 따라서, 이 예에서, 애플리케이션 (32) 은 모노 뷰 이미지와 일치할 것인, 디스플레이의 전부를 포함하는 이미지의 뷰포트를 정의한다. 그러나, 애플리케이션 (32) 은 예시된 것들 외에, 상이한 변수들을 glViewport 커맨드에 대해 할당할 수도 있다.

본 개시물에 따라, 그래픽 드라이버 래퍼 (16) 는 glViewport 커맨드 (예컨대, 이전의 예의 glViewport (0, 0, 폭, 길이)) 를 인터셉트하고, 이 뷰포트 커맨드에 대한 변수들을 수정할 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지를 디스플레이의 소망의 부분으로 제한하기 위해 glViewport 커맨드의 변수들을 수정할 수도 있다. 설명의 편이를 위해, 기법들은 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로, 그리고 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한하는 것을 설명한다; 그러나, 양태들은 그렇게 제한되지 않는다.

왼쪽 눈 이미지에 대해, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 glViewport (0, 0, 폭/2, 길이) 로 수정할 수도 있다. 이 예에서, 폭/2 은 디스플레이의 폭의 절반일 것이다. 예를 들어, 수정된 glViewport 커맨드는 왼쪽 눈 이미지가 디스플레이의 왼쪽 말단으로부터 시작하고 (예컨대, x-축 상의 0 지점부터 시작하고) "폭/2"의 거리를 오른쪽으로 연장함을 나타내며, 이는 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로 제한할 것이다. 또한, 수정된 glViewport 커맨드는 왼쪽 눈 이미지가 디스플레이의 하부로부터 시작하고 (예컨대, y-축 상의 0 지점부터 시작하고) "길이"의 거리를 위쪽으로 연장함을 나타내며, 이는 이미지를 디스플레이의 상부 및 하부로 제한할 것이다.

그래픽 드라이버 래퍼 (16) 는 그 다음에 제 1 glDraw 커맨드를 GPU (20) 로 발행할 수도 있다. glDraw 커맨드에 응답하여, GPU (20) 는 고정 기능 파이프라인 (24) 및 프래그먼트 셰이더들을 통해, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 실행에 의해 생성된 왼쪽 눈 이미지에 대한 클리핑 좌표들을 처리할 수도 있다. 이 예에서, 제 1 glViewport 커맨드는 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로 제한할 수도 있다. glDraw 커맨드는 그 다음에 GPU (20) 가 왼쪽 눈 이미지를 임시 저장을 위해 프레임 버퍼로 랜더링하게 할 수도 있다. 예를 들어, 프레임 버퍼는 오른쪽 눈 이미지가 생성되기까지 왼쪽 눈 이미지를 저장할 수도 있다. 그 다음에, GPU (20) 는 프레임 버퍼의 전부를 디스플레이 프로세서 (미도시) 로 출력할 수도 있다. 디스플레이 프로세서는 입체 뷰를 생성하기 위해 디스플레이가 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 디스플레이하게 할 수도 있다.

그래픽 드라이버 래퍼 (16) 는 오른쪽 눈 이미지를 생성하는 것이 아니라, 왼쪽 눈 이미지를 생성하기 위해 동일한 단계들을 반복할 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 셰이더 프로세서 (22) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하게 하는 다른 명령을 발행한다. 덧붙여서, 그래픽 드라이버 래퍼 (16) 는 오른쪽 눈 이미지에 대한 클리핑 좌표들을 생성하기 위해 수정된 정점 셰이더 (30) 가 gl_Position.x 변수로부터 감산하는 상수 값을 송신한다. 셰이더 프로세서 (22) 의 출력은, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 실행으로 인해, 오른쪽 눈 이미지의 정점들에 대한 클리핑 좌표들이다.

위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 명령 gl_Position.x+ = (z_near*w_world/(R-L)/2)*X, 또는 그냥 gl_Position.x+ = X 를 정점 셰이더 (28) 의 소스 코드에 추가할 수도 있다. 왼쪽 눈 이미지에 대해, 변수 X의 값은 +D (예컨대, 관람자의 눈들 사이의 절반 거리) 일 수도 있다. 본 개시물의 예들에서, 오른쪽 눈 이미지에 대해, 변수 X의 값은 -D 일 수도 있다. 변수 X의 값이 -D 이기 때문에, gl_Position.x+= 커맨드는 셰이더 프로세서 (22) 가 gl_Position.x 변수에 저장된 값으로부터 D의 값을 감산 (예컨대, x_clip의 값으로부터 -D 를 감산) 하게 한다.

그래픽 드라이버 래퍼 (16) 는 또한 눈 이미지에 대한 뷰포트를 정의한다. 위에서 논의된 바와 같이, 왼쪽 눈 이미지에 대해, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로 제한하기 위해 뷰포트를 glViewport (0, 0, 폭/2, 길이) 인 것으로 정의한다. 오른쪽 눈 이미지에 대해, 그래픽 드라이버 래퍼 (16) 는 뷰포트를 glViewport (폭/2, 0, 폭/2, 길이) 로 정의할 수도 있다. 이 예에서, (폭/2, 0) 좌표는 오른쪽 눈 이미지가 디스플레이의 중간으로부터 시작하고 오른쪽으로 연장할 것임을 나타낸다. 또한, glViewport 커맨드에서의 (폭/2, 길이) 변수들은 오른쪽 눈 이미지가 디스플레이의 절반 폭 및 디스플레이의 전체 길이로 연장할 것임을 나타낸다.

그러므로, 이 예에서, 수정된 glViewport 커맨드 (예컨대, glViewport (폭/2, 0, 폭/2, 길이)) 는 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한할 것이다. 예를 들어, 수정된 glViewport 커맨드는 오른쪽 눈 이미지가 디스플레이의 중앙으로부터 시작하고 (예컨대, x-축 상의 폭/2 지점부터 시작하고) "폭/2"의 거리를 오른쪽으로 연장할 것임을 나타내며, 이는 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한할 것이다. 또한, 수정된 glViewport 커맨드는 오른쪽 눈 이미지가 디스플레이의 하부로부터 시작하고 (예컨대, y-축 상의 0 지점부터 시작하고) "길이"의 거리를 아래쪽으로 연장함을 나타내며, 이는 이미지를 디스플레이의 상부 및 하부로 제한할 것이다.

그래픽 드라이버 래퍼 (16) 는 그 다음에 제 2 glDraw 커맨드를 GPU (20) 로 발행할 수도 있다. glDraw 커맨드에 응답하여, GPU (20) 는 고정 기능 파이프라인 (24) 및 프래그먼트 셰이더들을 통해, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 실행에 의해 생성된 오른쪽 눈 이미지에 대한 클리핑 좌표들을 처리할 수도 있다. 이 예에서, 제 2 glViewport 커맨드는 오른쪽 눈 이미지를 디스플레이의 오른쪽 절반으로 제한할 수도 있다. glDraw 커맨드는 그 다음에 GPU (20) 가 오른쪽 눈 이미지를 임시 저장을 위해 프레임 버퍼로 랜더링하게 할 수도 있다. 이 경우, GPU (20) 는 프레임 버퍼에 왼쪽 눈 이미지를 이미 저장하고 있을 수도 있고, GPU (20) 는 입체 뷰를 생성하기 위해 프레임 버퍼로부터 저장된 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 취출하고 디스플레이할 것을 디스플레이 프로세서에 지시할 수도 있다.

위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 명령 gl_Position.x+= 커맨드를 정점 셰이더 (28) 의 소스 코드에 추가할 수도 있다. 정점 셰이더 (28) 의 소스 코드에 추가되는 것은 입체 뷰 밖으로 튀어나오거나 그 속으로 밀려들어가게 하기 위해 왼쪽 눈 이미지 및 오른쪽 눈 이미지 사이이 약간의 변위가 발생하게 하는 gl_Position.x+= 커맨드이다. 그것은 모노 뷰를 위한 뷰포트 (예컨대, glViewport) 를 정의하는 명령의, 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 디스플레이의 적절한 부분들로 (예컨대, 디스플레이의 왼쪽 절반 및 오른쪽 절반 각각으로) 제한하는 오른쪽 눈 및 왼쪽 눈 이미지들을 위한 뷰포트를 정의하는 명령들로의 수정이다.

이해를 추가로 돕기 위해, 그래픽 드라이버 래퍼 (16) 가 gl_Position.x+= 커맨드를 포함하도록 정점 셰이더 (28) 의 명령들을 수정하지 않았지만, 그래픽 드라이버 래퍼 (16) 는 glViewport 커맨드를 수정했고, GPU (20) 가 두 개의 glViewport 커맨드들 및 두 개의 glDraw 커맨드들을 실행하게 하였다고 가정한다. 이 경우, GPU (20) 는 두 개의 glDraw 커맨드들 때문에 두 개의 이미지들을 랜더링할 것이다. 그러나, 이해를 돕는 이 예에서, 이들 두 개의 이미지들이 포개지게 배치되었다면, 변위가 없을 것이고, 두 개의 이미지들의 콘텐츠가 완전히 일렬로 될 것이다. 두 개의 이미지들의 콘텐츠에 변위가 없기 때문에, 임의의 입체 효과가 없을 수도 있고, 이미지는 디스플레이의 2D 영역으로 제한된 단일 이미지로서 관람자에게 보일 것이다. gl_Position.x+= 커맨드의 포함은 두 개의 이미지들의 콘텐츠에서 변위를 유발할 수도 있다. 그 다음에, 관람자가 왼쪽 눈 및 오른쪽 눈 이미지들을 동시에 보는 때, 왼쪽 눈 이미지가 오른쪽 눈으로부터 차단되고 오른쪽 눈 이미지가 왼쪽 눈으로부터 차단되는 경우, 관람자의 뇌는 입체 뷰의 효과에서 밖으로 튀어나옴 또는 밀려들어감을 만들기 위해 두 개의 이미지들의 콘텐츠에서의 변위를 해결한다.

더욱이, 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는, 위에서 설명된 수정 외에, 뷰포트를 추가로 수정할 수도 있다. 예를 들어, 위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지에 대한 glViewport 명령을 glViewport (0, 0, 폭/2, 길이) 로 수정하고, 오른쪽 눈 이미지에 대한 glViewport 명령을 glViewport (폭/2, 0, 폭/2, 길이) 로 수정할 수도 있다. 관람자가 이들 두 개의 이미지들 (예컨대, 입체 뷰) 을 보는 경우, 관람자는 제로 격차 평면 (zero disparity plane; ZDP) 상의 3D 볼륨을 포함하는 입체 이미지를 인식할 수도 있다.

ZDP는 디스플레이 밖으로 튀어나오거나 또는 그 속으로 밀려들어가게 보일 (예컨대, 디스플레이의 앞 또는 뒤에서 보일) 수도 있다. 그러나, ZDP의 로케이션은 반드시 소망의 로케이션에 있지 않을 수도 있다. 예를 들어, ZDP가 더 튀어나왔거나, 그 정도로는 튀어나오지 않았거나, 그 정도로 밀려들어가지 않았거나, 또는 더 밀려들어갔다면, 관람자는 더 풍부하고 더 사실적인 관람 경험을 경험할 수도 있다.

뷰포트 시프트 또는 ZDP의 시프팅이라고 지칭될 수도 있는 ZDP 변화를 위해, 그래픽 래퍼 드라이버 (16) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 왼쪽 경계를 시프트할 수도 있다. 예를 들어, 입체 뷰가 디스플레이 밖으로 튀어나오는 양을 변화시키기 위해 왼쪽 눈 이미지에 대해, 그래픽 래퍼 (16) 는 glViewport 커맨드를 (0 - Vps, 0, 폭/2, 길이) 로 수정할 수도 있고, 오른쪽 눈 이미지에 대해, 그래픽 래퍼 (16) 는 glViewport 커맨드를 ((폭/2 + Vps), 0, 폭/2, 길이) 로 수정할 수도 있다.

이들 예들에서, Vps 값은 뷰포트 시프트를 말하고 왼쪽 눈 이미지의 뷰포트가 시프트하는 양 및 오른쪽 눈 이미지의 뷰포트가 시프트하는 양을 나타낸다. Vps 값은 사용자 선택가능하거나 또는 사전프로그래밍될 수도 있다. 예를 들어, 관람자가 (예컨대, 뷰포트 시프트 전에) ZDP를 그것의 현재 로케이션으로부터 시프트하기 원한다면, 관람자는 ZDP의 소망의 로케이션을 달성하기 위해 Vps 값을 선택할 수도 있다. 대안으로, Vps 값은 관람자들이 ZDP가 최적으로 위치되었다고 간주했을 측정값을 제공하는 테스트들에 기초하여 사전프로그래밍될 수도 있다. 예를 들면, Vps 가 양의 값이면, 입체 뷰가 튀어나오는 양은 감소될 수도 있다 (예컨대, ZDP 평면은 디스플레이에 더 가깝다). Vps 가 음의 값이면, 입체 뷰가 튀어나오는 양은 증가될 수도 있다 (예컨대, ZDP 평면은 디스플레이로부터 더 멀다).

일부 예들에서, 뷰포트 시프트 외에, 그래픽 드라이버 래퍼 (16) 는 뷰포트 스트레치를 위해 왼쪽 눈 및 오른쪽 눈 이미지들에 대한 glViewport 커맨드들을 수정할 수도 있다. 뷰포트 스트레치는 뷰포트의 사이즈를 스트레칭하는 것으로 간주될 수도 있으며, 이는 왼쪽 눈 이미지 및 오른쪽 눈 이미지가 스트레칭되게 한다. 일부 경우들에서, 뷰포트 시프트 및 뷰포트 스트레치는 양호한 입체 뷰가 되게 할 수도 있다. 뷰포트 시프트 및 뷰포트 스트레치는 보통 뷰포트를 수정하는 것이라고 말해질 수도 있다. 다르게 말하면, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트들을 각각 정의하는 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 glViewport 커맨드들을 생성하기 위해 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수정할 수도 있다. 이 예에서, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지의 뷰포트들을 추가로 수정 (예컨대, 뷰포트 시프트 또는 뷰포트 시프트 및 뷰포트 스트레치) 할 수도 있다.

왼쪽 눈 이미지에 대한 뷰포트를 스트레치하기 위해, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지에 대한 glViewport 커맨드를 glViewport (0 - Vps, 0, 폭/2 + Vps, 길이) 가 되도록 수정할 수도 있다. 오른쪽 눈 이미지에 대한 뷰포트를 스트레치하기 위해, 그래픽 드라이버 래퍼 (16) 는 오른쪽 눈 이미지에 대한 glViewport 커맨드를 glViewport (폭/2, 0, 폭/2 + Vps, 길이) 가 되도록 수정할 수도 있다. 예의 기법들에서, 뷰포트 시프트 및 뷰포트 스트레치는 반드시 모든 인스턴스에서 있을 필요는 없을 수도 있다. 예를 들면, 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 glViewport 커맨드들로 수정할 수도 있고, 임의의 부가적인 뷰포트 시프팅 또는 스트레칭을 수행하지 않을 수도 있다. 일부 대체 예들에서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수정할 수도 있고, 추가로 왼쪽 눈 이미지 및 오른쪽 눈 이미지의 뷰포트들을 수정 (예컨대, 뷰포트 시프트 또는 뷰포트 시프트 및 뷰포트 스트레치) 할 수도 있다.

일부 예들에서, 뷰포트 시프트 및 뷰포트 스트레치는 glViewport 커맨드의 수정과 동시에 수정할 수도 있다. 예를 들어, 위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지에 대해 glViewport 커맨드를 glViewport (0, 0, 폭/2, 길이) 로 수정하고, 오른쪽 눈 이미지에 대해 glViewport (폭/2, 0, 폭/2, 길이) 로 수정할 수도 있다. 일부 예들에서, 사용자가 뷰포트 시프트 값 (예컨대, Vps) 을 입력하기 원하는 경우, 그래픽 드라이버 래퍼 (16) 는 위에서 설명된 바와 같이 뷰포트를 시프트하거나 또는 시프트하고 스트레치할 수도 있다. 대체 예들에서, 그래픽 드라이버 래퍼 (16) 는, Vps 값이 사전 프로그래밍되는 예들에서, glViewport 커맨드를 수정하는 때에 Vps 값들을 선제적으로 가산 또는 감산할 수도 있다.

일 예로서, 디스플레이의 사이즈가 10x10 화소들이고 입체 뷰가 튀어나오는 양을 감소시키기 위해 Vps 값이 2가 되도록 선택되거나 또는 사전프로그래밍된다고 가정한다. 이 예에서, 뷰포트 시프트 전에, 왼쪽 눈 이미지에 대한 뷰포트는 (0, 0, 5, 9) 일 수도 있고, 오른쪽 눈 이미지에 대한 뷰포트는 (5, 0, 5, 9) 일 수도 있다. 그래픽 드라이버 래퍼 (16) 는 ZDP를 시프트하기 위해 2 (예컨대, Vps의 값) 을 감산함으로써 왼쪽 눈 이미지에 대한 뷰포트를 시프트시킬 수도 있다. 이 예에서, 왼쪽 눈 이미지에 대한 뷰포트는 (-2, 0, 5, 9) 가 될 수도 있다. 그래픽 드라이버 래퍼 (16) 는 ZDP를 시프트하기 위해 2 (예컨대, Vps의 값) 를 가산함으로써 오른쪽 눈 이미지에 대한 뷰포트를 시프트시킬 수도 있다. 이 예에서, 오른쪽 눈 이미지에 대한 뷰포트는 (7, 0, 5, 9) 가 될 수도 있다. 유사한 계산들이 뷰포트 스트레치 후에 뷰포트를 결정하기 위해 수행될 수도 있다.

뷰포트 시프트된 왼쪽 눈 이미지에 대해, GPU (20) 는 왼쪽 눈 이미지의 화소들의 일부를 크롭 (crop) 할 수도 있다. 예를 들어, 디스플레이의 좌표들은 이 예에서 (0, 0, 9, 9) 일 수도 있다. 그러나, 뷰포트 시프트된 왼쪽 눈 이미지에 대한 좌표들은 (-2, 0, 5, 9) 일 수도 있으며, 이는 뷰포트 시프트된 왼쪽 눈 이미지가 디스플레이의 왼쪽 가장자리보다 더 왼쪽에서 시작한다는 것을 의미한다. GPU (20) 의 고정 기능 파이프라인 (24) 은 좌표들이 디스플레이의 왼쪽 가장자리보다 더 왼쪽에 있는 화소들을 크롭할 수도 있다. 마찬가지로, 뷰포트 시프트된 오른쪽 눈 이미지에 대해, GPU (20) 는 오른쪽 눈 이미지의 화소들의 일부를 크롭할 수도 있다. 예를 들어, 뷰포트 시프트된 오른쪽 눈 이미지에 대한 좌표들은 (7, 0, 5, 9) 일 수도 있으며, 이는 뷰포트 시프트된 오른쪽 눈 이미지가 디스플레이의 오른쪽 가장자리보다 더 오른쪽에서 끝난다는 것을 의미한다. GPU (20) 의 고정 기능 파이프라인 (24) 은 좌표들이 디스플레이의 오른쪽 가장자리보다 더 오른쪽에 있는 화소들을 크롭할 수도 있다. 다시, 유사한 계산들이 뷰포트 스트레칭을 위해 수행될 수도 있다.

뷰포트 시프트된 또는 시프트되고 스트레치된 ZDP (예컨대, 뷰포트 시프트된 또는 시프트되고 스트레치된 왼쪽 눈 이미지 및 오른쪽 눈 이미지로부터의 결과적인 ZDP) 의 로케이션은 다음의 수학식에 의해 결정될 수도 있으며:

(수학식 6)

여기서 ZDP' 은 뷰포트 시프트된 ZDP의 로케이션이며, z_near 는 PRJ 행렬 (수학식 4) 에서 정의되며, D 는 관람자의 왼쪽 눈 및 오른쪽 눈 사이의 절반 거리이며, ZDP 는 (예컨대, 뷰포트 시프트팅 전의) 원래의 로케이션이고, Vps 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지의 왼쪽 경계가 시프트된 양이다.

일부 인스턴스들에서, z_near, ZDP, D, 또는 Vps 의 값은 관람자에게 이용가능하지 않을 수도 있다. 이들 인스턴스들에서, 관람자가 바람직한 뷰포트 시프트된 ZDP 또는 시프되고 스트레치된 ZDP를 발견하기까지 관람자는 여전히 Vps 값을 수정할 (예컨대, 그 값을 증분증가시키거나 또는 그 값을 감분감소시킬) 수도 있다. Vps 값의 수정은 모든 예에서 반드시 필요하지 않을 수도 있고, 사전프로그래밍된 Vps 값이 적절히 풍부하고 사실적인 관람 경험을 대부분의 관람자들에게 제공할 수도 있다.

일부 예들에서, 본 개시물에서 설명된 기법들은 실행 또는 런 타임 동안에 입체 뷰에 대한 이미지들을 생성하기 위해 모노 뷰에 대한 이미지를 생성하는 명령들을 수정할 수도 있다. 예를 들어, 애플리케이션 (32) 의 실행에 의해 생성된 그래픽를 처리하기 위해 정점 셰이더 (28) 의 실행을 필요로 할 수도 있는 애플리케이션 (32) 을 관람자가 실행을 위해 선택할 수도 있다. 애플리케이션 (32) 이 디바이스 (10) 상에서 실행중이거나 또는 런닝 중일 경우, 그래픽 드라이버 (14), 그래픽 드라이버 래퍼 (16), 및 컴파일러 (18) 는 정점 셰이더 (28) 의 소스 코드를 수정하고 수정된 정점 셰이더 (30) 에 대한 오브젝트 코드를 생성하기 위해 그것들의 개별 기능들을 수행할 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 런 타임 동안 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 인터셉트하고, 일부 예들에서, 런 타임 동안 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드의 GPU (20) 로의 송신을 차단하거나, 또는 다른 예들에서, 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드의 GPU (20) 로의 송신을 허용할 수도 있다. 어느 하나의 예에서, 그래픽 드라이버 래퍼 (16) 는 GPU (20) 에 의해 실행되는 glViewport 커맨드가 그래픽 드라이버 래퍼 (16) 에 의해 수정되는 수정된 glViewport 커맨드가 되도록 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수정할 수도 있다.

더구나, 애플리케이션 (32) 이 그리기 커맨드 (예컨대, glDraw) 를 발행하는 경우, 그래픽 드라이버 래퍼 (16) 는 이 glDraw를 캡처하고 GPU (20) 로의 송신을 차단할 수도 있다. 애플리케이션 (32) 이 런 타임 동안 발행했던 이 glDraw 커맨드는, 위에서 설명된 방식으로, 그래픽 드라이버 래퍼 (16) 가 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트를 정의하는 명령들을 포함하게 하는 트리거로서 기능을 할 수도 있고, GPU (20) 가 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하게 하는 두 개의 glDraw 커맨드들을 포함한다.

또한, 위의 예들이 그래픽 드라이버 래퍼 (16) 가 명령들을 정점 셰이더 (28) 의 명령들에 추가하여 수정하고 뷰포트를 정의하는 명령을 수정하는 상황으로 설명되었지만, 본 개시물의 양태들은 그렇게 제한되지 않는다. 대체 예들에서, 그래픽 드라이버 래퍼 (16) 보다는, 그래픽 드라이버 (14) 또는 컴파일러 (18) 가 정점 셰이더 (28) 의 명령들 및 뷰포트를 정의하는 명령을 수정하는 것이 가능할 수도 있다. 그러나, 이들 예들은 그래픽 드라이버 (14) 또는 컴파일러 (18) 에 대한 수정을 필요로 할 수도 있다.

그래픽 드라이버 (14) 또는 컴파일러 (18) 에 대한 수정은, GPU (20) 가 입체 뷰에 대한 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 생성하도록 본 개시물에서 설명되는 기능들을 수행하는 그래픽 드라이버 래퍼 (16) 를 가지는 것과 그래픽 드라이버 래퍼 (16) 를 개발하는 것보다 더 어려울 수도 있다. 예를 들어, 디바이스 (10) 에는 미리 존재하는 그래픽 드라이버 (14) 및 컴파일러 (18) 가 로딩되어 있을 수도 있고, 그래픽 드라이버 (14) 및 컴파일러 (18) 를 변경하는 것이 어려울 수도 있다. 정점 셰이더 (28) 에 대한 수정을 수행하는 그래픽 드라이버 래퍼 (16) 를 추가함으로써, 예의 기법들은 미리 존재하는 그래픽 드라이버 (14) 및 컴파일러 (18) 에 대한 수정을 필요로 하지 않을 수도 있다.

더욱이, 위에서 설명된 기법들은 애플리케이션 (32) 에 대한 수정 없이 GPU (20) 가 입체 뷰에 대한 이미지들을 생성하는 것을 허용할 수도 있다. 예를 들어, 입체 뷰를 생성하기 위한 일부 다른 기법들은 왼쪽 눈 및 오른쪽 눈 이미지들에 대한 화소 값들을 생성하기 위해 애플리케이션 (32) 의 소스 코드를 수정하는 애플리케이션 (32) 의 개발자들을 필요로 할 수도 있다. 이들 기법들은 입체 뷰에 대한 그들의 애플리케이션들을 수정하기 위해 애플리케이션 (32) 의 개발자로부터의 도움을 필요로 했으며, 이는 애플리케이션 (32) 의 개발자에게 잠재적으로 번거러운 태스크가 될 수도 있다. 위에서 설명된 예의 기법들은 애플리케이션 (32) 의 개발자로부터의 임의의 도움 없이, 모노 뷰에 대해 개발된 애플리케이션 (32) 에 대한 입체 뷰를 제공할 수도 있다.

또한, 위에서 설명된 기법들은 입체 뷰에 대한 왼쪽 눈 및 오른쪽 눈 이미지들을 생성하기 위한 시스템 메모리 (26) 에 대한 다수의 호출들을 필요로 하지 않을 수도 있다. 예를 들어, 입체 뷰를 생성하는 일부 다른 기법들에서, GPU가 왼쪽 눈 이미지를 생성할 것이다. 왼쪽 눈 이미지의 생성의 완료 시, GPU는 오른쪽 눈 이미지를 생성하기 위해 왼쪽 눈 이미지를 생성하는 동안 시스템 메모리 (26) 에 저장된 깊이 정보를 활용할 수도 있다. 그러나, 깊이 정보를 취출하기 위한 시스템 메모리 (26) 에 대한 반복된 호출들은 컴퓨테이션적으로 비용이 많이 들 수도 있고 과도한 소비 전력을 필요로 할 수도 있다.

위에서 설명된 예의 기법들은 오른쪽 눈 이미지를 생성하기 위해 왼쪽 눈 이미지에 대한 깊이 정보를 위해 시스템 메모리 (26) 에 대한 그런 다수의 호출들을 필요로 하지 않을 수도 있다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 다른 이미지를 생성하기 위한 하나의 이미지의 깊이 정보를 반드시 필요로 하지 않고, 정점 셰이더 (28) 의 소스 코드와 왼쪽 눈 및 오른쪽 눈 이미지들을 서로 독립적으로 생성하기 위해 뷰포트를 정의하는 명령을 수정할 수도 있다. 예를 들면, 정점 셰이더 (28) 에 추가되는 명령들과 glViewport 커맨드들의 수정 및 두 개의 glDraw 커맨드들의 발행들은, 위에서 설명된 바와 같이, 임의의 깊이 정보를 필요로 하지 않을 수도 있고, 일부 예들에서, 오른쪽 눈 이미지에 관한 정보를 필요로하지 않고서도 왼쪽 눈 이미지를 생성할 수도 있고, 그 반대로도 생성할 수도 있다. 이런 식으로, 본 개시물에서 설명된 기법들은, 다른 기법들과 비교하여, 입체 뷰를 생성하기 위한 시스템 메모리 (26) 에 대한 액세스 수를 감소시킬 수도 있다.

더구나, 위에서 설명된 바와 같이, glViewport 커맨드는 고정 기능 파이프라인 (24) 의 고정 기능 유닛 (예컨대, 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛) 에 의해 활용되지만, 셰이더 프로세서 (22) 에 의해서는 아니다. 이런 식으로, 정점 셰이더 (28) 에 대한 소스 코드는 디스플레이의 제 1 부분 (예컨대, 디스플레이의 왼쪽 절반) 에 대한 왼쪽 눈 이미지의 랜더링을 강제하고 디스플레이의 다른 부분 (예컨대, 디스플레이의 오른쪽 절반) 에 대한 오른쪽 눈 이미지의 랜더링을 강제하도록 수정될 필요가 없을 수도 있다. 오히려, 고정 기능 파이프라인 (24) 의 고정 기능 유닛은 왼쪽 눈 이미지를 디스플레이의 그 부분으로 그리고 오른쪽 눈 이미지를 디스플레이의 그 부분으로 제한하기 위해 수정된 glViewport 커맨드들을 적용할 수도 있다. 이는 정점 셰이더 (28) 에 대한 수정들을 감소시키고 단순화시킬 수도 있으며, 이는 셰이더 프로세서 (22) 의 컴퓨테이션 효율을 증가시킬 수도 있다.

예를 들어, 본 개시물의 기법들에 따라, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지 사이에 변위를 제공하기 위해 정점 셰이더 (28) 의 소스 코드를 수정할 수도 있다. 예를 들면, 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 클리핑 정점 좌표들을 생성하는 경우, 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행 중인 셰이더 프로세서 (22) 는, 생성된 그래픽 데이터가 디스플레이될 곳을 의식하지 못하게 될 수도 있다. 다르게 말하면, 셰이더 프로세서 (22) 는 그래픽 데이터가 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대해 제시되는 곳을 정의하는 임무를 가지지 않을 수도 있다. 셰이더 프로세서 (22) 외부의 유닛인 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛은, 그것들의 디스플레이의 개별 부분들로 왼쪽 눈 및 오른쪽 눈 이미지들을 제한하는 임무를 가지지 않을 수도 있다. 이런 식으로, 셰이더 프로세서 (22) 는 왼쪽 눈 및 오른쪽 눈 이미지들이 디스플레이해야 하는 곳을 결정할 때에 컴퓨테이션 사이클들을 낭비하는 것을 필요로 하지 않을 수도 있다. 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛의 하드와이어드 기능은, 셰이더 프로세서 (22) 와 비교하여, 왼쪽 눈 및 이미지 오른쪽 눈 이미지를 그것들의 디스플레이 상의 개별 부분들로 제한하기에 더 적합할 수도 있다.

예를 들어, 정점 셰이더 (28) 에 대한 소스 코드가 제로 격차 평면 (ZDP) 을 제어하기 위해서 왼쪽 눈 및 오른쪽 눈 이미지들이 디스플레이되어야 하는 곳을 결정하도록 수정되었다면, 왼쪽 눈 및 오른쪽 눈 이미지들에서 프리미티브들 중 각각의 프리미티브의 각각의 정점에 대한 좌표들을 결정하기 위해 셰이더 프로세서 (22) 를 필요로 할 수도 있다. 이는 셰이더 프로세서 (22) 의 효율을 감소시킬 수도 있는 다수의 컴퓨테이션 사이클들을 수행하는 셰이더 프로세서 (22) 를 필요로 할 수도 있다. 뷰포트 변환, 그리고 또한 뷰포트 시프트 또는 시프트 및 스트레치를 수행하는 것 (예컨대, ZDP를 조절하기 위해 Vps 값에 기초하여 뷰포터를 추가로 수정하는 것) 에 의해, 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛에서, 본 개시물의 양태들은 셰이더 프로세서 (22) 에서 낭비된 계산 사이클들 없이 더 풍부한 입체 뷰를 제공할 수도 있다.

위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 gl_Position.x+ = (z_near*w_world/(R-L)/2)*X 또는 그냥 gl_Position.x+ = X 커맨드를, gl_Position.x 변수의 값을 수정하는 정점 셰이더 (28) 의 소스 코드 속에 포함시킬 수도 있다. 다음에서는 이러한 정점 셰이더 (28) 의 소스 코드 속으로의 명령들의 포함에 대한 이유들이 제공된다.

위의 수학식 (1) 에서 나타낸 바와 같이, Vclip = PRJ*Veye = PRJ*MVT*Vworld 이다. Vclip 에 대한 수학식은 왼쪽 눈 및 오른쪽 눈에 대한 클리핑 좌표들을 생성하기 위해 수정될 수도 있다. 예를 들어, 왼쪽 눈 및 오른쪽 눈에 대한 클리핑 좌표들은 다음과 같을 수도 있다:

(수학식 7), 및

(수학식 8).

VTleft-eye 및 VTright-eye 는 모노 뷰로부터 떨어져 있는 왼쪽 눈 및 오른쪽 눈의 가정된 거리에 기초하는 4x4 행렬들일 수도 있다. 모노 뷰의 좌표들은 (0, 0, 0) 일 수도 있고, 왼쪽 눈은 (-D, 0, 0) 에 위치된 것으로 간주될 수도 있고, 오른쪽 눈은 (D, 0, 0) 에 위치된 것으로 간주될 수도 있다. 다르게 말하면, (0, 0, 0) 로케이션은 관람자의 오른쪽 눈 및 왼쪽 눈의 중간에 있는 것으로 간주될 수도 있다. 왼쪽 눈이 오른쪽 눈 및 왼쪽 눈의 중간으로부터 -D 떨어져서 위치된 것으로 간주되고 오른쪽 눈이 오른쪽 눈 및 왼쪽 눈의 중간으로부터 +D 떨어져서 위치된 것으로 간주되면, D 는 관람자의 오른쪽 눈 및 왼쪽 눈 사이의 거리의 절반을 나타낸다.

VTleft-eye 및 VTright-eye에 대한 행렬들은 다음과 같이 정의될 수도 있다:

및

VTleft-eye 및 VTright-eye는 두 개의 행렬들의 합으로서 다시 쓰여질 수도 있다. 예를 들어, VTleft-eye는

로서 다시 쓰여질 수도 있다.

VTright-eye는 다음

과 같이 다시 쓰여질 수도 있다

VTleft-eye 행렬을 Vclip_left-eye에 대한 수학식 (수학식 7) 으로 치환함으로써, Vclip_left-eye는 다음과 같이 된다:

(수학식 9).

VTright-eye 행렬을 Vclip_right-eye에 대한 수학식 (수학식 8) 으로 치환함으로써, Vclip_right-eye는 다음과 같이 된다:

(수학식 10).

수학식 9 및 10 양쪽 모두에서, 예컨대, Vclip_left-eye 및 Vclip_right-eye에 대해,

는 PRJ*MVT*Vworld 로 단순화될 수 있는데

이 단위 행렬이고 1에 의해 곱해진 것에 해당하기 때문이다.

위의 수학식 1에서 설명된 바와 같이, PRJ*MVT*Vworld 는 Vclip 이다. 그러므로, Vclip_left-eye 및 Vclip_right-eye 수학식들 (예컨대, 수학식 9 및 10 각각) 은 다음과 같이 다시 쓰여질 수 있다:

(수학식 11),

및

(수학식 12).

PRJ 및 MVT에 대한 행렬들 (수학식 4 및 5 각각) 을 치환하고 수학식 11의 행렬 곱셈을 수행함으로써, Vclip_left-eye에 대한 수학식은 다음으로 단순화될 수도 있으며:

, 그리고 더 구체적으로는 다음으로 될 수도 있다:

(수학식 13)

Vclip_left-eye에 대한 것들과 유사한 치환들로, Vclip_right-eye 수학식은 다음으로 단순화될 수도 있으며:

, 그리고 더 구체적으로는 다음으로 될 수도 있다:

. (수학식 14)

수학식 13 및 14로부터, 계산된 x_clip 좌표에 상수

를 가산하고 모든 다른 클리핑 좌표들을 동일한 것으로 유지함으로써, 정점 셰이더 (28) 는 왼쪽 눈 이미지에 대한 클리핑 좌표들을 생성할 수도 있다는 것을 알 수 있다. 마찬가지로, x_clip 좌표로부터 상수

를 감산하고 모든 다른 클리핑 좌표들을 동일한 것으로 유지함으로써, 정점 셰이더 (28) 는 오른쪽 눈 이미지에 대한 클리핑 좌표들을 생성할 수도 있다. 적어도 이들 이유들로, 그래픽 드라이버 래퍼 (16) 는 명령 gl_Position.x+ = z_near*w_world/((R-L)/2)*X 를 포함할 수도 있으며, 여기서 X 는 왼쪽 눈 이미지를 생성하기 위해 +D 이고, X 는 오른쪽 눈 이미지를 생성하기 위해 -D 이다.

일부 예들에서, gl_Position.x+= 커맨드를 단지 gl_Position.x+ = X로 추가로 단순화시키는 것이 가능할 수도 있다. 예를 들어, w_world 변수가 1로 설정되는 것이 보통이다. 또한, OpenGL, OpenGL ES, 및 OpenGL ES 2.0는, 프로그램가능 셰이더들과 함께, 프루스텀을 다음이 되도록 정의하며:

, 여기서 fov_x 는 OpenGL, OpenGL ES, 및 OpenGL ES 2.0에서 정의된 프루스텀이다. 시야각은

가 1 임을 의미하는 45 도로 설정되는 것이 또한 보통이다. 이는

이 1 임을 의미한다. 그러므로, 이들 예들에서,

는 그냥 X로 단순화된다 (예컨대,

는 1 이고, w_world 는 1 이다). 이들 예들에서, gl_Position.x+= 변수는 gl_Position.x+ = X 로 단순화할 수도 있다.

따라서, 수학식 7 내지 수학식 14는 명령 gl_Position.x+= (z_near*w_world/(R L)/2)* X, 또는 gl_Position.x+ = X 를 정점 셰이더 (28) 에 추가하는 것이 2 번 실행될 때 그리고 X가 제 1 실행에서 +D이고 제 2 실행에서 -D인 경우, 입체 뷰를 생성하기 위해 모노 뷰 이미지를 변위시키는데 충분할 수도 있는지의 이유를 설명하는 수학적 기초를 제공한다. 이런 식으로, 본 개시물의 기법들은 모노 뷰를 위해 설계된 정점 셰이더 (28) 의 소스 코드에 대해 미소한 수정을 제공할 수도 있어서, 수정된 소스 코드가 컴파일되고 실행되는 (예컨대, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 실행의) 경우, 결과적인 이미지들은 관람자에게 입체 뷰를 제공할 수도 있다. 입체 뷰는 디스플레이의 2D 영역에 의해 제한된 이미지를 볼 수 있는 것과 비교하여, 더 풍부하며, 더 가득찬 경험일 수도 있는 3D 경험을 관람자에게 제공할 수도 있다.

일부 예들에서, (z_near*w_world/(R-L)/2) 가 1로 단순화되지 않는 경우 (예컨대, 시야각이 45 도가 아니며 그리고/또는 w_world 가 1이 아니기 때문에

가 1 이 아닌 경우) 에도 그래픽 드라이버 래퍼 (16) 는 커맨드 gl_Position.x+= X를 포함할 수도 있다. 예를 들면, (z_near*w_world/(R-L)/2) 은 상수일 수도 있는데 z_near, w_world, R, 및 L 이 각각 상수이기 때문이다. (z_near*w_world/(R-L)/2) 이 상수이므로, X가 상수이기 때문에 (z_near*w_world/(R-L)/2)*X 의 값은 상수이다. 이 경우, (z_near*w_world/(R-L)/2)*X 는 단순히 X 일 수도 있는 단일 상수를 표현하기 위해 축소될 수도 있다. 이 경우, X의 값은 사용자 특정되거나 또는 사전프로그래밍될 수도 있다. 예를 들면, 위의 예들에서, X 는 왼쪽 눈 이미지에 대해 +D 그리고 오른쪽 눈 이미지에 대해 -D이다. 이 현재 예에서, X 는 왼쪽 눈 이미지에 대해 (z_near*w_world/(R-L)/2)*D 그리고 오른쪽 눈 이미지에 대해 (z_near*w_world/(R-L)/2)*-D일 수도 있으며, 여기서 z_near, w_world, R, 및 L 값들이 셰이더 프로세서 (22) 에 대해 이용가능하지 않다면, (z_near*w_world/(R-L)/2) 및 D 는 사전프로그래밍된 값들에 대해 사용자 특정될 수도 있다.

z_near, w_world, R, 및 L 값들이 셰이더 프로세서 (22) 에 대해 이용가능하다면, 셰이더 프로세서 (22) 는 GPU (20) 가 왼쪽 눈 이미지 또는 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하고 있는지의 여부에 기초하여, (z_near*w_world/(R-L)/2) 의 값을 결정하고 그 값과 +D 또는 -D 를 곱셈할 수도 있다. 또한, 다시,

및 w_world 양쪽 모두가 1 이면, (z_near*w_world/(R-L)/2) 는 1 로 단순화할 수도 있다.

도 2는 본 개시물에서 설명되는 하나 이상의 예의 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 일 예를 도시하는 블록도이다. 예를 들어, 도 2는 GPU (20) 의 컴포넌트들을 더 상세히 예시한다. 도 2에 예시된 바와 같이, GPU (20) 는 커맨드 프로세서 (54), 셰이더 프로세서 (22), 및 고정 기능 파이프라인 (24) 을 구비한다. 커맨드 프로세서 (54) 는 GPU (20) 및 애플리케이션 프로세서 (12) 사이의 인터페이스로서 기능을 할 수도 있다. 예를 들면, 커맨드 프로세서 (54) 는 애플리케이션 프로세서 (12) 로부터 커맨드들을 수신할 수도 있고, 커맨드들이 셰이더 프로세서 (22) 또는 고정 기능 파이프라인 (24) 으로 포워딩되어야 하는지의 여부를 결정할 수도 있다.

하나의 예로서, 위에서 설명된 바와 같이, 애플리케이션 (32) 을 실행하고 있는 애플리케이션 프로세서 (12) 는, 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행할 것을 GPU (20) 에 지시할 수도 있다. 이 예에서, 커맨드 프로세서 (54) 는 애플리케이션 프로세서 (12) 로부터 커맨드를 수신할 수도 있고, 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행할 것을 셰이더 프로세서 (22) 에 지시할 수도 있다. 다른 예로서, 위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 발행된 glViewport 커맨드를 수정하고, 수정된 glViewport 커맨드들을 GPU (20) 에 제공할 수도 있다. 이 예에서, 커맨드 프로세서 (54) 는 수정된 glViewport 커맨드들을 수신하고, 이 커맨드가 고정 기능 파이프라인 (24) 의 뷰포트 변환 유닛 (42) 을 위한 것이라고 결정할 수도 있다. 커맨드 프로세서 (54) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트들을 적용하기 위해 수정된 glViewport 커맨드들을 뷰포트 변환 유닛 (42) 으로 포워딩할 수도 있다.

예를 들어, 위에서 설명된 바와 같이, 애플리케이션 (32) 은 그래픽 드라이버 래퍼 (16) 가 GPU (20) 로의 송신을 차단하라는 glDraw 커맨드를 발행할 수도 있다. glDraw 커맨드는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하기 위한 제 1 명령을 셰이더 프로세서 (22) 로 발행하게 그래픽 드라이버 래퍼 (16) 를 트리거할 수도 있다. 결국, 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하고, 결과적인 클리핑 좌표들을 그것의 로컬 메모리 또는 시스템 메모리 (26) 에 저장한다. glDraw 커맨드는 또한 그래픽 드라이버 래퍼 (16) 가 제 1 수정된 glViewport 명령을 발행하게 하며, 그 명령은 커맨드 프로세서 (54) 에 의해 수신된다. 그 다음에, 그래픽 드라이버 래퍼 (16) 는 커맨드 프로세서 (54) 에 의해 수신되는 제 1 glDraw 커맨드를 발행한다. 커맨드 프로세서 (54) 는, 응답하여, 고정 기능 파이프라인 (24) 의 고정 기능 유닛들과 셰이더 프로세서 (22) 가 입체 뷰의 제 1 이미지 (예컨대, 왼쪽 눈 이미지) 를 위한 그래픽 콘텐츠를 생성하기 위해 그것들의 개별 기능들을 수행하게 한다. 예를 들어, 더 상세히 논의되는 바와 같이, 제 1 glDraw 커맨드에 응답하여, 뷰포트 변환 유닛 (42) 은 제 1 이미지를 디스플레이의 제 1 부분으로 제한하고, 프래그먼트 당 동작 유닛 (50) 은 제 1 이미지의 그래픽 콘텐츠를 프레임 버퍼 (52) 로 출력한다.

입체 뷰의 제 1 이미지가 프레임 버퍼 (52) 에 저장된 후, GPU (20) 는 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하는 단계들을 반복한다. 예를 들어, 그래픽 드라이버 래퍼 (16) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하기 위해 제 2 명령을 셰이더 프로세서 (22) 로 발행한다. 결국, 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하고, 결과적인 클리핑 좌표들을 그것의 로컬 메모리 또는 시스템 메모리 (26) 에 저장한다. 그래픽 드라이버 래퍼 (16) 는 또한 제 2 수정된 glViewport 명령을 발행하며, 그것은 커맨드 프로세서 (54) 에 의해 수신된다. 그 다음에, 그래픽 드라이버 래퍼 (16) 는 커맨드 프로세서 (54) 에 의해 수신되는 제 2 glDraw 커맨드를 발행한다. 커맨드 프로세서 (54) 는, 응답하여, 고정 기능 파이프라인 (24) 의 고정 기능 유닛들과 셰이더 프로세서 (22) 가 입체 뷰의 제 2 이미지 (예컨대, 오른쪽 눈 이미지) 를 위한 그래픽 콘텐츠를 생성하기 위해 그것들의 개별 기능들을 수행하게 한다. 예를 들어, 제 2 glDraw 커맨드에 응답하여, 뷰포트 변환 유닛 (42) 은 제 2 이미지를 디스플레이의 제 2 부분으로 제한하고, 프래그먼트 당 동작 유닛 (50) 은 제 2 이미지의 그래픽 콘텐츠를 프레임 버퍼 (52) 로 출력한다. GPU (20) 의 이 기능은 다음의 예들에서 더 상세히 설명된다.

도 2의 점선 상자들에서 예시된 바와 같이, 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 및 프래그먼트 셰이더 (46) 를 구비한다. 점선 상자들은 셰이더 프로세서 (22) 가 수정된 정점 셰이더 (30) 및 프래그먼트 셰이더 (46) 를 실제로 구비하지 않을 수도 있다는 것을 나타내는 것이다. 오히려, 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 및 프래그먼트 셰이더 (46) 의 오브젝트 코드를 실행할 수도 있다. 수정된 정점 셰이더 (30) 및 프래그먼트 셰이더 (46) 의 오브젝트는 시스템 메모리 (26) 에 저장될 수도 있다.

고정 기능 파이프라인 (24) 은 프리미티브 어셈블리 유닛 (36), 프루스텀유닛 (38), 원근 분리 (perspective divide) 유닛 (40), 뷰포트 변환 유닛 (42), 래스터화 유닛 (44), 및 프래그먼트 당 동작 유닛 (50) 과 같은 하나 이상의 고정 기능 유닛들을 구비할 수도 있다. 고정 기능 파이프라인 (24) 의 이들 고정 기능 유닛들의 각각은 특정 그래스 관련된 기능들을 수행하기 위해 하드와이어되는 하드웨어 유닛들일 수도 있다. 고정 기능 파이프라인 (24) 의 이들 고정 기능 유닛들이 별개의 컴포넌트들로서 예시되었지만, 본 개시물의 양태들은 그렇게 제한되지 않는다. 고정 기능 파이프라인 (24) 의 고정 기능 유닛들 중 하나 이상은 공통 고정 기능 유닛과 결합될 수도 있다. 또한, 고정 기능 파이프라인 (24) 에는 도 2에 예시된 것들보다 더 많은 고정 기능 유닛들이 있을 수도 있다. 고정 기능 파이프라인 (24) 의 하나 이상의 고정 기능 유닛들은 이해를 용이하게 하기 위해 따로따로 예시되어 있다.

더구나, 고정 기능 파이프라인 (24) 의 고정 기능 유닛들의 특정 순서가 예시 목적으로 도시되었고 제한하는 것으로 간주되지 않아야 한다. 예를 들면, 고정 기능 파이프라인 (24) 의 고정 기능 유닛들을 재순서화하는 것이 가능할 수도 있다. 하나의 예로서, 프래그먼트 당 동작 유닛 (50) 의 기능들 중 하나는 화소들을 중첩시킴으로써 가려지는 화소들을 컬링하는 것일 수도 있다. 이 기능이 고정 기능 파이프라인 (24) 에서 조기에 수행되는 것이 가능할 수도 있다.

고정 기능 파이프라인 (24) 의 이들 고정 기능 유닛들은, 셰이더 프로세서 (22) 와 비교하여, 매우 제한된 기능적 유연성을 제공할 수도 있다. 예를 들어, 셰이더 프로세서 (22) 는 수정된 정점 셰이더 (30) 및 프래그먼트 셰이더 (46) 와 같은 프로그램가능 셰이더 프로그램들을 실행하도록 특별히 설계될 수도 있다. 이들 셰이더 프로그램들은 셰이더 프로세서 (22) 가 셰이더 프로그램들에 의해 정의된 방식으로 기능을 하게 한다. 다르게 말하면, 셰이더 프로그램들은 셰이더 프로세서 (22) 의 기능을 정의할 수도 있는 반면, 고정 기능 파이프라인 (24) 의 고정 기능 유닛들의 기능은 설정된다.

위에서 설명된 바와 같이, 그래픽 드라이버 래퍼 (16) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 2 번 실행할 것을 GPU (20) 에 지시할 수도 있으며, 여기서 제 1 실행은 입체 뷰의 이미지들 중 하나 (예컨대, 왼쪽 눈 이미지) 의 정점들에 대한 클리핑 좌표들의 생성을 위한 것이고 제 2 실행은 입체 뷰의 다른 이미지 (예컨대, 오른쪽 눈 이미지) 의 정점들에 대한 클리핑 좌표들의 생성을 위한 것이다. 응답하여, 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하기 위한 이들 명령들의 각각에 대해, 커맨드 프로세서 (54) 는 수정된 정점 셰이더 (30) 의 오브젝트 코드를 취출하고 그것을 실행할 것을 셰이더 프로세서 (22) 로 지시할 수도 있다. 위에서 설명된 바와 같이, 컴파일러 (18) 는 수정된 정점 셰이더의 소스 코드를 컴파일하고 결과적인 오브젝트 코드를 수정된 정점 셰이더 (30) 의 오브젝트 코드로서 저장할 수도 있다. 도 2에 예시된 바와 같이, 수정된 정점 셰이더 (30) 는 정점 어레이 (34) 및 텍스처들 (48) 을 입력들로서 수신할 수도 있다. 정점 어레이들 (34) 은, 위에서 설명된 바와 같이, 애플리케이션 (32) 에 의해 생성된 정점들에 대한 화소 값들 (예컨대, 정점들의 좌표들, 정점들의 컬러 값들, 및 정점들의 투명도 값들) 을 생성하기 위한 정보를 포함할 수도 있다. 예를 들어, 정점 어레이 (34) 의 정점들의 좌표들은 애플리케이션 (32) 에 의해 정의된 바와 같은 월드 좌표들일 수도 있다. 텍스처들 (48) 은 그래픽 콘텐츠의 더 사실적 뷰를 제공하기 위해 생성된 그래픽 상에 중첩되는 텍스처들에 대한 화소 값들일 수도 있다.

셰이더 프로세서 (22) 상에서 실행하고 있는 수정된 정점 셰이더 (30) 는, 정점들의 각각에 대한 클리핑 좌표들을 생성할 수도 있다. 예를 들어, 수정된 정점 셰이더 (30) 는, 도 1에 관해 위에서 논의된 바와 같이, 수학식 1의 행렬 곱셈을 수행함으로써 애플리케이션 (32) 에 의해 정의되고 정점 어레이 (34) 에 저장된 바와 같은 정점들의 월드 좌표들을 정점들의 각각에 대한 클리핑 좌표들로 변환할 수도 있다. 더욱이, 셰이더 프로세서 (22) 상에서 실행하고 있는 수정된 정점 셰이더 (30) 는, 수정된 정점 셰이더 (30) 의 오브젝트 코드의 제 1 실행에서 왼쪽 눈 이미지에 대한 변위를 제공하고 수정된 정점 셰이더 (30) 의 오브젝트 코드의 제 2 실행에서 오른쪽 눈 이미지에 대한 변위를 제공하기 위해 정점들의 각각의 정점의 클리핑 좌표들에 대한 gl_Position.x 변수를 업데이트할 수도 있다. 또한, 수정된 정점 셰이더 (30) 는 부가적인, 기존의 정점 셰이더 태스크들을 수행할 수도 있다. 예를 들어, 수정된 정점 셰이더 (30) 는 정점들에 대한 라이팅 (lighting) 기능들을 수행할 수도 있다.

수정된 정점 셰이더 (30) 가 모델 뷰 변환 (예컨대, gl_Position.x += 커맨드를 이용한 변위를 포함한, 클리핑 좌표들로의 월드 뷰 좌표들의 변환) 을 수행한 후, 수정된 정점 셰이더 (30) 는 정점들에 대한 클리핑 좌표들을 고정 기능 파이프라인 (24) 의 프리미티브 어셈블리 유닛 (36) 에 제공한다. 프리미티브 어셈블리 유닛 (36) 은 정점들을 프리미티브들로 어셈블리하기 위해 정점들에 대한 클리핑 좌표들을 활용할 수도 있다. 예를 들어, 프리미티브 어셈블리 유닛 (36) 은 정점들에 대한 클리핑 좌표들에 기초하여 복수의 삼각형들을 어셈블리할 수도 있으며, 여기서 삼각형들의 각각의 정점들은 수정된 정점 셰이더 (30) 로부터 수신된 정점들에 대응한다. 복수의 삼각형들은 프리미티브들의 하나의 예이다. 대체로, 프리미티브 어셈블리 유닛 (36) 은 수신된 정점들에 대한 클리핑 좌표들에 기초하여 수신된 정점들을 임의의 다각형으로 어셈블리할 수도 있다.

프리미티브 어셈블리 유닛 (36) 은 어셈블리된 프리미티브들을 프루스텀유닛 (38) 으로 송신할 수도 있다. 프루스텀유닛 (38) 은 어셈블리된 프리미티브들이 뷰 볼륨 내에 있는지의 여부를 결정할 수도 있다. 예를 들어, 위에서 설명된 바와 같이, OpenGL, OpenGL ES, 및 OpenGL ES 2.0은 특정 뷰 볼륨을 (fov_x) 로서 정의할 수도 있다. 그러나, 프루스텀은, 예를 들어, glFrustum 함수를 이용하여 사용자 정의가능하게 될 수도 있다. 프루스텀유닛 (38) 은 프리미티브가 완전히 뷰 볼륨 내부에, 완전히 뷰 볼륨 외부에, 또는 부분적으로 뷰 볼륨 내부에 그리고 부분적으로 뷰 볼륨 외부에 있는지를 결정할 수도 있다. 프루스텀유닛 (38) 은, 추가의 프로세싱으로부터, 완전히 뷰 볼륨 외부에 있는 프리미티브들과 뷰 볼륨 외부에 있는 프리미티브들의 부분들을 컬링할 수도 있다. 프루스텀유닛 (38) 은, 추가의 프로세싱을 위해, 완전히 뷰 볼륨 내부에 있는 프리미티브들과 뷰 볼륨 내부에 있는 프리미티브들의 부분들을 유지할 수도 있다.

프루스텀유닛 (38) 은 남아있는 프리미티브들 및 프리미티브들의 부분들을 원근 분리 유닛 (40) 으로 송신할 수도 있다. 원근 분리 유닛 (40) 은 프리미티브들을 그것들의 깊이에 기초하여 확장 또는 축소시킬 수도 있다. 예를 들어, 프리미티브들의 각각은 x, y, 및 z 좌표들에 의해 정의될 수도 있다. z 좌표는 프리미티브가 얼마나 가까이 또는 멀리 있는지를 나타낼 수도 있다. 이 스테이지에서, GPU (20) 는 입체 뷰에 대한 이미지들 중 하나를 위한 그래픽 콘텐츠를 생성하는 것임에 주의해야 한다. 그러므로, 프리미티브의 근접의 개념은 모노 뷰의 상황이지, 입체 뷰의 상황은 아니다.

예를 들면, 원근 분리 유닛 (40) 은 일부 프리미티브들을 축소시키고, 다른 프리미티브들을 확장시킬 수도 있다. 이는 축소된 프리미티브들이 모노 뷰에서 확장된 프리미티브들에 비하여 훨씬 멀리 떨어져 있다는 인식을 만들어 낼 수도 있다. 위에서 설명된 바와 같이, 관람자가 입체 뷰를 인식하는 것은 이들 모노 뷰 이미지들이 디스플레이되는 경우이다. 다르게 말하면, 원근 분리 유닛 (40) 은 왼쪽 눈 이미지 및 오른쪽 눈 이미지가 디스플레이의 2D 영역에서 디스플레이되는 3D 이미지들이 되게 할 수도 있다. 관람자가 이들 3D 이미지들을 보는 경우, 왼쪽 눈 이미지 및 오른쪽 눈 이미지에서, gl_Position.x += 커맨드의 추가에 의해 유발된 변위는, 관람자가 3D 볼륨을 포함하는 입체 3D (S3D) 이미지를 인식하게 한다.

원근 분리 유닛 (40) 은 프리미티브들을 뷰포트 변환 유닛 (42) 으로 송신할 수도 있다. 뷰포트 변환 유닛 (42) 은 이미지의 사이즈 및 로케이션을 정의된 뷰포트에 맞게 수정한다. 예를 들어, 뷰포트 변환 유닛 (42) 에 앞서, 수정된 정점 셰이더 (30) 와 고정 기능 파이프라인 (24) 의 고정 기능 유닛들은 이미지가 디스플레이의 전체 상에 디스플레이되는 것처럼 그래픽 데이터를 처리한다. 뷰포트 변환 유닛 (42) 의 기능은 이미지가 정의된 뷰포트로 제한되도록 이미지의 사이즈 및 로케이션을 수정하기 위한 것일 수도 있다.

예를 들면, 위에서 설명된 바와 같이, 왼쪽 눈 이미지에 대한 그래픽 콘텐츠 (예컨대,정점들에 대한 클리핑 좌표들) 를 생성할 수도 있는 정점 셰이더 (30) 의 오브젝트 코드의 제 1 실행 후, 그래픽 드라이버 래퍼 (16) 는 왼쪽 눈 이미지를 디스플레이의 왼쪽 절반으로 제한하기 위해 왼쪽 눈 이미지의 뷰포트를 수정할 수도 있다. 예를 들어, 정점 셰이더 (30) 의 오브젝트 코드의 제 1 실행 후, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 이전에 발행되었고 GPU (20) 로부터 차단되었던 glViewport (0, 0, 폭, 길이) 커맨드를 glViewport (0, 0, 폭/2, 길이) 로 수정하고, 이 제 1 수정된 glViewport 커맨드를 GPU (20) 로 제공할 수도 있다. 커맨드 프로세서 (54) 는 제 1 수정된 glViewport 커맨드를 뷰포트 변환 유닛 (42) 으로 제공할 수도 있다. 뷰포트 변환 유닛 (42) 은 그 다음에, 이 예에서, 원근 분리 유닛 (40) 으로부터 수신된 프리미티브들의 사이즈들을, 이들 프리미티브들이 디스플레이의 왼쪽 절반으로 제한되도록 수정할 수도 있다. 예를 들면, 원근 분리 유닛 (40) 은 일부 프리미티브들이 다른 프리미티브들보다 더 가깝게 보이도록 프리미티브들의 사이즈들을 서로에 대해 수정할 수도 있다. 뷰포트 변환 유닛 (42) 은 프리미티브들이 디스플레이의 왼쪽 절반으로 제한되도록 프리미티브들의 사이즈 및 로케이션을 비례하게 수정할 수도 있다.

정점 셰이더 (30) 의 오브젝트 코드의 제 2 실행 후, 뷰포트 변환 유닛 (42) 은 유사한 기능들을 그러나 오른쪽 눈 이미지에 대해 수행할 수도 있다. 예를 들어, 정점 셰이더 (30) 의 오브젝트 코드의 제 2 실행은 오른쪽 눈 이미지에 대한 그래픽 콘텐츠 (예컨대,정점들에 대한 클리핑 좌표들) 의 생성을 위한 것일 수도 있다. 이 제 2 정점 셰이더 (30) 의 오브젝트 코드의 실행 후, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 이전에 발행되었고 GPU (20) 로부터 차단되었던 glViewport (0, 0, 폭, 길이) 커맨드를 glViewport (폭/2, 0, 폭/2, 길이) 로 수정하고, 이 제 2 수정된 glViewport 커맨드를 GPU (20) 로 제공할 수도 있다. 커맨드 프로세서 (54) 는 제 2 수정된 glViewport 커맨드를 뷰포트 변환 유닛 (42) 으로 포워딩할 수도 있다. 뷰포트 변환 유닛 (42) 은 프리미티브들이 디스플레이의 오른쪽 절반으로 제한되도록 프리미티브들의 사이즈 및 로케이션을 비례하게 수정할 수도 있다. 이런 식으로, GPU (20) 는 왼쪽 눈 이미지로부터 오른쪽 눈 이미지를 생성하기 위해 깊이 정보에 의존하지 않고, 애플리케이션 (32) 의 런 타임 동안 애플리케이션 (32) 에 의해 생성된 모노 뷰 이미지로부터 입체 뷰에 대한 왼쪽 눈 및 오른쪽 눈 이미지들을 생성하도록 동작할 수도 있고, 반대의 경우도 마찬가지이다.

더욱이, 뷰포트 변환 유닛 (42) 은, 위에서 설명된 바와 같이, 뷰포트 시프트 또는 뷰포트 시프트 및 스트레치를 수행할 수도 있다. 예를 들어, 위에서 설명된 바와 같이, 관람자는 Vps 값을 제공할 수도 있거나, 또는 Vps 값은 사전프로그래밍될 수도 있으며, 여기서 Vps 값은 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대한 뷰포트가 시프트되거나 또는 시프트되고 스트레치된 양을 나타낸다. 이 예에서, 뷰포트 변환 유닛 (42) 은 뷰포트 시프팅과 스트레칭 또한 수행하도록 동작가능할 수도 있다. 뷰포트 시프팅 또는 시프팅 및 스트레칭은 인식된 입체 뷰가 디스플레이로부터 더 튀어나오도록, 디스플레이로부터 많이 튀어나오지 않도록, 디스플레이 속으로 밀려들어가지 않도록, 또는 디스플레이 속으로 더 밀려들어가도록 할 수도 있다.

뷰포트 시프팅 또는 시프팅 및 스트레칭을 위해, 커맨드 프로세서 (54) 는 사용자가 제공한 또는 사전프로그래밍한 Vps 값을 취출하고, 그 Vps 값을 뷰포트 변환 유닛 (42) 에 제공할 수도 있다. 이 예에서, 뷰포트 변환 유닛 (42) 은 왼쪽 눈 이미지에 대해 glViewport (0 - Vps, 0, 폭/2, 길이) 또는 glViewport (0 - Vps, 0, 폭/2 + Vps, 길이) 로서 그리고 오른쪽 눈 이미지에 대해 glViewport (폭/2 + Vps, 0, 폭/2, 길이) 또는 glViewport (폭/2, 0, 폭/2 + Vps, 길이) 로서 수정된 glViewport 커맨드를 수신할 수도 있다. 뷰포트 변환 유닛 (42) 은 왼쪽 눈 이미지 및 오른쪽 눈 이미지에 대해 뷰포트 시프팅 또는 시프팅 및 스트레칭을 수행하고, 뷰포트가 디스플레이의 디스플레이 영역 외부로 연장된다면 임의의 컬링을 수행할 수도 있다. 위에서 설명된 바와 같이, 뷰포트 시프팅 또는 시프팅 및 스트레칭은 관람자에게 더 풍부한 입체 뷰를 제공할 수도 있다.

뷰포트 변환 유닛 (42) 은 제 1 수정된 glViewport 커맨드 및 제 2 수정된 glViewport 커맨드의 각각 뒤에 뷰포트를 수정한 후 프리미티브들을 래스터화 유닛 (44) 으로 포워딩할 수도 있다. 래스터화 유닛 (44) 은 프리미티브들을 디스플레이의 화소들로 변환할 수도 있다. 예를 들어, 래스터화 유닛 (44) 은 어떤 디스플레이의 화소들이 프리미티브들의 각각에 의해 포함되는지를 결정할 수도 있다. 래스터화 유닛 (44) 은 또한 디스플레이들 상의 이들 화소들의 각각의 로케이션을 결정할 수도 있다.

래스터화 유닛 (44) 은 그것의 그래픽 데이터를 프래그먼트 셰이더 (46) 로 출력할 수도 있다. 화소 셰이더라고 때때로 지칭되는 프래그먼트 셰이더 (46) 는, 셰이더 프로세서 (22) 상에서 실행하는 셰이더 프로그램일 수도 있다. 예를 들어, 프래그먼트 셰이더 (46) 에 대한 소스 코드는 시스템 메모리 (26) 에 저장될 수도 있고, 컴파일러 (18) 는 프래그먼트 셰이더 (46) 의 오브젝트 코드를 생성하기 위해 프래그먼트 셰이더 (46) 의 소스 코드를 컴파일할 수도 있다. 대안으로, 시스템 메모리 (26) 는 프래그먼트 셰이더 (46) 에 대한 오브젝트 코드를 그것이 컴파일러 (18) 에 의해 반드시 생성될 필요 없이 저장할 수도 있다.

프래그먼트 셰이더 (46) 는 디스플레이 상의 화소들의 각각에 대한 컬러 값들을 출력할 수도 있다. 예를 들어, 프래그먼트 셰이더 (46) 는 적색-녹색-청색 (RGB) 성분에 기초하여 각각의 화소의 컬러를 정의할 수도 있다. 프래그먼트 셰이더 (46) 는, 하나의 구체적인 예로서, 적색 성분을 정의하기 위해 8-비트, 녹색 성분을 정의하기 위해 8-비트, 그리고 청색 성분을 정의하기 위해 8-비트를 활용할 수도 있다. 프래그먼트 셰이더 (46) 는 컬러 값들을 프래그먼트 당 동작 유닛 (50) 으로 출력할 수도 있다.

프래그먼트 당 동작 유닛 (50) 은 볼 수 없는 화소들을 컬링할 수도 있다. 예를 들어, 더 멀리 있는 오브젝트의 화소는, 프래그먼트 당 동작 유닛 (50) 이 z-버퍼로부터 결정할 수도 있는, 가까이 있는 오브젝트의 화소에 의해 겹쳐질 수도 있다. 이 겹쳐짐은 더 멀리 있는 오브젝트의 화소가 완전히 가려지게 할 수도 있다. 이 경우, 프래그먼트 당 동작 유닛 (50) 은 겹쳐진 화소를 컬링할 수도 있다. 프래그먼트 당 동작 유닛 (50) 은 또한 화소들을 서로 혼합할 수도 있다. 예를 들어, 겹치는 화소는 겹쳐진 화소를 완전히 가리지 않도록 반투명일 수도 있다. 이 경우, 프래그먼트 당 동작 유닛 (50) 은 이들 화소들의 컬러를 서로 혼합할 수도 있다.

프래그먼트 당 동작 유닛 (50) 의 출력은 디스플레이 상의 화소들에 대한 화소 값들 (예컨대, 컬러) 일 수도 있다. 프래그먼트 당 동작 유닛 (50) 은 화소 값들을 시스템 메모리 (26) 의 프레임 버퍼 (52) 로 임시 저장을 위해 출력할 수도 있다. 일단 프레임 버퍼 (52) 가 가득 차면, 프레임 버퍼 (52) 는 디스플레이 상의 화소들의 각각에 대한 화소 값들을 저장할 수도 있다.

프레임 버퍼 (52) 는 저장 로케이션들의 2D 어레이로서 간주될 수도 있다. 프레임 버퍼 (52) 에 대한 저장 로케이션들의 수는 디스플레이의 화소들의 수와 적어도 동일할 수도 있다. 또한, 프레임 버퍼 (52) 내의 저장 로케이션들은 디스플레이 상의 로케이션에 대응할 수도 있다. 예를 들어, 프레임 버퍼 (52) 내의 왼쪽 상단 저장 로케이션은 디스플레이의 왼쪽 상단에 대응할 수도 있으며, 프레임 버퍼 (52) 내의 왼쪽 상단 저장 로케이션의 오른쪽에 대한 저장 로케이션은 디스플레이의 왼쪽 상단 화소의 오른쪽의 화소에 대응할 수도 있다는 등등이다.

제 1 glDraw 커맨드의 완료 후, 프레임 버퍼 (52) 의 왼쪽 절반에 위치된 저장 로케이션들은 왼쪽 눈 이미지에 대한 화소 값들을 저장할 수도 있는데, 프레임 버퍼 (52) 의 왼쪽 절반이 디스플레이의 왼쪽 절반에 대응할 수도 있기 때문이다. 마찬가지로, 제 2 glDraw 커맨드의 완료 후, 프레임 버퍼 (52) 의 오른쪽 절반에 위치된 저장 로케이션들은 오른쪽 눈 이미지에 대한 화소 값들을 저장할 수도 있는데, 프레임 버퍼 (52) 의 오른쪽 절반이 디스플레이의 오른쪽 절반에 대응할 수도 있기 때문이다. 그러므로, 제 1 및 제 2 glDraw 커맨드들의 완료 후, 프레임 버퍼 (52) 는 왼쪽 눈 이미지에 대한 화소 값들 및 오른쪽 눈 이미지에 대한 화소 값들을 저장할 수도 있다.

도 3은 도 1의 예의 디바이스를 더 상세히 도시하는 블록도이다. 예를 들면, 도 3은 도 1의 디바이스 (10) 를 더 상세히 예시한다. 예를 들어, 위에서 나타낸 바와 같이, 디바이스 (10) 의 예들은, 모바일 무선 전화기들, PDA들, 비디오 디스플레이들을 구비한 비디오 게이밍 콘솔들, 모바일 비디오 회의 유닛들, 랩톱 컴퓨터들, 데스크톱 컴퓨터들, 텔레비전 셋톱 박스들 등을 포함하지만 그것들로 제한되지는 않는다.

도 3에 예시된 바와 같이, 디바이스 (10) 는 애플리케이션 프로세서 (12), GPU (20), 프레임 버퍼 (52) 를 구비한 시스템 메모리 (26), 트랜시버 모듈 (56), 사용자 인터페이스 (58), 디스플레이 (60), 및 디스플레이 프로세서 (62) 를 구비할 수도 있다. 애플리케이션 프로세서 (12), GPU, 및 시스템 메모리 (26) 는 도 1 및 도 2의 애플리케이션 프로세서 (12), GPU (20), 및 시스템 메모리 (26) 와 실질적으로 유사하거나 또는 동일할 수도 있다. 간결함을 위해, 도 3에 도시되지만 도 1 및 도 2에는 도시되지 않은 컴포넌트들만이 상세히 설명된다.

도 3에 예시된 바와 같은 디바이스 (10) 는, 명료함을 위해 도 3에 도시되지 않은 부가적인 모듈들 또는 유닛들을 포함할 수도 있다. 예를 들어, 디바이스 (10) 는 디바이스 (10) 가 모바일 무선 전화기인 예들에서 전화 통신들을 유효하게 하는, 도 3에는 어느 것도 도시되지 않은 스피커 및 마이크로폰, 또는 디바이스 (10) 가 미디어 플레이어인 경우의 스피커를 구비할 수도 있다. 더욱이, 디바이스 (10) 에서 도시된 다양한 모듈들 및 유닛들은 디바이스 (10) 의 모든 예에서 반드시 필요하지 않을 수도 있다. 예를 들어, 사용자 인터페이스 (58) 및 디스플레이 (60) 는 디바이스 (10) 가 데스크톱 컴퓨터 또는, 외부 사용자 인터페이스 또는 디스플레이와 인터페이싱하도록 장비된 다른 디바이스인 예들에서 디바이스 (10) 외부에 있을 수도 있다.

사용자 인터페이스 (58) 의 예들은 트랙볼, 마우스, 키보드, 및 다른 유형들의 입력 디바이스들을 포함하지만 그것들로 제한되지는 않는다. 사용자 인터페이스 (58) 는 또한 터치 스크린일 수도 있고 디스플레이 (60) 의 일 부분으로서 통합될 수도 있다. 트랜시버 모듈 (56) 은 디바이스 (10) 및 다른 디바이스 또는 네트워크 사이의 무선 또는 유선 통신을 허용하는 회로를 포함할 수도 있다. 트랜시버 모듈 (56) 은 하나 이상의 변조기들, 복조기들, 증폭기들, 안테나들 및 유선 또는 무선 통신을 위한 다른 그러한 회로를 구비할 수도 있다. 디스플레이 (60) 는 액정 디스플레이 (LCD), 유기 발광 다이오드 디스플레이 (OLED), 음극선관 (CRT) 디스플레이, 플라즈마 디스플레이, 편광 디스플레이, 또는 다른 유형의 디스플레이 디바이스를 포함할 수도 있다.

디스플레이 프로세서 (62) 는 디스플레이 (60) 가 입체 뷰를 디스플레이하게 하도록 구성될 수도 있다. 디스플레이 (60) 가 입체 뷰를 디스플레이하게 하도록 디스플레이 프로세서 (62) 가 활용될 수도 있는 다양한 기법들이 있을 수도 있고, 본 개시물의 양태들은 이들 기법들 중 임의의 것을 활용할 수도 있다. 예를 들어, 디스플레이 프로세서 (62) 는 프레임 버퍼 (52) 의 왼쪽 절반으로부터 왼쪽 눈 이미지를 취출하며, 프레임 버퍼 (52) 의 오른쪽 절반으로부터 오른쪽 눈 이미지를 취출하고, 입체 뷰를 제공하기 위해 두 개의 이미지들을 함께 인터리브할 수도 있다.

다른 예로서, 디스플레이 프로세서 (62) 는 디스플레이 (60) 의 리프레시 레이트를 제어할 수도 있다. 이 예에서, 각각의 리프레시 사이클 동안, 디스플레이 프로세서 (62) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지 사이를 순환할 수도 있다. 예를 들면, 디스플레이 프로세서 (62) 는 프레임 버퍼 (52) 의 왼쪽 절반으로부터 왼쪽 눈 이미지를 취출하며, 그 왼쪽 눈 이미지를 디스플레이 (60) 의 전부로 확장하고, 그 왼쪽 눈 이미지를 하나의 리프레시 사이클 동안 디스플레이 (60) 상에 디스플레이할 수도 있다. 그 다음에, 다음의 리프레시 사이클 동안, 디스플레이 프로세서 (62) 는 실질적으로 유사한 기능들을, 프레임 버퍼 (52) 의 오른쪽 절반에 저장된 오른쪽 눈 이미지에 대해 수행할 수도 있다. 다르게 말하면, 디스플레이 (60) 는 왼쪽 눈 이미지, 그 다음에 오른쪽 눈 이미지, 그 다음에 왼쪽 눈 이미지 등으로 디스플레이할 수도 있다.

관람자는 디스플레이 프로세서 (62) 의 리프레시 레이트와 동기되는 특수 안경을 착용하고 있을 수도 있다. 예를 들어, 디스플레이 (60) 가 왼쪽 눈 이미지를 디스플레이하고 있는 동안, 특수 안경은 관람자의 왼쪽 눈만이 왼쪽 눈 이미지를 캡처하도록 오른쪽 렌즈를 셔터로 닫을 수도 있다. 그 다음에, 디스플레이 (60) 가 오른쪽 눈 이미지를 디스플레이하고 있는 동안, 특수 안경은 관람자의 오른쪽 눈만이 오른쪽 눈 이미지를 캡처하도록 왼쪽 렌즈를 셔터로 닫을 수도 있다는 등등이다. 리프레시 레이트가 충분히 빠르면, 관람자는 이미지가 디스플레이 (60) 밖으로 튀어나오거나 또는 그 속으로 밀려들어가고 3D 볼륨을 포함하는 입체 뷰를 인식한다.

일부 예들에서, 일부 기존의 디스플레이 프로세서들은 디스플레이 (60) 가 입체 뷰를 디스플레이하게 하도록 구성되지 않을 수도 있다. 이들 예들에서, 관람자는 디바이스 (10) 를 디스플레이가 입체 뷰를 표현하게 하도록 구성되는 디스플레이 프로세서, 이를테면 디스플레이 프로세서 (62) 를 구비하는 디스플레이에 연결시킬 수도 있다. 예를 들어, 관람자는 디바이스 (10) 를 트랜시버 모듈 (56) 을 통해 입체 뷰 가능 텔레비전에 연결시킬 수도 있다. 예를 들면, 관람자는 트랜시버 모듈 (56) 을 고품위 멀티미디어 인터페이스 (HDMI) 와이어를 통해 텔레비전에 연결시킬 수도 있다. 이 예에서, 애플리케이션 프로세서 (12) 또는 GPU (20) 는 프레임 버퍼 (52) 에 저장된 화소 값들을 텔레비전의 디스플레이 프로세서로 송신할 것을 트랜시버 모듈 (56) 에 지시할 수도 있다. 이 텔레비전의 디스플레이 프로세서는 그 다음에 텔레비전이 입체 뷰를 형성하기 위해 왼쪽 눈 및 오른쪽 눈 이미지들을 디스플레이하게 할 수도 있다.

이들 예들에서, 디바이스 (10) 의 디스플레이가 왼쪽 눈 및 오른쪽 눈 이미지들을 디스플레이하는 것이 여전히 가능할 수도 있다. 그러나, 디바이스 (10) 의 디스플레이 프로세서 (62) 는 디바이스 (10) 의 디스플레이 (60) 가 입체 뷰를 표현하도록 하는 것이 가능하지 않기 때문에, 이 예에서, 디스플레이 (60) 는 왼쪽 눈 이미지 및 오른쪽 눈 이미지를 나란히 디스플레이할 수도 있다. 예를 들어, 디스플레이 (60) 의 왼쪽 절반은 왼쪽 눈 이미지를 디스플레이할 수도 있고, 디스플레이 (60) 의 오른쪽 절반은 오른쪽 눈 이미지를 디스플레이할 수도 있다. 이는 위에서 설명된 뷰포트 변환 때문일 수도 있다. 이 경우, 특수 안경을 이용하고도, 관람자는 디스플레이 (60) 를 단순히 보는 것만으로는 입체 뷰를 경험하지 못할 수도 있지만, 입체 뷰 가능 텔레비전을 보는 것에 의해 입체 뷰를 경험할 것이다.

도 4는 본 개시물에서 설명되는 하나 이상의 예의 기법들에 따른 일 예의 동작을 도시하는 흐름도이다. 예시의 목적을 위해, 도 1 및 도 2가 참조된다.

프로세서가 모노 뷰의 이미지를 생성하도록 설계되고 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로세서 상에서 실행될 정점 셰이더에 대한 명령들을 수신할 수도 있다 (64). 예를 들어, 애플리케이션 프로세서 (12) 는, 그래픽 드라이버 래퍼 (16) 의 실행을 통해, 정점 셰이더 (28) 에 대한 명령들을 수신할 수도 있다. 위에서 설명된 바와 같이, 정점 셰이더 (28) 는 모노 뷰를 위한 그래픽 콘텐츠를 생성하도록 설계될 수도 있고, GPU (20) 의 셰이더 프로세서 (22) 상에서 실행되도록 설계될 수도 있다.

프로세서는 정점 셰이더로 하여금, GPU의 셰이더 프로세서 상에서 실행되는 경우, 입체 뷰의 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠 및 정점 셰이더의 제 2 실행 후에 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하게 하는 하나 이상의 명령을 포함하도록 정점 셰이더의 명령들을 수정할 수도 있다 (66). 제 1 이미지는 왼쪽 눈 이미지일 수도 있고 제 2 이미지는 오른쪽 눈 이미지일 수도 있다.

예를 들어, 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 소스 코드를 수신할 수도 있고, gl_Position.x+ = X 커맨드를 정점 셰이더 (28) 의 소스 코드 속에 포함시킬 수도 있다. 컴파일러 (18) 는 수정된 정점 셰이더 (30) 의 코딩된 오브젝트를 생성하기 위해 정점 셰이더 (28) 의 수정된 소스 코드를 컴파일할 수도 있다. 그래픽 드라이버 래퍼 (16) 는 셰이더 프로세서 (22) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 실행하게 할 수도 있고, X에 대한 +D의 값을 셰이더 프로세서 (22) 에 제공할 수도 있다. 그래픽 드라이버 래퍼 (16) 가 제 1 glDraw 커맨드를 발행한 후, 그래픽 드라이버 래퍼 (16) 는 셰이더 프로세서 (22) 가 수정된 정점 셰이더 (30) 의 오브젝트 코드를 다시 실행하게 할 수도 있고, X에 대한 -D 의 값을 셰이더 프로세서 (22) 에 제공할 수도 있다.

프로세서는, 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 제 1 이미지에 대한 뷰포트를 정의하는, 셰이더 프로세서와는 상이한 GPU의 고정 기능 유닛에 대한 제 1 커맨드, 및 제 2 이미지에 대한 뷰포트를 정의하는, GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정할 수도 있다 (68). 이 예에서, 고정 기능 유닛은 도 2의 뷰포트 변환 유닛 (42) 일 수도 있다. 예시되고 위에서 설명된 바와 같이, 뷰포트 변환 유닛 (42) 은 셰이더 프로세서 (22) 와 상이하다.

하나의 예로서, 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 이전에 발행되었던 glViewport (0, 0, 폭, 길이) 커맨드를, 왼쪽 눈 이미지를 랜더링하기 위해 glViewport (0, 0, 폭/2, 길이) 커맨드로 수정할 수도 있고, 오른쪽 눈 이미지를 랜더링하기 위해, 그래픽 드라이버 래퍼 (16) 는 glViewport (0, 0, 폭, 길이) 커맨드를 glViewport (폭/2, 0, 폭/2, 길이) 커맨드로 수정할 수도 있다. 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는, 위에서 논의된 바와 같이 제 1 및 제 2 이미지들을 위한 뷰포트들을 시프트 또는 시프트 및 스트레치할 수도 있다. 일부 예들에서, 그래픽 드라이버 래퍼 (16) 는 제 1 및 제 2 이미지들을 위한 뷰포트들을 정의하기 위해, 모노 뷰를 위한 뷰포트를 정의하는 명령을 수정하면서, 제 1 및 제 2 이미지들을 위한 뷰포트를 시프트 또는 시프트 및 스트레치할 수도 있다.

다음의 의사-코드는 그래픽 드라이버 래퍼 (16) 및 애플리케이션 (32) 의 기능성의 일 예를 제공한다. 이 의사-코드는 이해를 돕기 위한 것으로 여겨지고 제한으로 간주되어서는 안된다.

1. 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 소스 코드를 인터셉트하기 위해 애플리케이션 (32) 에 의해 발행된 glShaderSource 커맨드를 인터셉트한다.

2. 그래픽 드라이버 래퍼 (16) 는 "균일한 플로트 X"를 정점 셰이더 (28) 의 명령들 속에 삽입하며, 여기서 "균일한 (uniform)"은 프로그램가능 셰이더들과 함께 OpenGL 및 OpenGL ES에서의 사용자 정의된 표준 속성 변수이다.

3. 그래픽 드라이버 래퍼 (16) 는 정점 셰이더 (28) 의 소스 코드 내에 "gl_Position.x+ = X" 커맨드를 삽입한다.

4. 애플리케이션 (32) 은 수정된 정점 셰이더 (30) 의 오브젝트 코드를 생성하기 위해 컴파일러 (18) 가 정점 셰이더 (28) 의 수정된 소스 코드 명령들을 컴파일하게 하는 glCompileShader 커맨드를 실행한다.

5. 애플리케이션 (32) 은 수정된 정점 셰이더 (30) 의 오브젝트 코드에 링크하기 위해 다음의 커맨드들을 실행한다:

programObject = glCreateProgram();

glAttachShader(programObject, vertexShader);

glAttachShader(programObject, fragmentShader);

glLinkProgram(programObject)

6. 그래픽 드라이버 래퍼 (16) 는 애플리케이션 (32) 에 의해 호출될 경우 glDraw 커맨드들 (예컨대, glDrawArrays 및 glDrawElements) 를 인터셉트하고, GPU (20) 로 송신되지 않게 커맨드들을 차단한다.

7. 그래픽 드라이버 래퍼 (16) 는 다음의 커맨드들을 발행한다:

glGetInteger(GL_CURRENT_PROGRAM, &program); // 현재 정점 셰이더에 대한 포인터를 얻기 위함

위에서 설명된 바와 같이 왼쪽 눈 이미지에 대한 뷰포트를 생성하기 위해 glViewport 커맨드를 수정.

p = glGetUniformLocation (프로그램, X); 균일한 X에 대한 포인터를 얻기 위함

glUniform1f(p,D); // D와 동일한 X의 값을 설정함.

glDraw 커맨드 // GPU (20) 가 왼쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하게 함

8. 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하기 위해 다음의 수정들로 7부터 뒤의 단계들을 반복한다:

위에서 설명된 바와 같이 오른쪽 눈 이미지에 대한 뷰포트를 생성하기 위해 glViewport 커맨드를 수정한다.

glUniform1f(p, -D) // -D와 동일한 X의 값을 얻기 위함.

glDraw 커맨드 // GPU (20) 가 오른쪽 눈 이미지에 대한 그래픽 콘텐츠를 생성하게 함.

하나 이상의 예들에서, 설명된 기능들은 하드웨어, 소프트웨어, 펌웨어, 또는 그것들의 임의의 조합으로 구현될 수도 있다. 소프트웨어로 구현된다면, 기능들은 하나 이상의 명령들 또는 코드로서 컴퓨터 판독가능 매체 상에 저장될 수도 있다. 컴퓨터 판독가능 매체들은 컴퓨터 저장 매체들을 포함할 수도 있다. 데이터 저장 매체들은 본 개시물에서 설명된 기법들의 구현을 위한 명령들, 코드들 및/또는 데이터 구조들을 취출하기 위해 하나 이상의 컴퓨터들 또는 하나 이상의 프로세서들에 의해 액세스될 수 있는 임의의 이용가능 매체들일 수도 있다. 비제한적인 예로서, 이러한 컴퓨터 판독가능 매체들은 랜덤 액세스 메모리 (RAM), 판독 전용 메모리 (ROM), EEPROM, CD-ROM 또는 다른 광 디스크 스토리지, 자기 디스크 스토리지, 또는 다른 자기 저장 디바이스들, 또는 소망의 프로그램 코드를 명령들 또는 데이터 구조들의 형태로 저장하는데 사용될 수 있고 컴퓨터에 의해 액세스될 수 있는 임의의 다른 매체를 포함할 수 있다. 디스크 (Disk 및 disc) 는 본원에서 사용되는 바와 같이, 콤팩트 디스크 (compact disc, CD), 레이저 디스크, 광 디스크, 디지털 다용도 디스크 (DVD), 플로피 디스크 (floppy disk) 및 블루레이 디스크를 포함하는데, disk들은 보통 데이터를 자기적으로 재생하지만, disc들은 레이저들로써 광적으로 데이터를 재생한다. 상기한 것들의 조합들은 또한 컴퓨터 판독가능 매체들의 범위 내에 포함되어야 한다.

코드들은 하나 이상의 프로세서들, 이를테면 하나 이상의 디지털 신호 프로세서들 (DSPs), 범용 마이크로프로세서들, 주문형 집적회로들 (ASICs), 필드 프로그램가능 로직 어레이들 (FPGAs), 또는 다른 동등한 집적 또는 개별 로직 회로에 의해 실행될 수도 있다. 따라서, 본원에서 사용되는 바와 같은 용어 "프로세서"는 앞서의 구조 또는 본원에서 설명된 기법들의 구현에 적합한 임의의 다른 구조 중의 어느 것을 나타낼 수도 있다. 또한, 본 기법들은 하나 이상의 회로들 또는 로직 엘리먼트들 내에 완전히 구현될 수 있다.

본 개시내용의 기법들은 무선 핸드셋, 집적회로 (IC) 또는 한 세트의 IC들 (즉, 칩 셋) 을 포함하여, 매우 다양한 디바이스들 또는 장치들로 구현될 수도 있다. 갖가지 컴포넌트들, 모듈들, 또는 유닛들은 개시된 기법들을 수행하도록 구성된 디바이스들의 기능적 양태들을 강조하기 위해 본 개시물에서 설명되지만, 상이한 하드웨어 유닛들에 의한 실현을 반드시 요구하지는 않는다. 약간 더 언급하면, 위에서 설명된 바와 같이, 갖가지 유닛들은 하드웨어 유닛에 결합되거나 또는 적합한 소프트웨어 및/또는 펌웨어와 함께, 위에서 설명된 바와 같은 하나 이상의 프로세서들을 포함하는, 상호운용적 하드웨어 유닛들의 컬렉션에 의해 제공될 수도 있다.

다양한 예들이 설명되어 있다. 이들 및 다른 예들은 다음의 청구항들의 범위 내에 있다.

Claims (38)

1. 그래픽 데이터 프로세싱을 위한 방법으로서,
   프로세서를 이용하여, 모노 뷰의 이미지를 생성하도록 구성되고 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로세서 상에서 실행될 정점 셰이더에 대한 명령들을 수신하는 단계로서, 상기 모노 뷰의 이미지는 관람자의 왼쪽 눈 및 오른쪽 눈 양쪽으로 볼 수 있는 단일 이미지인, 상기 수신하는 단계;
   상기 프로세서를 이용하여, 상기 GPU의 상기 셰이더 프로세서 상에서 실행되는 경우, 상기 정점 셰이더로 하여금, 상기 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 생성하고 상기 정점 셰이더의 제 2 실행 후에 상기 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하게 하는 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하는 단계; 및
   상기 프로세서를 이용하여, 상기 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 상기 제 1 이미지에 대한 뷰포트를 정의하는, 상기 셰이더 프로세서와는 상이한 상기 GPU의 고정 기능 유닛에 대한 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는, 상기 GPU의 고정 기능 유닛에 대한 제 2 커맨드로 수정하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
2. 제 1 항에 있어서,
   상기 GPU의 상기 셰이더 프로세서를 이용하여, 상기 정점 셰이더의 상기 수정된 명령들의 오브젝트 코드를 실행하는 단계; 및
   상기 GPU의 상기 고정 기능 유닛을 이용하여, 상기 제 1 이미지에 대한 뷰포트를 정의하는 상기 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는 상기 제 2 커맨드를 실행하는 단계를 더 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
3. 제 1 항에 있어서,
   상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하는 단계는, 상기 제 1 커맨드가 상기 제 1 이미지를 디스플레이의 제 1 부분으로 제한하게 구성되고 상기 제 2 커맨드가 상기 제 2 이미지를 상기 디스플레이의 제 2 부분으로 제한하게 구성되도록 하는, 그래픽 데이터 프로세싱을 위한 방법.
4. 제 1 항에 있어서,
   상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하는 단계는, 상기 제 1 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하는 단계, 및 상기 제 2 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하는 단계를 더 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
5. 제 1 항에 있어서,
   상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하는 단계는, glViewport (0, 0, 폭, 길이) 커맨드를, glViewport (0, 0, 폭/2, 길이) 커맨드를 포함하는 제 1 커맨드, 및 glViewport (폭/2, 0, 폭/2, 길이) 커맨드를 포함하는 제 2 커맨드로 수정하는 단계를 포함하고,
   폭은 디스플레이의 폭이고, 길이는 상기 디스플레이의 길이인, 그래픽 데이터 프로세싱을 위한 방법.
6. 제 1 항에 있어서,
   상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하는 단계는, glViewport (0, 0, 폭, 길이) 커맨드를, glViewport (0 - Vps, 0, 폭/2, 길이) 커맨드 또는 glViewport (0 - Vps, 0, 폭/2 + Vps, 길이) 커맨드를 포함하는 제 1 커맨드 및 glViewport (폭/2 + Vps, 0, 폭/2, 길이) 커맨드 또는 glViewport (폭/2, 0, 폭/2 + Vps, 길이) 커맨드를 포함하는 제 2 커맨드로 수정하는 단계를 포함하고,
   폭은 디스플레이의 폭이며, 길이는 상기 디스플레이의 길이이고, Vps 는 상기 입체 뷰가 상기 디스플레이 밖으로 튀어나오거나 또는 그 속으로 밀려들어 가는 양을 정의하는, 그래픽 데이터 프로세싱을 위한 방법.
7. 제 1 항에 있어서,
   상기 고정 기능 유닛은 상기 GPU의 고정 기능 파이프라인의 뷰포트 변환 유닛을 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
8. 제 1 항에 있어서,
   상기 정점 셰이더에 대한 명령들을 수신하는 단계는, 상기 프로세서 상에서 실행하는 그래픽 드라이버 래퍼를 이용하여, 상기 정점 셰이더의 명령들을 수신하는 단계를 포함하며,
   상기 정점 셰이더의 명령들을 수정하는 단계는, 상기 프로세서 상에서 실행하는 상기 그래픽 드라이버 래퍼를 이용하여, 상기 정점 셰이더의 명령들을 수정하는 단계를 포함하고,
   상기 뷰포트를 정의하는 커맨드를 수정하는 단계는, 상기 프로세서 상에서 실행하는 상기 그래픽 드라이버 래퍼를 이용하여, 뷰포트를 정의하는 커맨드를 수정하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
9. 제 1 항에 있어서,
   상기 정점 셰이더의 명령들을 수정하는 단계는 상기 모노 뷰의 이미지에 대한 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
10. 제 9 항에 있어서,
    상기 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하는 단계는, 상기 적어도 하나의 클리핑 좌표를 저장하는 변수를 업데이트하는 명령을 상기 정점 셰이더에 추가하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
11. 제 10 항에 있어서,
    상기 적어도 하나의 클리핑 좌표를 저장하는 변수를 업데이트하는 명령을 상기 정점 셰이더에 추가하는 단계는, 상기 제 1 실행에서 상기 적어도 하나의 클리핑 좌표에 상수 값을 가산하기 위한 명령을 추가하는 단계 및 상기 제 2 실행에서 상기 적어도 하나의 클리핑 좌표로부터 상기 상수 값을 감산하기 위한 명령을 추가하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
12. 제 10 항에 있어서,
    상기 모노 뷰의 이미지에 대해 상기 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하는 단계는, gl.Position.x += X 커맨드를 추가하는 단계를 포함하며, X 는 상기 제 1 실행에서 +D 이고 상기 제 2 실행에서 -D이고, 상기 D 는 관람자의 왼쪽 눈 및 오른쪽 눈 사이의 거리의 절반의 추정값인, 그래픽 데이터 프로세싱을 위한 방법.
13. 제 1 항에 있어서,
    상기 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 상기 명령들을 수정하는 단계는, 상기 모노 뷰의 이미지에 대한 하나의 클리핑 좌표를 수정하는 명령만을 상기 정점 셰이더에 추가하는 단계를 포함하는, 그래픽 데이터 프로세싱을 위한 방법.
14. 그래픽 데이터 프로세싱을 위한 장치로서,
    셰이더 프로세서 및 상기 셰이더 프로세서와는 상이한, 고정 기능 파이프라인의 고정 기능 유닛을 포함하는 그래픽 프로세싱 유닛 (GPU); 및
    프로세서를 포함하며,
    상기 프로세서는,
    모노 뷰의 이미지를 생성하도록 구성되고 상기 GPU의 상기 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하고;
    상기 정점 셰이더가, 상기 GPU의 상기 셰이더 프로세서 상에서 실행되는 경우, 상기 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 생성하고 상기 정점 셰이더의 제 2 실행 후에 상기 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하게 하는 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하고;
    상기 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 상기 제 1 이미지에 대한 뷰포트를 정의하는, 상기 셰이더 프로세서와는 상이한 상기 GPU의 상기 고정 기능 유닛에 대한 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는, 상기 GPU의 상기 고정 기능 유닛에 대한 제 2 커맨드로 수정하도록 동작가능하고;
    상기 모노 뷰의 이미지는 관람자의 왼쪽 눈 및 오른쪽 눈 양쪽으로 볼 수 있는 단일 이미지인, 그래픽 데이터 프로세싱을 위한 장치.
15. 제 14 항에 있어서,
    상기 GPU의 상기 셰이더 프로세서는 상기 정점 셰이더의 상기 수정된 명령들의 오브젝트 코드를 실행하도록 구성되고,
    상기 GPU의 상기 고정 기능 유닛은 상기 제 1 이미지에 대한 뷰포트를 정의하는 상기 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는 상기 제 2 커맨드를 실행하도록 구성된, 그래픽 데이터 프로세싱을 위한 장치.
16. 제 14 항에 있어서,
    상기 프로세서는, 상기 제 1 커맨드가 상기 제 1 이미지를 디스플레이의 제 1 부분으로 제한하게 구성되고 상기 제 2 커맨드가 상기 제 2 이미지를 상기 디스플레이의 제 2 부분으로 제한하게 구성되도록 상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
17. 제 14 항에 있어서,
    상기 프로세서는, 상기 제 1 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하고 상기 제 2 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하기 위해 상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하도록 추가로 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
18. 제 14 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하기 위해, 상기 프로세서는, glViewport (0, 0, 폭, 길이) 커맨드를, glViewport (0, 0, 폭/2, 길이) 커맨드를 포함하는 상기 제 1 커맨드, 및 glViewport (폭/2, 0, 폭/2, 길이) 커맨드를 포함하는 상기 제 2 커맨드로 수정하도록 동작가능하고, 폭은 디스플레이의 폭이고, 길이는 상기 디스플레이의 길이인, 그래픽 데이터 프로세싱을 위한 장치.
19. 제 14 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하기 위해, 상기 프로세서는, glViewport (0, 0, 폭, 길이) 커맨드를, glViewport (0 - Vps, 0, 폭/2, 길이) 커맨드 또는 glViewport (0 - Vps, 0, 폭/2 + Vps, 길이) 커맨드를 포함하는 상기 제 1 커맨드, 및 glViewport (폭/2 + Vps, 0, 폭/2, 길이) 커맨드 또는 glViewport (폭/2, 0, 폭/2 + Vps, 길이) 커맨드를 포함하는 상기 제 2 커맨드로 수정하도록 동작가능하고, 폭은 디스플레이의 폭이며, 길이는 상기 디스플레이의 길이이고, Vps 는 상기 입체 뷰가 상기 디스플레이 밖으로 튀어나오는 양을 정의하는, 그래픽 데이터 프로세싱을 위한 장치.
20. 제 14 항에 있어서,
    상기 고정 기능 유닛은 뷰포트 변환 유닛을 포함하는, 그래픽 데이터 프로세싱을 위한 장치.
21. 제 14 항에 있어서,
    상기 프로세서는 그래픽 드라이버 래퍼를 실행시켜, 정점 셰이더에 대한 명령들을 수신하고, 상기 정점 셰이더의 명령들을 수정하고, 상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
22. 제 14 항에 있어서,
    상기 정점 셰이더의 명령들을 수정하기 위해, 상기 프로세서는 상기 모노 뷰의 이미지에 대한 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
23. 제 22 항에 있어서,
    상기 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하기 위해, 상기 프로세서는 상기 적어도 하나의 클리핑 좌표를 저장하는 변수를 업데이트하는 명령을 상기 정점 셰이더에 추가하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
24. 제 23 항에 있어서,
    상기 적어도 하나의 클리핑 좌표를 저장하는 변수를 업데이트하는 명령을 상기 정점 셰이더에 추가하기 위해, 상기 프로세서는, 상기 제 1 실행에서 상기 적어도 하나의 클리핑 좌표에 상수 값을 가산하기 위한 명령을 추가하고, 상기 제 2 실행에서 상기 적어도 하나의 클리핑 좌표로부터 상기 상수 값을 감산하기 위한 명령을 추가하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
25. 제 23 항에 있어서,
    상기 모노 뷰의 이미지에 대한 상기 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하기 위해, 상기 프로세서는 gl.Position.x += X 커맨드를 추가하도록 동작가능하며, X 는 상기 제 1 실행에서 +D 이고 상기 제 2 실행에서 -D이고, D 는 관람자의 왼쪽 눈 및 오른쪽 눈 사이의 거리의 절반의 추정값인, 그래픽 데이터 프로세싱을 위한 장치.
26. 제 14 항에 있어서,
    상기 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하기 위해, 상기 프로세서는, 상기 모노 뷰의 이미지에 대한 하나의 클리핑 좌표를 수정하는 명령만을 상기 정점 셰이더에 추가하도록 동작가능한, 그래픽 데이터 프로세싱을 위한 장치.
27. 그래픽 데이터 프로세싱을 위한 장치로서,
    셰이더 프로세서 및 상기 셰이더 프로세서와는 상이한, 고정 기능 파이프라인의 고정 기능 유닛을 포함하는 그래픽 프로세싱 유닛 (GPU); 및
    프로세서를 포함하며,
    상기 프로세서는,
    모노 뷰의 이미지를 생성하도록 구성되고 상기 GPU의 상기 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하는 수단으로서, 상기 모노 뷰의 이미지는 관람자의 왼쪽 눈 및 오른쪽 눈 양쪽으로 볼 수 있는 단일 이미지인, 상기 수신하는 수단;
    상기 정점 셰이더로 하여금, 상기 GPU의 상기 셰이더 프로세서 상에서 실행되는 경우, 상기 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 생성하고 상기 정점 셰이더의 제 2 실행 후에 상기 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하는 수단; 및
    상기 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 상기 제 1 이미지에 대한 뷰포트를 정의하는, 상기 셰이더 프로세서와는 상이한 상기 GPU의 상기 고정 기능 유닛에 대한 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는, 상기 GPU의 상기 고정 기능 유닛에 대한 제 2 커맨드로 수정하는 수단을 포함하는, 그래픽 데이터 프로세싱을 위한 장치.
28. 제 27 항에 있어서,
    상기 GPU의 상기 셰이더 프로세서는 상기 정점 셰이더의 상기 수정된 명령들의 오브젝트 코드를 실행하도록 구성되고,
    상기 GPU의 상기 고정 기능 유닛은 상기 제 1 이미지에 대한 뷰포트를 정의하는 상기 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는 상기 제 2 커맨드를 실행하도록 구성된, 그래픽 데이터 프로세싱을 위한 장치.
29. 제 27 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하기 위한 수단은, 상기 제 1 커맨드가 상기 제 1 이미지를 디스플레이의 제 1 부분으로 제한하게 구성되고 상기 제 2 커맨드가 상기 제 2 이미지를 상기 디스플레이의 제 2 부분으로 제한하게 구성되도록 하는, 그래픽 데이터 프로세싱을 위한 장치.
30. 제 27 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하는 수단은, 상기 제 1 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하는 수단 및 상기 제 2 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하는 수단을 더 포함하는, 그래픽 데이터 프로세싱을 위한 장치.
31. 제 27 항에 있어서,
    상기 정점 셰이더의 명령들을 수정하는 수단은, 상기 모노 뷰의 이미지에 대한 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하는 수단을 포함하는, 그래픽 데이터 프로세싱을 위한 장치.
32. 제 27 항에 있어서,
    상기 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하는 수단은, 상기 모노 뷰의 이미지에 대한 하나의 클리핑 좌표를 수정하는 명령만을 상기 정점 셰이더에 추가하는 수단을 포함하는, 그래픽 데이터 프로세싱을 위한 장치.
33. 명령들을 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체로서,
    상기 명령들은, 실행되는 경우, 하나 이상의 프로세서들로 하여금,
    모노 뷰의 이미지를 생성하도록 설계되고 그래픽 프로세싱 유닛 (GPU) 의 셰이더 프로세서 상에서 실행될, 정점 셰이더에 대한 명령들을 수신하고;
    상기 정점 셰이더로 하여금, 상기 GPU의 상기 셰이더 프로세서 상에서 실행되는 경우, 상기 정점 셰이더의 제 1 실행 후에 입체 뷰의 제 1 이미지에 대한 그래픽 콘텐츠를 생성하고 상기 정점 셰이더의 제 2 실행 후에 상기 입체 뷰의 제 2 이미지에 대한 그래픽 콘텐츠를 생성하도록 하는 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하고;
    상기 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 상기 제 1 이미지에 대한 뷰포트를 정의하는, 상기 셰이더 프로세서와는 상이한 상기 GPU의 고정 기능 유닛에 대한 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는, 상기 GPU의 상기 고정 기능 유닛에 대한 제 2 커맨드로 수정하도록 하고;
    상기 모노 뷰의 이미지는 관람자의 왼쪽 눈 및 오른쪽 눈 양쪽으로 볼 수 있는 단일 이미지인, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.
34. 제 33 항에 있어서,
    상기 GPU의 상기 셰이더 프로세서를 이용하여, 상기 정점 셰이더의 상기 수정된 명령들의 오브젝트 코드를 실행하고;
    상기 GPU의 상기 고정 기능 유닛을 이용하여, 상기 제 1 이미지에 대한 뷰포트를 정의하는 상기 제 1 커맨드 및 상기 제 2 이미지에 대한 뷰포트를 정의하는 상기 제 2 커맨드를 실행시키는 명령들을 더 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.
35. 제 33 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 커맨드를 수정하기 위한 명령들은, 상기 모노 뷰의 이미지에 대한 뷰포트를 정의하는 커맨드를, 상기 제 1 이미지를 디스플레이의 제 1 부분으로 제한하는 상기 제 1 커맨드 및 상기 제 2 이미지를 상기 디스플레이의 제 2 부분으로 제한하는 상기 제 2 커맨드로 수정하기 위한 명령들을 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.
36. 제 33 항에 있어서,
    상기 이미지에 대한 뷰포트를 정의하는 상기 커맨드를 수정하기 위한 명령들은, 상기 제 1 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하고 상기 제 2 이미지에 대한 뷰포트를 시프트하거나 또는 시프트하고 스트레치하기 위한 명령들을 더 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.
37. 제 33 항에 있어서,
    상기 정점 셰이더의 명령들을 수정하기 위한 명령들은, 상기 모노 뷰의 이미지에 대한 적어도 하나의 클리핑 좌표를 수정하는 명령을 상기 정점 셰이더에 추가하기 위한 명령들을 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.
38. 제 33 항에 있어서,
    상기 하나 이상의 명령들을 포함하도록 상기 정점 셰이더의 명령들을 수정하기 위한 명령들은, 상기 모노 뷰의 이미지에 대한 하나의 클리핑 좌표를 수정하는 명령만을 상기 정점 셰이더에 추가하기 위한 명령들을 포함하는, 그래픽 데이터 프로세싱을 위한 컴퓨터 판독가능 저장 매체.

Images