KR101732836B1 - 셰이더 기반의 그래픽스 콘텐츠에 대한 뷰잉 배향에 의한 입체 변환 - Google Patents

Abstract

본 개시물의 예시적인 기법들은 모노 뷰를 생성하도록 설계된 애플리케이션으로부터 입체 뷰를 생성하는 것에 관한 것이다. 예를 들어, 이 기법들은 시야각에 기초하여 정점 셰이더에 대한 명령들을 수정할 수도 있다. 수정된 정점 셰이더가 실행될 때, 수정된 정점 셰이더는 시야각에 기초하여 입체 뷰의 정점들에 대한 좌표들을 생성할 수도 있다.

Description

셰이더 기반의 그래픽스 콘텐츠에 대한 뷰잉 배향에 의한 입체 변환{STEREOSCOPIC CONVERSION WITH VIEWING ORIENTATION FOR SHADER BASED GRAPHICS CONTENT}

본 개시물은 그래픽스 데이터 프로세싱에 관한 것으로, 좀더 구체적으로는, 입체 뷰에 대한 그래픽스 데이터 프로세싱에 관한 것이다.

입체 뷰는 3차원 (3D) 체적을 둘러싸는 것처럼 보이는 인지된 이미지를 지칭한다. 입체 뷰를 생성하기 위해, 디바이스는 디스플레이의 2-차원 (2D) 영역 상에 2개의 이미지들을 디스플레이한다. 이들 2개의 이미지들은, 실질적으로 유사하지만, 2개의 이미지들에서 하나 이상의 대응하는 픽셀들의 수평축을 따라서 경미한 변위를 갖는 콘텐츠를 포함한다. 2D 영역 상에서, 이들 2개의 이미지들의 동시적인 뷰잉은 뷰어로 하여금, 2개의 이미지들을 디스플레이하고 있는 2D 디스플레이 외부로 나오거나 2D 디스플레이 내로 들어간 이미지를 인지할 수 있도록 한다. 이러한 방법으로, 2개의 이미지들이 디스플레이의 2D 영역 상에 디스플레이되더라도, 뷰어는 3D 체적을 둘러싸는 것처럼 보이는 이미지를 인지한다.

입체 뷰의 2개의 이미지들은 좌측-눈 이미지 및 우측-눈 이미지로서 각각 지칭된다. 좌측-눈 이미지는 뷰어의 좌측 눈에 의해 시인가능하고, 우측-눈 이미지는 뷰어의 좌측 눈에 의해 시인불가능하다. 이와 유사하게, 우측-눈 이미지는 뷰어의 우측 눈에 의해 시인가능하며, 좌측-눈 이미지는 뷰어의 우측 눈에 의해 시인불가능하다. 예를 들어, 뷰어는 특수 안경을 착용할 수도 있으며, 여기서, 안경의 좌측 렌즈는 우측-눈 이미지를 차단하고 좌측-눈 이미지를 통과시키며, 안경의 우측 렌즈는 좌측-눈 이미지를 차단하고 우측-눈 이미지를 통과시킨다.

좌측-눈 및 우측-눈 이미지들이 수평축을 따라서 경미한 변위를 가진 실질적으로 유사한 콘텐츠를 포함하지만 (예컨대, 특수 안경 때문에) 뷰어의 양쪽 눈들에 의해 동시에 시인불가능하기 때문에, 뷰어의 두뇌는 2개의 이미지들을 혼합시킴으로써 대응하는 픽셀들 사이의 경미한 변위를 해결한다. 혼합 (commingling) 은 뷰어로 하여금, 2개의 이미지들을 3D 체적을 가진 이미지로서 인지할 수 있도록 한다.

일반적으로, 본 개시물의 기법들은 모노 뷰를 생성하는 명령들을 수정하여 그래픽 프로세싱 유닛 (GPU) 으로 하여금 입체 뷰를 생성하도록 하는 것에 관한 것이다. GPU 의 셰이더 프로그램은 모노 뷰를 생성하도록 설계될 수도 있다. 본 개시물에서 설명하는 기법들은 입체 뷰를 생성하기 위해 적어도 시야각에 기초하여 이러한 셰이더 프로그램의 명령들을 수정한다. 예를 들어, 본 기법들은 픽셀의 로케이션을 입체 뷰의 뷰들 중 하나에 대한 하나의 방향에 의해 변위시키고 픽셀의 로케이션을 입체 뷰의 다른 뷰에 대한 또 다른 방향으로 변위시키도록 셰이더 프로그램의 명령들을 수정한다. 수정된 셰이더 프로그램이 픽셀의 로케이션을 변위시키는 방향은 시야각에 기초한다.

일 예에서, 본 개시물은 그래픽스 프로세싱을 위한 방법을 기술한다. 본 방법은 프로세서에 의해, 디스플레이에 대한 시야각을 결정하는 단계, 프로세서에 의해, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하는 단계, 및 프로세서에 의해, 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 정점 셰이더에 대한 명령들을 수정하는 단계를 포함한다. 이 예에서, 수정된 정점 셰이더는, 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성한다. 본 방법은 또한 프로세서에 의해, 그래픽 프로세싱 유닛 (GPU) 에게 수정된 정점 셰이더를 실행할 것을 명령하는 단계를 포함한다.

일 예에서, 본 개시물은 장치를 기술한다. 본 장치는 그래픽 프로세싱 유닛 (GPU) 및 프로세서를 포함한다. 프로세서는 디스플레이에 대한 시야각을 결정하고, 그리고, 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 정점 셰이더에 대한 명령들을 수정하도록 구성된다. 이 예에서, 수정된 정점 셰이더는, 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성한다. 프로세서는 또한 GPU 에게 수정된 정점 셰이더를 실행할 것을 명령하도록 구성된다.

일 예에서, 본 개시물은 프로세서를 기술한다. 프로세서는 디스플레이에 대한 시야각을 결정하고, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하고, 그리고, 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 정점 셰이더에 대한 명령들을 수정하도록 구성된다. 이 예에서, 수정된 정점 셰이더는, 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성한다. 프로세서는 또한 그래픽 프로세싱 유닛 (GPU) 에게 수정된 정점 셰이더를 실행할 것을 명령하도록 구성된다.

일 예에서, 본 개시물은 그래픽 프로세싱 유닛 (GPU), 디스플레이에 대한 시야각을 결정하는 수단, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하는 수단, 및 수정된 정점 셰이더를 생성하기 위해 시야각에 기초하여 하나 이상의 명령들을 포함하도록 정점 셰이더에 대한 명령들을 수정하는 수단을 포함하는 장치를 기술한다. 이 예에서, 수정된 정점 셰이더는, 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성한다. 본 장치는 또한 GPU 에게 수정된 정점 셰이더를 실행할 것을 명령하는 수단을 포함한다.

일 예에서, 본 개시물은 실행될 때, 하나 이상의 프로세서들로 하여금, 디스플레이에 대한 시야각을 결정하고, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하고, 그리고, 수정된 정점 셰이더를 생성하기 위해 시야각에 기초하여 하나 이상의 명령들을 포함하도록 정점 셰이더에 대한 명령들을 수정하도록 하는 명령들을 안에 저장하고 있는 컴퓨터-판독가능 저장 매체를 기술한다. 이 예에서, 수정된 정점 셰이더는, 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성한다. 명령들은 추가로, 하나 이상의 프로세서들로 하여금, 그래픽 프로세싱 유닛 (GPU) 에게 수정된 정점 셰이더를 실행할 것을 명령하도록 한다.

본 개시물의 하나 이상의 양태들의 세부 사항들이 첨부도면 및 아래의 상세한 설명에서 개시된다. 본 개시물의 다른 특징들, 목적들, 및 이점들은 설명 및 도면들로부터, 그리고 청구범위로부터 명백히 알 수 있을 것이다.

도 1 은 본 개시물에서 설명된 하나 이상의 예들에 따른, 입체 뷰를 디스플레이하고 있는 디스플레이를 예시하는 개념도이다.
도 2 는 상이한 시야각들을 예시하는 개념도이다.
도 3 는 뷰어의 눈들 및 헤드 배향의 검출을 예시하는 개념도이다.
도 4 는 시야각의 일 예를 예시하는 개념도이다.
도 5 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 디바이스의 일 예를 예시하는 블록도이다.
도 6 은 제로 디스패리티 평면의 로케이션을 예시하는 개념도이다.
도 7 은 본 개시물에서 설명되는 하나 이상의 예시적인 기법들에 따른, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 예시하는 개념도이다.
도 8 은 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 일 예를 예시하는 블록도이다.
도 9 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 또 다른 예를 예시하는 블록도이다.
도 10a 내지 도 10c 는 본 개시물에서 설명되는 하나 이상의 기법들에 따른, 예시적인 결과들을 예시하는 개념도들이다.
도 11 은 도 5 의 예시적인 디바이스를 좀더 상세히 예시하는 블록도이다.
도 12 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들에 따른, 예시적인 동작을 예시하는 플로우차트이다.

본 개시물에서 설명되는 예시적인 기법들은 실행 또는 런 타임 동안 입체적인 3차원 (S3D) 그래픽스를 렌더링하는 것에 관한 것이다. 예를 들어, 애플리케이션은 디스플레이를 위해 그래픽 프로세싱 유닛 (GPU) 에 의해 렌더링될 모노 뷰 이미지들을 생성할 수도 있다. 본 개시물에서 설명하는 기법들은 애플리케이션의 실행 (즉, 런-타임 동안) 모노 뷰 이미지들을 입체 뷰 이미지들로 변환할 수도 있다.

일부 예들에서, 이 기법들은 그래픽스를 생성하는 애플리케이션 또는 GPU 에 대한 어떤 변경을 요함이 없이 S3D 그래픽스를 렌더링할 수도 있다. 일부 예들에서, 본 개시물에서 설명하는 기법들은 그래픽스 드라이버에 대한 래퍼를 실행하는 애플리케이션 프로세서에 의해 구현될 수도 있다. 그래픽스 드라이버 대한 래퍼는 본 개시물에서 설명하는 기법들에 따라서, 이전에 생성된 그래픽스 드라이버에의 입력들을 수정하거나 또는 이전에 생성된 그래픽스 드라이버의 출력들을 수정하는 프로그램으로서 간주될 수도 있다. 이러한 방법으로, 본 개시물에서 설명하는 기법들은 GPU 가 애플리케이션 프로세서 상에서 실행하는 그래픽스 드라이버를 수정할 필요 없이 S3D 그래픽스를 생성하기 위해 제공할 수도 있다. 그러나, 애플리케이션 프로세서가, 그래픽스 드라이버의 실행에 응답하여, 본 개시물에서 설명되는 예시적인 기법들을 구현하도록, 새로운 그래픽스 드라이버를 생성하거나, 또는 이전에 생성된 그래픽스 드라이버를 수정하는 것이 가능할 수도 있다. 예시의 목적을 위해, 그 기법들은 그래픽스 드라이버 래퍼를 실행하는 애플리케이션 프로세서에 의해 수행되는 것으로 설명된다.

애플리케이션의 관점으로부터, 애플리케이션을 실행하는 애플리케이션 프로세서는 GPU 에 의한 종래의 3D 그래픽스 렌더링을 위해 그래픽스 데이터 및 애플리케이션의 지령들을 출력할 수도 있다. 애플리케이션 프로세서 상에서 실행하는 그래픽스 드라이버 래퍼는 GPU 가 S3D 디스플레이 상에서 S3D 그래픽스를 렌더링하도록, 지령들 뿐만 아니라, GPU 에 의해 실행되는 명령들을 수정할 수도 있다. 본 개시물에서, 용어들 "지령들" 및 "명령들" 은 교환가능하게 사용될 수도 있다. 이러한 방법으로, GPU 는 그래픽스를 생성하는 애플리케이션에 대한 또는 GPU 에 대한 어떤 변경들 없이 S3D 그래픽스를 렌더링할 수 있다. 따라서, 본 개시물에서 설명하는 기법들은 뷰어가 S3D 그래픽스를 생성하도록 설계되지 않은 애플리케이션들에 의해 생성되는 이미지 콘텐츠에 대해 S3D 그래픽스를 경험가능하게 할 수도 있다.

더욱이, 본 개시물에서 설명하는 기법들은 시야각 (즉, 뷰어가 디스플레이를 보고 있는 각도) 을 활용하여, 애플리케이션 프로세서가, 그래픽스 드라이버 래퍼를 통해서, GPU 에 의해 실행되는 명령들을 수정하는 방법을 결정할 수도 있다. 시야각을 활용함으로써, 뷰어는 설령 디스플레이가 기울어지거나 또는 뷰어의 헤드가 기울어지더라도 고품질 S3D 그래픽스를 경험할 수도 있다.

종래의 3D 그래픽스 렌더링에서, GPU 는 단일 시점 (예컨대, 모노 뷰) 으로부터 3D 그래픽스를 생성한다. 이 단일 시점 (single point of view) 은 뷰어의 우측 눈 및 좌측 눈 양쪽에 의해 시인가능한 단일 이미지를 의미할 수도 있다. S3D 그래픽스는 S3D 그래픽스가 입체 뷰를 생성한다는 점에서 3D 그래픽스와 상이하다. 용어 입체 뷰는 양안 시점 (binocular point of view) 으로부터 생성되는 이미지들을 지칭한다. 양안 시점에서, 2개의 이미지들이 존재할 수도 있으며, 여기서, 하나의 이미지는 눈들 중 하나에 의해 시인가능하고 나머지 하나는 시인불가능하며, 반대도 마찬가지이다. 예를 들어, 뷰어가 특수 안경을 착용할 때, 안경의 좌측 렌즈를 통해서 들어오는 광은 좌측 눈에 의해 시인가능하지만 우측에 의해 시인불가능하며, 반대로도 마찬가지이다. 양안 시점은 입체 뷰로서 지칭될 수도 있다.

예를 들어, S3D 그래픽스에서, GPU 는 좌측-눈을 위한 이미지 및 우측-눈을 위한 또 다른 이미지 (즉, 입체 뷰) 를 생성할 수도 있다. 좌측-눈 이미지는 뷰어의 우측 눈으로부터 차단되며 단지 좌측 눈으로만 지향된다. 우측-눈 이미지는 뷰어의 좌측 눈으로부터 차단되며 단지 우측 눈으로만 지향된다. 용어 입체 뷰는 디스플레이 상에 각각 디스플레이되는 2개의 이미지들 (예컨대, 좌측-눈 이미지 및 우측-눈 이미지) 를 지칭하며, 반면 모노 뷰는 디스플레이 상에 디스플레이되는 단일 이미지를 지칭한다. 좌측-눈 이미지와 우측-눈 이미지의 조합은 마치 이미지가 이미지들을 디스플레이하고 있는 디스플레이 외부로 나오거나 또는 디스플레이 내로 들어가는 것처럼 뷰어에게 나타나 보일 수도 있다. 이것은 더 실제적이고 더 풍부한 뷰잉 경험을 초래할 수도 있다.

본 개시물에서, S3D 이미지 (예컨대, 입체 뷰) 및 3D 이미지 (예컨대, 모노 뷰) 의 컨셉은 혼동되지 않아야 한다. 3D 이미지는 디스플레이의 2-차원 (2D) 영역에 제한되는 이미지이다. 예를 들어, 3D 그래픽스 프로세싱에서, 애플리케이션은 3D 프리미티브들을 정의하며, 여기서, 프리미티브들은 애플리케이션 콘텐츠의 여러 오브젝트들을 형성한다. 이들 오브젝트들은 디스플레이의 2D 영역에 제한되는 단일 이미지 (예컨대, 모노 뷰) 를 형성한다.

예를 들어, 3D 이미지 내 오브젝트들은 3D 이미지 내 다른 오브젝트들보다 멀리 떨어져 있거나 또는 더 가깝게 보일 수도 있다. 그러나, 이들 오브젝트들의 모두는 디스플레이의 2D 영역에 제한된다. S3D 이미지는 우측-눈 및 좌측-눈 이미지들을 합성하는 뷰어의 두뇌로부터 유래하는 인지된 이미지이다. 최종 이미지 (즉, S3D 이미지) 는 디스플레이의 2D 영역에 제한되지 않는 것처럼 보인다. 대신, S3D 이미지는 3D 체적을 둘러싸는 것처럼 보이며, 여기서, 이미지는 디스플레이 외부로 나오거나 또는 내부로 들어가는 것처럼 보인다. 예를 들어, S3D 이미지 내 오브젝트들은 3D 이미지들의 경우와 같이, 3D 체적 내 다른 오브젝트들보다 더 멀리 떨어져 있거나 또는 더 가까운 것처럼 보이지만, 2D 영역 내 오브젝트들에 대해서는 그렇게 보이지 않는다.

다시 말해서, 3D 그래픽스 프로세싱은 디스플레이의 2D 영역에 제한되는 것처럼 보이는 3D 이미지를 (예컨대, 애플리케이션에 의해 정의되는 3D 프리미티브들에 의해) 생성하는 것을 지칭한다. 이 3D 이미지는 모노 뷰로서 지칭된다. S3D 는 모노 뷰보다는, 입체 뷰의 생성을 위한 렌더링을 지칭한다. 입체 뷰에서, 우측-눈 및 좌측-눈 이미지들은 2D 디스플레이에 제한되며; 그러나, 뷰어가 입체 뷰를 볼 때, 이미지는 3D 체적을 둘러싸는 것처럼 보인다.

S3D 이미지를 함께 형성하는 우측-눈 및 좌측-눈 이미지들은 3D 이미지들일 수도 있다. 뷰어의 두뇌는 그 두뇌가 3D 우측-눈 이미지 및 3D 좌측-눈 이미지를 합성할 때 뷰어로 하여금 S3D 이미지를 인지하도록 한다. 예를 들어, 뷰어가 우측-눈 및 좌측-눈 이미지들 양쪽을 동시에 볼 때, 뷰어는 인간 양안의 시력 (vision) 에 기초하여 장면의 심도를 인지할 수 있다. 우측-눈 이미지 및 좌측-눈 이미지들의 콘텐츠는 단일 3D 이미지의 콘텐츠와 실질적으로 유사할 수도 있다.

고품질 입체적인 효과를 위해서, 단지 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티가 존재할 수도 있다. 예를 들어, 좌측-눈 이미지에서의 오브젝트의 로케이션과 우측-눈 이미지에서의 오브젝트의 로케이션은 상이할 수도 있다. 그러나, 그 차이는 수직 방향이 아닌, 단지 수평 방향에서 있을 수도 있다. 뷰어의 양안의 시력으로 하여금, 오브젝트들이 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어간 것처럼 보이도록, 좌측-눈 이미지 및 우측-눈 이미지를 합성하도록 하는 것은 오브젝트들 사이의 수평 디스패리티이다. 오브젝트들 사이의 임의의 수직 디스패리티는 S3D 효과를 감소시킬 수도 있다.

본 개시물에서 설명하는 기법들에서, 그래픽스 드라이버 또는 그래픽스 드라이버 래퍼를 실행하는 애플리케이션 프로세서는 GPU 로 하여금 모노 뷰에 대한 그래픽스 콘텐츠를 생성하도록 하는 명령들을, GPU 로 하여금 입체 뷰에 대한 그래픽스 콘텐츠를 생성하도록 하는 명령들로 수정할 수도 있다. 다시 말해서, 수정 전에, 명령들은 GPU 로 하여금, 단일 3D 이미지를 생성하도록 할 수도 있다. 수정에 뒤이어서, 명령들은 GPU 로 하여금, 입체 뷰의 2개의 3D 이미지들 (예컨대, 3D 좌측-눈 이미지 및 3D 우측-눈 이미지) 를 생성하도록 할 수도 있다.

본 개시물에서 설명하는 기법들은 일반적으로 3D 이미지들에 대해 개시되지만, 본 개시물의 양태들은 이에 제한되지 않는다는 점에 유의해야 한다. 본 개시물의 기법들은 2D 그래픽스로도 역시 확장될 수도 있다. 예를 들어, 모노 뷰의 단일 이미지는 2D 이미지일 수도 있으며, 본 개시물의 기법들은 GPU 로 하여금, 입체 뷰에 대한 2개의 2D 이미지들을 생성하도록 하기 위해 명령들을 수정할 수도 있다. 이 경우, 뷰어는 입체 뷰에 대한 2개의 이미지들을 디스플레이하고 있는 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어간 단일 이미지를 인지할 것이다. 혼란을 피하기 위해, 아래에서 설명되는 기법들은 모노 뷰에 대한 단일 이미지, 입체 뷰에 대한 좌측-눈 및 우측-눈 이미지들을, 이들 이미지들이 3D 이미지들 또는 2D 이미지들일 수 있다는 점을 포함해서, 참조한다.

본 개시물에서 설명되는 예시적인 기법들에서, 애플리케이션 프로세서는, 그래픽스 드라이버 또는 그래픽스 드라이버 래퍼를 통해서, GPU 에 의해 수행되는 애플리케이션에 의해 발행되는 명령들 및 GPU 에 의해 수행되는 정점 셰이더 프로그램의 명령들을 수정할 수도 있다. 예를 들어, 애플리케이션 프로세서는 애플리케이션을 실행할 수도 있다. 애플리케이션은 단일 이미지 (예컨대, 모노 뷰) 를 생성하도록 설계되었을 수도 있으며, 단일 이미지의 그래픽스 콘텐츠를 복수의 프리미티브들로서 생성할 수도 있다. 게다가, 애플리케이션은 프리미티브들의 각각의 정점에 대해, 칼라, 투명도, 및 좌표 값들과 같은, 픽셀 값들을 결정할 수도 있다.

애플리케이션의 실행 동안 (예컨대, 런-타임에서), 애플리케이션은, 애플리케이션 프로세서를 통해서, 정점 셰이더 프로그램의 명령들을 취출하는 지령을 발행한다. 정점 셰이더 프로그램의 출력은, 실행될 때, 단일 이미지 (예컨대, 모노 뷰) 에 대해 애플리케이션에 의해 생성되는 프리미티브들의 정점들에 대한 클리핑 좌표들일 수도 있다. 예시적인 기법들은 좌측-눈 이미지 및 우측-눈 이미지 (예컨대, 입체 뷰) 에 대한 프리미티브들의 정점들에 대한 클리핑 좌표들을 생성하기 위해 정점 셰이더 프로그램의 명령들을 수정할 수도 있다. 좌측-눈 이미지 및 우측-눈 이미지에 대한 프리미티브들의 정점들에 대한 클리핑 좌표들은 시야각에 기초할 수도 있다.

시야각은 좌측-눈 및 우측-눈 이미지들이 애플리케이션의 실행 동안 디스플레이되고 있는 디스플레이를 뷰어가 보고 있는 각도 (즉, 디스플레이에 대한 뷰어의 뷰잉 배향) 를 지칭한다. 시야각을 결정하는 많은 상이한 방법들이 있을 수도 있다. 본 개시물에서 설명하는 기법들은 시야각을 결정하는 임의의 특정의 방법에 한정되지 않는다.

또한, 애플리케이션의 실행 동안, 애플리케이션은, 애플리케이션 프로세서를 통해서, 그리기 명령을 GPU 로 발행하여, GPU 에게 단일 이미지 내에 프리미티브들 중 하나 이상을 그릴 것을 명령한다. 예를 들어, 본 개시물의 기법들에서, 애플리케이션 프로세서 상에서 실행하는 애플리케이션은 마치 GPU 가 단일 이미지에 대한 그래픽스 콘텐츠를 생성하고 있는 것처럼 명령들을 출력한다. 본원에서 설명되는 기법들은 좌측-눈 및 우측-눈 이미지들에 대한 그래픽스 콘텐츠를 생성하기 위해, 그리기 명령과 같은, 애플리케이션에 의해 발행되는 명령들 중 하나 이상을 수정한다. 이렇게 하여, 애플리케이션의 관점에서 명령들에 대한 어떤 수정도 없다.

예를 들어, 애플리케이션 프로세서는, 그래픽스 드라이버 래퍼를 통해서, 애플리케이션에 의해 발행되는 명령들을 모니터링한다. 애플리케이션이 그리기 명령을 발할 때, 그래픽스 드라이버 래퍼는 이러한 그리기 명령을 캡쳐하고 2개의 그리기 명령들을 발행한다, 여기서, 하나의 명령은 시야각에 기초하여 좌측-눈 이미지에 대한 그래픽 콘텐츠를 생성하는 것이며 하나의 명령은 시야각에 기초하여 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하는 것이다.

시야각은 일정하게 유지되지 않을 수도 있다. 예를 들어, 애플리케이션의 실행 동안, 뷰어는 디바이스를 기울이거나, 그 또는 그녀의 헤드를 기울이거나, 또는 양쪽 모두일 수도 있다. 시야각에서의 변화들의 확률을 설명하기 위해, 애플리케이션 프로세서는 시야각을 주기적으로 결정할 수도 있다. 일 예로서, GPU 가 좌측-눈 이미지와 우측-눈 이미지의 하나의 조합을 출력한 후, 이 기법들은 시야각을 결정할 수도 있다. 이 예에서, 그래픽스 드라이버 래퍼는 GPU 에 의해 렌더링되는 좌측-눈 이미지와 우측-눈 이미지의 다음 조합을 위해 시야각에서의 변화를 설명하기 위해 정점 셰이더의 명령들을 수정할 수도 있다. 이의 대안으로, 프로세서는 시야각을 연속적으로 결정할 수도 있으며, 그래픽스 드라이버 래퍼는 현재의 시야각을 이용하여, 정점 셰이더의 명령들을 수정하는 방법을 결정할 수도 있다.

위에서 설명된 바와 같이, 그래픽스 드라이버 래퍼는 좌측-눈 이미지 및 우측-눈 이미지 양쪽에 대해 프리미티브들에 대한 정점들을 생성하도록 정점 셰이더의 명령들을 수정할 수도 있다. 예를 들어, 이 기법들은 수정된 정점 셰이더로 하여금 두번 실행하게 할 수도 있다. 실행의 제 1 인스턴스에서, 수정된 정점 셰이더는 정점의 클리핑 좌표들을 시야각에 기초하여 제 1 방향으로 변위시킬 수도 있으며, 실행의 제 2 인스턴스에서, 수정된 정점 셰이더는 정점의 클리핑 좌표들을 시야각에 기초하여 제 2 방향으로 변위시킬 수도 있다. GPU 는 제 1 방향으로 변위된 정점들을 프로세싱하여 좌측-눈 이미지를 렌더링할 수도 있으며, 제 2 방향으로 변위된 정점들을 프로세싱하여 우측-눈 이미지를 렌더링할 수도 있다.

그러나, 클리핑 좌표들의 모두를 제 1 방향으로 변위시킨 후 클리핑 좌표들의 모두를 제 2 방향으로 변위시키는 것은, 애플리케이션에 의해 생성되는 단일 이미지의 모든 오브젝트들이 좌측-눈 이미지 및 우측-눈 이미지를 디스플레이하고 있는 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어간 것처럼 보이는 입체 뷰를 초래할 수도 있다. 예를 들어, 애플리케이션에 의해 생성되는 프리미티브들은 상이한 오브젝트들을 형성할 수도 있다. 좌측-눈 이미지를 생성하기 위해 프리미티브들의 모두의 클리핑 좌표들을 제 1 방향으로 변위시키고 그리고 우측-눈 이미지를 생성하기 위해 프리미티브들의 모두의 클리핑 좌표들을 제 2 방향으로 변위시킴으로써, 오브젝트들의 모두는 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어간 것처럼 보일 수도 있다.

이러한 결과는 인간 양안 시력에 대해 이상적이지 않을 수도 있다. 예를 들어, 뷰어는 오브젝트들의 일부가 다른 오브젝트들보다 많이 나오오기를 원할 수도 있다. 또 다른 예로서, 오브젝트들의 모두가 동일한 양 만큼 디스플레이 외부로 나오거나 또는 내부로 들어가더라도, 뷰어는 오브젝트들이 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어가는 양을 제어하는 것을 원할 수도 있다.

좀더 자세하게 설명되는 바와 같이, 애플리케이션 프로세서는, 그래픽스 드라이버 래퍼를 통해서, 또한 오브젝트들의 일부가 다른 오브젝트들보다 많이 디스플레이 외부로 나오거나 또는 내부로 들어가도록, 정점 셰이더의 명령들을 수정할 수도 있다. 일부 예들에서, 일부 오브젝트들이 다른 오브젝트들보다 많이 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어갈 수 있도록 정점 셰이더의 명령들을 수정하는 것에 더해 또는 그 대신에, 애플리케이션 프로세서는, 그래픽스 드라이버 래퍼를 통해서, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 증가시키거나 또는 감소시키는 명령들을 수정할 수도 있다. 이러한 방법으로, 뷰어는 입체 뷰가 디스플레이 외부로 나오거나 또는 디스플레이 내에 들어가는 양을 제어가능할 수도 있다.

도 1 은 본 개시물에서 설명된 하나 이상의 예들에 따른, 입체 뷰를 디스플레이하고 있는 디스플레이를 예시하는 개념도이다. 도 1 은 디바이스 (10) 를 예시한다. 디바이스 (10) 의 예들은 모바일 무선 전화기들, 개인 휴대정보 단말기들 (PDAs), 비디오 디스플레이들을 포함하는 비디오 게이밍 콘솔들, 모바일 화상 회의 유닛들, 랩탑 컴퓨터들, 데스크탑 컴퓨터들, 텔레비전 셋-탑 박스들, 디지털 미디어 플레이어들, 태블릿 컴퓨팅 디바이스, 스마트폰들 등을 포함하지만 이에 한정되지 않는다. 디바이스 (10) 는 디스플레이 (12) 를 포함한다. 디스플레이 (12) 의 예들은 액정 디스플레이 (LCD), 유기 발광 다이오드 디스플레이 (OLED), 음극선관 (CRT) 디스플레이, 플라즈마 디스플레이, 편광 디스플레이, 또는 또 다른 유형의 디스플레이 디바이스를 포함하지만 이에 한정되지 않는다. 디스플레이 (12) 는 입체 뷰 (예컨대, 좌측-눈 이미지 및 우측-눈 이미지) 를 디스플레이하도록 구성되는 임의 종류의 디스플레이일 수도 있다.

예시된 바와 같이, 디스플레이 (12) 는 3D 이미지 (14A) 및 3D 이미지 (14B) 를 디스플레이한다. 도 1 은 이미지 (14A) 를 실선 박스로서, 그리고 이미지 (14B) 를 파선 박스로서 예시한다. 이미지 (14A) 및 이미지 (14B) 는 각각 3D 이미지일 수도 있다. 예를 들어, 이미지 (14A 및 14B) 의 각각의 하나가 개별적으로 보여지면, 이미지 (14A 및 14B) 는 디스플레이 (12) 외부로 나오거나 또는 디스플레이 (12) 내에 들어간 것처럼 보이지 않을 것이다 (예컨대, 마치 모노 뷰처럼 보일 것이다).

그러나, 이미지 (14A) 및 이미지 (14B) 가 함께 보여질 때, 이미지 (14A) 및 이미지 (14B) 는 함께 입체 뷰를 형성한다. 예를 들어, 이미지 (14A) 및 이미지 (14B) 는 유사한 이미지 콘텐츠를 포함할 수도 있으며, 그러나 디스플레이 (12) 상에서 변위되지 않는다. 뷰어에 의해 착용되는 특수 안경은 뷰어의 우측 눈이 이미지 (14A) 를 보는 것을 차단하고, 뷰어의 좌측 눈이 이미지 (14B) 를 보는 것을 가능하게 할 수도 있다. 특수 안경은 또한 뷰어의 좌측 눈이 이미지 (14B) 를 보는 것을 차단하고, 뷰어의 우측 눈이 이미지 (14A) 를 보는 것을 가능하게 할 수도 있다. 뷰어가 이미지들 (14A 및 14B) 을 함께 볼 때, 이미지 (14A) 과 이미지 (14B) 사이의 수평 디스패리티는 뷰어가 S3D 이미지 (즉, 디스플레이 (12) 뒤에 있거나 또는 디스플레이 (12) 앞에 있는 것처럼 보이며 3D 체적을 둘러싸는 이미지) 를 인지하도록 초래할 수도 있다. 다시 말해서, 이미지 (14A) 는 입체 뷰의 좌측-눈 이미지이며, 이미지 (14B) 는 입체 뷰의 우측-눈 이미지이다.

디바이스 (10) 의 프로세서 상에서 실행하는 애플리케이션은 단일 이미지 (예컨대, 모노 뷰) 를 생성할 수도 있다. 예를 들어, 애플리케이션을 실행하는 프로세서는 단일 이미지의 이미지 콘텐츠를 복수의 프리미티브들로서 생성할 수도 있다. 이 단일 이미지의 이미지 콘텐츠는 이미지 (14A) 및 이미지 (14B) 의 이미지 콘텐츠와 유사할 수도 있다. 게다가, 애플리케이션을 실행하는 프로세서는 프리미티브들의 각각의 정점에 대해, 칼라, 투명도, 및 좌표 값들과 같은, 픽셀 값들을 결정할 수도 있다. 프리미티브들의 픽셀 값들은 이미지 데이터로서 지칭될 수도 있다. 애플리케이션을 실행하는 프로세서는 이미지 데이터 및 명령들을 디바이스 (10) 의 그래픽 프로세싱 유닛 (GPU) 으로 출력하여, GPU 에게 단일 이미지를 렌더링할 것을 명령할 수도 있다.

본 개시물에서 설명하는 기법들에 따르면, 프로세서는 GPU 에게 단일 이미지를 렌더링하도록 지령하는 GPU 로의 지령들을 캡쳐할 수도 있다. 예를 들어, 프로세서는 그래픽스 드라이버 또는 그래픽스 드라이버 래퍼를 실행할 수도 있고, 프로세서는 단일 이미지를 렌더링하기 위해, 그래픽스 드라이버 또는 그래픽스 드라이버 래퍼를 통해서, GPU 로의 지령들을 캡쳐할 수도 있다. 예시의 목적을 위해, 본 기법들은 그래픽스 드라이버 래퍼를 실행하는 프로세서에 의해 수행되는 것으로 설명된다. 일반적으로, 본 기법들은 설명의 용이성을 위해 여러 기능들을 수행하는 그래픽스 드라이버 래퍼를 기술한다. 그러나, 프로세서가 그래픽스 드라이버 래퍼의 실행을 통해서 본 기법들을 구현하고 있는 것으로 이해되어야 한다.

예를 들어, 그래픽스 드라이버 래퍼는 프로세서 상에서 실행하는 프로그램일 수도 있다. 그래픽스 드라이버 래퍼는 수정된 명령들이 GPU 로 하여금, 입체 뷰를 렌더링하도록, 그래픽스 드라이버가 수신하는 명령들 또는 그래픽스 드라이버가 출력하는 명령들을 수정할 수도 있다. 따라서, 본 개시물에서 설명하는 기법들은 그래픽스 드라이버에 대한 어떤 수정을 필요로 하지 않을 수도 있다. 대신, 프로세서는 그래픽스 드라이버 래퍼를 실행하고, 이전에 개발된 그래픽스 드라이버를 실행할 수도 있다. 그러나, 본 개시물에서 설명하는 기법들을 구현하기 위해 기존 그래픽스 드라이버들을 수정하거나 또는 새로운 그래픽스 드라이버들을 생성하는 것이 가능할 수도 있다.

그래픽스 드라이버 래퍼를 실행하는 프로세서는 프로세서에 의해 발행되는 지령들을 수정하고, GPU 로 하여금, 입체 뷰를 형성하는 2개의 이미지들 (예컨대, 이미지 (14A) 및 이미지 (14B)) 을 렌더링하게 할 수도 있다. 게다가, 그래픽스 드라이버 래퍼를 실행하는 프로세서는 GPU 상에서 실행하는 셰이더 프로그램 (예컨대, 정점 셰이더) 의 명령들을 수정할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼는 수정된 정점 셰이더가, GPU 상에서 실행될 때, 프로세서를 실행하는 애플리케이션에 의해 생성되는 단일 이미지에서 픽셀의 위치를 변위시키도록, 정점 셰이더의 명령들을 수정할 수도 있다. 그래픽스 드라이버 래퍼는 GPU 로 하여금, 수정된 정점 셰이더를 두번 실행시키도록 할 수도 있다. 수정된 정점 셰이더의 제 1 실행에서, 수정된 정점 셰이더는 단일 이미지에서의 픽셀들의 위치들을 하나의 방향으로 변위시킨다. 수정된 정점 셰이더의 제 2 실행에서, 수정된 정점 셰이더는 단일 이미지에서의 픽셀들의 위치들을 제 2 실행에서 또 다른 방향으로 변위시킨다. 이미지 (14A) 는 정점 셰이더가 단일 이미지의 픽셀들을 하나의 방향으로 변위시키는 것으로부터 유래하는 이미지일 수도 있다. 이미지 (14B) 는 정점 셰이더가 단일 이미지의 픽셀들을 또 다른 방향으로 변위시키는 것으로부터 유래하는 이미지일 수도 있다.

정점 셰이더의 명령들을 수정할 때에, 그래픽스 드라이버 래퍼를 실행하는 프로세서는 시야각을 활용할 수도 있다. 시야각 (viewing angle) 은 뷰어가 디스플레이 (12) 를 보고 있는 각도이다. 예를 들어, 도 1 에서, 디스플레이 (12) 는 풍경 모드에 있는 것으로 간주될 수도 있다. 뷰어가 디스플레이 (12) 바로 앞에서 보고 있으면 (즉, 뷰어가 그 또는 그녀의 헤드를 기울이지 않으면), 시야각은 제로로 간주될 수도 있다. 그러나, 뷰어가 디바이스 (10) 를 기울이거나 또는 그 또는 그녀의 헤드를 기울이면, 시야각은 더 이상 제로가 아닐 수도 있다. 예를 들어, 뷰어가 디바이스 (10) 를 인물 모드에 있도록 회전하면 (예컨대, 디바이스 (10) 를 90° 만큼 기울이면), 시야각은 90° 일 수도 있다.

풍경 모드에서 제로, 그리고 인물 모드에서 90° 인 시야각이 예시의 목적을 위해 제공되며 제한하는 것으로 간주되지 않아야 하는 것으로 이해되어야 한다. 본 개시물에서 설명하는 기법들은 또한 시야각이 인물 모드에서 제로이고 풍경 모드에서 90° 인 상황들, 또는 풍경 모드와 인물 모드 사이의 임의의 모드에 적용한다.

일반적으로, 디바이스 (10) 의 프로세서는 시야각을 결정할 수도 있으며, 프로세서는, 프로세서 상에서 실행하는 그래픽스 드라이버 래퍼를 통해서, 시야각에 기초하여, 애플리케이션에 의해 GPU 로 출력되는 명령들 및 GPU 상에서 실행하는 셰이더 프로그램의 명령들을 수정할 수도 있다. 그래픽스 드라이버 래퍼는 GPU 가 모노 뷰를 형성하는 단일 이미지보다는, 입체 뷰를 형성하는 2개의 이미지들을 렌더링하도록, 명령들을 수정할 수도 있다.

도 2 는 상이한 시야각들을 예시하는 개념도이다. 예시의 목적을 위해, 도 2 는 뷰어가 디바이스 (10) 를 기울일 수도 있는 상이한 각도들을 예시한다. 그러나, 본 개시물에서 설명하는 기법들은 또한 뷰어가 기울기 디바이스 (10) 를 기울이지 않지만, 대신에, 그 또는 그녀의 헤드를 기울이는 예들, 또는 이 2개의 조합으로 확장가능할 수도 있다.

대부분의 입체적인 3D 디스플레이들은 디바이스 배향에 관한 구속과 함께 사용되어야 한다. 예를 들어, 대부분의 모든 3D 텔레비전들은 풍경 모드에서 보여진다. 이것은 수평 표면 (TV 캐비닛, 데스크탑, 등) 상에서 사용을 위해 셋업되는 많은 디바이스들에 대해 적당하다. 그러나, 폰들 및 태블릿들과 같은, 핸드헬드 디바이스들에 있어, 뷰어는 디스플레이를 풍경 또는 인물 모드들에서, 또는 심지어 어떤 각도의 배향으로 볼 수도 있다.

예를 들어, 위치 18A 에서, 디바이스 (10) 는 풍경 모드에 있다. 설명의 용이성을 위해, 도 2 는 디바이스 (10) 가 풍경 모드에 있을 때 디바이스 (10) 의 우상단 모서리에 로케이트되는 배향 지점 (16) 을 예시한다. 뷰어는 디바이스 (10) 를 45° 만큼 (즉, 위치 18A 로부터 위치 18B 까지) 기울일 수도 있다. 이 경우, 도 2 는 위치 18B 에서 배향 지점 (16) 이 위치 18A 에서의 배향 지점에 대해 우측, 하단 방향으로 이동한 것을 예시한다. 이 예에서, 시야각은 45° 로서 간주될 수도 있다.

또 다른 예로서, 뷰어는 디바이스 (10) 를 -45° 만큼 (즉, 위치 18A 로부터 위치 18C 까지) 기울일 수도 있다. 이 경우, 도 2 는 위치 18C 에서, 배향 지점 (16) 이 위치 18A 에서의 배향 지점에 대해 좌측, 상단 방향으로 이동한 것을 예시한다. 이 예에서, 시야각은 -45° 로서 간주될 수도 있다. 뷰어가 디바이스 (10) 를 임의의 양 만큼 기울일 수도 있기 때문에, 시야각은 -180° 로부터 180° 까지의 범위일 수도 있다.

예를 들어, 풍경 및 인물은 2개의 전형적인 디스플레이 모드들이다 (예컨대, 뷰어가 디바이스 (10) 를 풍경 모드로부터 인물 모드로 회전하거나, 또는 반대로도 회전한다). 이들 경우들에서, 디바이스 (10) 는 디바이스 (10) 가 풍경 모드 또는 인물 모드에 있는지를 결정할 수도 있으며, 프로세서는, 그래픽스 드라이버 래퍼를 통해서, GPU 로 하여금, 풍경 모드 또는 인물 모드에 대하여 좌측-눈 이미지 및 우측-눈 이미지를 렌더링하도록 하는 명령들을 수정할 수도 있다. 그러나, 뷰어는 디바이스 (10) 를 임의의 각도로 배향할 수도 있으며, 꼭 풍경 모드 또는 인물 모드에 있지 않을 수도 있다. 따라서, 프로세서는 시야각을 활용하여, GPU 상에서 실행되는 명령들을 수정하는 방법을 결정할 수도 있다.

시야각을 결정하는 여러 방법들이 있을 수도 있다. 예를 들어, 디바이스 (10) 는 디바이스 (10) 가 풍경 모드로부터 인물 모드로 스위칭할지 여부를 결정하는데 사용하는 가속도계를 포함할 수도 있다. 디바이스 (10) 는 또한 적합한 가속도의 크기 및 방향을 검출하기 위해 가속도계의 단일- 또는 멀티-축 모델들을 포함할 수도 있다. 이러한 가속도계는 중량 변화들의 방향에 기초하여 배향을 출력할 수도 있다. 디바이스 (10) 의 프로세서는 출력 배향에 기초하여 시야각을 결정할 수도 있다.

또 다른 예로서, 디바이스 (10) 는 자이로스코프를 포함할 수도 있다. 자이로스코프는 각 운동량의 보존의 원리들에 기초하여 배향의 측정치를 제공할 수도 있다. 디바이스 (10) 의 프로세서는 자이로스코프에 의해 제공되는 배향의 측정치에 기초하여 시야각을 결정할 수도 있다. 소비자 전자 디바이스들에 사용되는 전자, 마이크로칩-패키지된 MEMS 자이로스코프 디바이스들과 같은, 다른 동작 원리들에 기초한 자이로스코프들이 또한 존재한다. 자이로스코프는 가속도계보다 3D 공간 내에서 이동의 더 정확한 인식을 제공할 수도 있다.

가속도계 또는 자이로스코프의 출력들은 프로세서로 하여금 적당한 시야각의 추정을 결정가능하게 할 수도 있다. 그러나, 시야각의 추정은 뷰어가 특정의 방법으로, 예컨대, 수직으로 배향된다 (예컨대, 뷰어가 그 또는 그녀의 헤드를 기울이지 않는다) 는 가정에 기초할 수도 있다. 다시 말해서, 가속도계 또는 자이로스코프는 시야각의 적당한 추정치를 결정하기에 충분할 수도 있는 디스플레이 배향의 정확한 측정치를 제공할 수도 있지만, 뷰어 배향의 정확한 측정치를 제공하지 않을 수도 있다.

일부 예들에서, 디바이스 (10) 의 프로세서가 뷰어의 배향 (예컨대, 뷰어가 수직으로 배향되는지 여부, 또는 뷰어가 그 또는 그녀의 헤드를 기울이는지 여부) 을 결정하는 것이 가능할 수도 있다. 예를 들어, 디스플레이 (12) 또는 디바이스 (10) 는 내장형 전방 (front-facing) 카메라를 포함할 수도 있다. 전방 카메라에 의해, 카메라 프로세서는 뷰어의 눈들 또는 디스플레이 (12) 에 대한 뷰어의 헤드 배향을 검출할 수도 있다. 디바이스 (10) 의 프로세서는 카메라 프로세서에 의해 검출되는 바와 같은, 검출된 눈들 또는 헤드 배향에 기초하여, 시야각을 결정할 수도 있다.

통상의 광학 카메라에 더해서, 다른 센서들이 또한 뷰어의 눈들 또는 헤드 배향을 검출하도록 구성될 수도 있다. 일반적으로, 본 개시물에서 설명하는 기법들은 사용자의 눈들 또는 헤드를 검출하는 것에 반드시 의존하지는 않는 기법들을 포함한, 시야각을 결정하는 임의의 기법을 이용할 수도 있다. 본 개시물에서 설명하는 기법들은 시야각을 결정하기 위한 위에서 설명된 예들에 한정되는 것으로 간주되지 않아야 한다.

예를 들어, 본 개시물에서 설명하는 기법들은 단지 가속도계 및/또는 자이로스코프의 출력들에 기초하여, 시야각을 결정할 수도 있다. 또 다른 예로서, 본 개시물에서 설명하는 기법들은 사용자의 검출된 눈들 또는 헤드에 기초하여, 시야각을 결정할 수도 있다. 또 다른 예로서, 본 개시물에서 설명하는 기법들은 가속도계 및/또는 자이로스코프의 출력들에 기초하여, 그리고 사용자의 검출된 눈들 또는 헤드에 기초하여, 시야각을 결정할 수도 있다. 또 다른 예로서, 이 기법들은 가속도계 및/또는 자이로스코프의 출력들에 기초하여, 그리고 사용자의 뷰잉 배향을 결정하도록 구성되는 하나 이상의 다른 센서들에 기초하여, 시야각을 결정할 수도 있다. 상기 뿐만 아니라, 임의의 다른 기법들의 임의의 치환 및 조합이 시야각을 결정하는데 이용될 수도 있다.

도 3 은 뷰어의 눈들 및 헤드 배향의 검출을 예시하는 개념도이다. 도 3 에서, 디바이스 (10) 의 디스플레이 (12) 는 디바이스 (10) 의 카메라에 의해 캡쳐되는 얼굴을 디스플레이한다. 디스플레이 (12) 가 시야각을 결정하기 위해 카메라에 의해 캡쳐되는 이미지를 디스플레이할 필요가 없는 것으로 이해되어야 하며, 도 3 은 예시의 용이를 위해 카메라에 의해 캡쳐되는 얼굴을 디스플레이하는 디스플레이 (12) 를 예시한다.

도 3 에 예시된 바와 같이, 디바이스 (10) 는 풍경 모드에 있으며; 그러나, 뷰어의 헤드가 기울여 있다. 이 경우, 디바이스 (10) 의 카메라 프로세서는 눈들 (20A 및 20B) 의 배향을 검출하고, 눈들 (20A 및 20B) 의 배향을 디바이스 (10) 의 프로세서로 송신할 수도 있다. 눈들 (20A 및 20B) 의 배향에 기초하여, 디바이스 (10) 의 프로세서는 시야각을 결정할 수도 있다. 본 개시물에서 설명하는 기법들에 따르면, 그래픽스 드라이버 래퍼는 결정된 시야각에 기초하여 GPU 상에서 실행하는 명령들을 수정할 수도 있다.

도 4 는 시야각의 일 예를 예시하는 개념도이다. 도 4 에서, 시야각은 alpha (α) 로서 라벨링된다. 시야각은 뷰어의 뷰잉 배향과 디스플레이의 배향 사이의 관계이다. 예를 들어, alpha 는 눈의 수평 방향 및 디스플레이의 수평 방향에 의해 형성되는 각도의 측정치이다. 디스플레이의 수평 방향은 디스플레이의 배향에 대한 수평면을 지칭하며, 눈의 수평 방향은 뷰어의 눈들 (20A 및 20B) 의 배향에 대한 수평면을 지칭한다. 도 4 에서, 뷰어는 디스플레이 (12) 를 일직선으로 보고 있다 (예컨대, 뷰어의 헤드에서 어떤 기울임도 없다). 따라서, 눈의 수평 방향은 수평 라인이다. 도 4 에서, 디바이스 (10) 는 일정 각도로 기울어져 있으며, 풍경 모드 또는 인물 모드에 있지 않다. 따라서, 디스플레이의 수평 방향은 디바이스 (10) 에 대해 수평이지만, 눈의 수평 방향에 대해 각진 라인이다.

도 5 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 디바이스의 일 예를 예시하는 블록도이다. 예를 들어, 도 5 는 디바이스 (10) 를 좀더 상세히 예시한다. 도 5 에 예시된 바와 같이, 디바이스 (10) 는 애플리케이션 프로세서 (22), 그래픽 프로세싱 유닛 (GPU) (30), 시스템 메모리 (36), 하나 이상의 센서들 (42) 및 카메라 프로세서 (44) 를 포함할 수도 있다. 디바이스 (10) 는 도 5 에 예시된 구성요소들에 더해서, 구성요소들을 포함할 수도 있다.

더욱이, 일부 예들에서, 애플리케이션 프로세서 (22), GPU (30), 및 카메라 프로세서 (44) 는 단일 회로 패키지 내에 하우징되는 공통 집적 회로로서 형성될 (예컨대, 공통 프로세서로서 형성될) 수도 있다. 그러나, 본 개시물의 양태들은 이에 제한되지 않으며, 애플리케이션 프로세서 (22), GPU (30), 및 카메라 프로세서 (44) 중 하나 이상은 별개의 회로 패키지들에 하우징되는 별개의 집적 회로들일 수도 있다.

하나 이상의 센서들 (42) 은 디바이스 (10) 의 배향의 측정치를 애플리케이션 프로세서 (22) 로 출력하도록 구성될 수도 있다. 하나 이상의 센서들 (42) 의 예들은 가속도계 및 자이로스코프를 포함한다. 카메라 프로세서 (44) 는 디바이스 (10) 의 카메라 (미도시) 또는 디스플레이 (12) 의 카메라 (미도시) 에 의해 캡쳐되는 이미지들로부터의 이미지 데이터를 수신할 수도 있다. 본 개시물에서 설명하는 기법들에서, 카메라는 사용자-개입 없이 그리고 백그라운드에서 이미지들을 연속적으로 캡쳐하도록 구성될 수도 있다. 예를 들어, 캡쳐된 이미지들은 디스플레이되거나 또는 추후 취출을 위해 저장될 필요가 없다. 캡쳐된 이미지들로부터, 카메라 프로세서 (44) 는 뷰어의 배향을 결정할 수도 있다.

카메라 프로세서 (44) 는 뷰어의 눈들의 배향을 결정하여 뷰어의 배향을 결정할 수도 있다. 카메라 프로세서 (44) 는 카메라 프로세서 (44) 가 뷰어의 눈들의 배향을 결정하는 뷰어의 눈들을 식별하기 위해 임의의 기법을 구현할 수도 있다. 많은, 현재의 카메라 프로세서들은 뷰어의 눈들을 식별하도록 구성되며, 이들 현재의 카메라 프로세서들은 카메라 프로세서 (44) 의 일 예일 수도 있다.

하나 이상의 센서들 (42) 은 디바이스 (10) 의 배향의 측정치를 애플리케이션 프로세서 (22) 로 출력할 수도 있다. 카메라 프로세서 (44) 는 뷰어 배향의 측정치를 애플리케이션 프로세서 (22) 로 출력할 수도 있다. 애플리케이션 프로세서 (22) 는 디바이스 (10) 의 배향의 측정치 및 뷰어의 배향의 측정치에 적어도 기초하여 시야각을 결정할 수도 있다. 예를 들어, 애플리케이션 프로세서 (22) 는 시야각을 디바이스 (10) 의 배향과 뷰어의 배향 사이의 각도인 것으로 결정할 수도 있다. 좀더 자세하게 설명되는 바와 같이, 애플리케이션 프로세서 (22) 는 시야각을 이용하여, 정점 셰이더 (38) 의 명령들을 수정하는 방법을 결정할 수도 있다.

카메라 프로세서 (44) 는 모든 예에서 필요하지 않을 수도 있다. 예를 들어, 디바이스 (10) 의 배향의 측정치는 애플리케이션 프로세서 (22) 가 시야각을 결정하기에 충분할 수도 있다. 이들 예들에서, 애플리케이션 프로세서 (22) 는 뷰어 배향의 측정치에 의해 미리 구성될 수도 있다. 애플리케이션 프로세서 (22) 는 디바이스 (10) 의 배향의 측정치 및 뷰어 배향의 미리 구성된 측정치에 기초하여 시야각을 결정할 수도 있다. 또 다른 예로서, 애플리케이션 프로세서 (22) 는 하나 이상의 센서들 (42) 의 출력들을 이용함이 없이, 뷰어의 배향의 측정치에 기초하여, 시야각을 결정할 수도 있다. 이 예에서, 애플리케이션 프로세서 (22) 는 디바이스 (10) 의 배향으로 미리 구성될 수도 있다 (예컨대, 하나 이상의 센서들 (42) 의 출력들을 이용하지 않을 때 디바이스 (10) 의 배향이 풍경이라고 결정하도록 미리 구성될 수도 있다).

시야각을 결정하는데 하나 이상의 센서들 (42) 및 카메라 프로세서 (44) 를 이용하는 것은 단지 예시의 목적을 위해 제공되며, 제한하는 것으로 간주되지 않아야 한다. 애플리케이션 프로세서 (22) 가 시야각을 결정 수 있는 다른 방법들이 있을 수도 있으며, 본 개시물에서 설명하는 기법들은 이러한 다른 기법들로 확장가능하다.

일부 예들에서, 애플리케이션 프로세서 (22) 는 뷰어가 시야각을 변경할 수도 있기 때문에, 시야각을 입체 뷰의 생성 당 한번 결정할 수도 있다. 예를 들어, GPU (30) 는 입체 뷰의 좌측-눈 이미지 및 우측-눈 이미지와 같은, 렌더링된 이미지들을 출력할 수도 있다. 좌측-눈 이미지 및 우측-눈 이미지 양쪽의 모든 출력 이후, 애플리케이션 프로세서 (22) 는 시야각을 결정할 수도 있다. 또 다른 예로서, 애플리케이션 프로세서 (22) 는 시야각을 연속적으로 결정할 수도 있다. 좀더 자세하게 설명되는 바와 같이, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 가 다음 이미지를 프로세싱할 때 정점 셰이더 (38) 가 애플리케이션 프로세서 (22) 에 의해 결정되는 바와 같은, 다음 좌측-눈 이미지 및 다음 우측-눈 이미지에 대한 클리핑 좌표들을 생성할 수 있도록, 현재, 결정된 시야각에 기초하여, 정점 셰이더 (38) 의 명령들을 수정할 수도 있다.

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

일부 예들에서, GPU (30) 는 구체적으로 말하면 그래픽스 프로세싱용으로 설계된 특수화된 하드웨어일 수도 있다. 예를 들어, 그래픽스 프로세싱은 빠른 병렬 프로세싱을 필요로 할 수도 있으며, GPU (30) 는 특히 이러한 빠른 병렬 프로세싱용으로 설계될 수도 있다. GPU (30) 는 일반적인 프로세싱 태스크와 같은, 그래픽스 프로세싱에 더해서, 태스크들을 수행하는 것이 가능할 수도 있다. 따라서, GPU (30) 는 일반적인 프로세싱 GPU (GPGPU) 로서 간주될 수도 있다. 본 개시물에서 설명하는 기법들은 GPU (30) 가 단지 그래픽스 관련 작업들을 수행하는 예들 또는 GPU (30) 가 GPGPU 인 예들에 적용할 수도 있다.

시스템 메모리 (36) 는 컴퓨터-판독가능 저장 매체의 일 예일 수도 있다. 예를 들어, 시스템 메모리 (36) 는 애플리케이션 프로세서 (22) 및 GPU (30) 로 하여금 본 개시물에서 각각에 속하는 것으로 생각되는 기능들을 수행하게 하는 명령들을 저장할 수도 있다. 시스템 메모리 (36) 는 하나 이상의 프로세서들 (예컨대, 애플리케이션 프로세서 (22) 또는 GPU (30)) 로 하여금 여러 기능들을 수행하도록 하는 명령들을 포함하는 컴퓨터-판독가능 저장 매체로서 간주될 수도 있다.

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

GPU (30) 는 셰이더 프로세서 (32) 및 고정-기능 파이프라인 (34) 을 포함할 수도 있다. 셰이더 코어로서 종종 지칭되는, 셰이더 프로세서 (32) 는 정점 셰이더들 및 프래그먼트 셰이더들과 같은 셰이더 프로그램들이 실행되는 GPU (30) 의 코어일 수도 있다. 고정-기능 파이프라인 (34) 은 고정 기능들을 수행하는 하드웨어 유닛들을 포함할 수도 있다. 다시 말해서, 정점 셰이더들 및 프래그먼트 셰이더들과 같은 셰이더 프로그램들은 셰이더 프로세서 (32) 상에서 실행하며 기능적 유연성을 가능하게 하는 소프트웨어 유닛들일 수도 있으며, 반면, 고정-기능 파이프라인 (34) 은 고정 기능들 및 최소의 기능적 유연성을 가진 하드웨어 유닛들을 포함한다.

예를 들어, GPU 의 일부 이전 버전들은 그래픽스 파이프라인에서 단지 고정-기능 유닛들을 포함하였다. GPU (30) 에서, 이전 GPU 의 버전의 고정-기능 그래픽스 파이프라인은 정점 셰이더 (38) 와 같은 정점 셰이더들 및 프래그먼트 셰이더들에 의해 부분적으로 대체된다. 예를 들어, 정점 셰이더 (38) 는 GPU들의 이전 버전들에서 고정-기능 유닛들에 의해 수행되었던, 모델 뷰 변환, 조명, 및 투영과 같은, 기능들을 수행할 수도 있다. 프래그먼트 셰이더들은 GPU들의 이전 버전들에서의 고정-기능 유닛들의 프래그먼트 스테이지의 기능들을 수행할 수도 있다.

본 개시물에서 설명되는 예시적인 기법들은 수정된 셰이더 프로그램들이 셰이더 프로세서 (32) 상에서 실행될 때 GPU (30) 가 시야각에 기초하여 S3D 이미지들 (예컨대, 입체 뷰) 에 대한 그래픽스 데이터를 생성하도록, (예컨대, 모노 뷰에 대한) 단일 3차원의 (3D) 이미지를 생성하도록 설계된 셰이더 프로그램들을, 수정할 수도 있다. 또, 위에서 설명한 바와 같이, 입체 뷰는 좌측-눈 이미지 및 우측-눈 이미지를 포함한다. 좌측-눈 이미지 및 우측-눈 이미지는 실질적으로 유사한 그래픽스 콘텐츠를 모노 뷰 이미지로서 포함하며; 그러나, 좌측-눈 및 우측-눈 이미지들의 하나 이상의 대응하는 픽셀들은 서로에 대해 수평축을 따라서 변위될 수도 있다.

예를 들어, 우측-눈 이미지가 좌측-눈 이미지의 상부 상에 배치된다고 가정한다. 이 경우, 우측-눈 이미지에서의 콘텐츠 모두는 좌측-눈 이미지에서의 동일한 콘텐츠와 정확히 정렬하지 않을 수도 있다. 대신, 우측-눈에서 하나 이상의 오브젝트들은 좌측-눈 이미지에서 동일한 오브젝트들의 좌측 또는 우측에 있을 수도 있다 (예컨대, 우측-눈 이미지와 좌측-눈 이미지에서 오브젝트들 사이에 수평 디스패리티가 존재할 수도 있다). 고품질 입체적인 효과를 위해, 우측-눈 이미지 및 좌측-눈 이미지에서 오브젝트들 사이에 수직 디스패리티가 존재하지 않을 수도 있다.

좌측-눈 이미지는 뷰어의 좌측 눈에 의해 시인가능하며, 우측-눈 이미지는 뷰어의 좌측 눈으로부터 차단된다. 우측-눈 이미지는 뷰어의 우측 눈에 의해 시인가능하며, 좌측-눈 이미지는 뷰어의 우측 눈으로부터 차단된다. 일부 예들에서, 뷰어는 좌측-눈 이미지가 우측 눈에 의해 시인하는 것, 및 우측-눈 이미지가 좌측 눈에 의해 시인하는 것으로부터 차단하는 특수 안경을 착용할 수도 있다. 그러나, 본 개시물의 양태들은 반드시 뷰어가 특수 안경을 착용하는 것을 필요로 하지 않는다. 예를 들어, 일부 디스플레이들은 뷰어가 입체 뷰를 경험하기 위해 특수 안경을 착용할 필요가 없다. 본 개시물의 기법들은 이러한 디스플레이들로 확장될 수도 있다.

GPU (30) 는 뷰어가 좌측-눈 이미지 및 우측-눈 이미지 양쪽을 동시에 볼 때 뷰어의 두뇌가 뷰어로 하여금, 디스플레이 외부로 나오거나 또는 2개의 이미지들을 디스플레이하는 디스플레이 내로 들어가는 (예컨대, 디스플레이 앞에 또는 뒤에 있는 것처럼 보이는) 이미지를 인지할 수 있도록, 좌측-눈 이미지 및 우측-눈 이미지에 대한 그래픽스 데이터를 생성할 수도 있다. 이 나오는 것 또는 눌러 들어가는 것은, 실질적으로 유사한 콘텐츠를 가진 입체 뷰의 2개의 이미지들에서 수평 불일치들을 해결하는 뷰어의 두뇌 때문이다. 예를 들어, 뷰어의 양안의 시력은 뷰어로 하여금 좌측-눈 이미지 및 우측-눈 이미지 양쪽을 동시에 볼 수 있게 하며, 뷰어는 심도를 인지함으로써 좌측-눈 및 우측-눈 이미지들에서 수평 불일치들을 해결한다.

일 예로서, 애플리케이션 프로세서 (22) 는 시스템 메모리 (36) 에 저장된, 애플리케이션 (42) 과 같은, 하나 이상의 애플리케이션들을 실행할 수도 있다. 애플리케이션 (32) 의 예들은 웹 브라우저들, 사용자 인터페이스들, e-메일 애플리케이션들, 스프레드시트 애플리케이션들, 워드 프로세싱 애플리케이션들, 그래픽스 저작 애플리케이션들, 비디오 게임들, 또는 디스플레이를 위해 시인가능한 오브젝트들을 생성하는 다른 애플리케이션들을 포함하지만 이에 한정되지 않는다. 예를 들어, 애플리케이션 (42) 은 실행될 때, 디스플레이 상에 디스플레이되는 그래픽 콘텐츠를 출력하는 비디오 게임일 수도 있다.

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

애플리케이션 프로세서 (22) 는 그후 추가적인 프로세싱을 위해 정점들에 대한 픽셀 값들을 GPU (30) 로 포워딩할 수도 있다. 예를 들어, 애플리케이션 프로세서 (22) 는 애플리케이션 프로세서 (22) 상에서 실행하는 소프트웨어일 수도 있는 그래픽스 드라이버 (24) 를 포함할 수도 있다. 애플리케이션 프로세서는, 그래픽스 드라이버 (24) 를 통해서, 지령들을 GPU (30) 로 송신하도록 구성될 수도 있으며, 이에 응답하여, GPU (30) 는 수신된 지령들에 따라서 기능들을 수행할 수도 있다. 예를 들어, 그래픽스 드라이버 (24) 는 GPU (30) 와 애플리케이션 프로세서 (22) 사이의 인터페이스로서 기능한다. 애플리케이션 프로세서 (22) 가 지령을 GPU (30) 로 발할 때, GPU (30) 가 지령을 수령하는 것은 그래픽스 드라이버 (24) 를 통한다. 예를 들어, 애플리케이션 프로세서 (22) 상에서 실행하는 애플리케이션 (42) 은 GPU (30) 에게 특정의 태스크를 수행할 것을 명령할 수도 있다. 이 경우, 그래픽스 드라이버 (24) 는 특정의 태스크에 대해 애플리케이션 (42) 으로부터 명령을 수신할 수도 있으며, 애플리케이션 프로세서 (22) 는 그 명령을 GPU (30) 에 제공할 수도 있다. 이에 응답하여, GPU (30) 는 태스크를 수행할 수도 있다.

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

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

예를 들어, 애플리케이션 (42) 은 애플리케이션 (42) 에 의해 생성되는 모노 뷰의 이미지 상에서 동작하도록 구성될 수도 있는 정점 셰이더 (38) 를 이용할 수도 있다. 애플리케이션 (42) 에 의해 생성되는 모노 뷰의 이미지의 픽셀 값들은 셰이더 프로세서 (32) 에 의해 정점 셰이더 (38) 를 이용하여 프로세싱될 필요가 있을 수도 있다. 일 예로서, 정점 셰이더 (38) 는 애플리케이션 프로세서 (22) 상에서의 애플리케이션 (42) 의 실행 동안 특히 애플리케이션 (42) 에 의해 호출되는 정점 셰이더일 수도 있다. 정점 셰이더 (38) 는 GPU (20) 의 셰이더 프로세서 (32) 상에서 실행할 수도 있으며, 애플리케이션 (42) 은 애플리케이션 프로세서 (22) 상에서 실행할 수도 있으며, 그러나, 정점 셰이더 (38) 와 애플리케이션 (42) 은 애플리케이션 (42) 에 의해 생성되는 이미지들을 디스플레이하려는 목적들을 위해 상호 관련될 수도 있다.

정점 셰이더 (38) 의 소스 코드는 시스템 메모리 (36) 에 저장될 수도 있다. 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 (24) 를 통해서, 정점 셰이더 (38) 의 소스 코드를 취출하고 정점 셰이더 (38) 에 대한 소스 코드를 컴파일러 (28) 에 제공할 수도 있다. 컴파일러 (28) 는 정점 셰이더 (38) 의 소스 코드를 컴파일하여 정점 셰이더 (38) 의 오브젝트 코드를 생성하고, 그 오브젝트 코드를 시스템 메모리 (38) 에 저장할 수도 있다. 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 (34) 를 통해서, 그후 GPU (30) 에게 시스템 메모리 (36) 로부터 정점 셰이더 (38) 의 오브젝트 코드를 취출할 것을 명령하고, GPU (30) 에게 셰이더 프로세서 (32) 상에서 정점 셰이더 (38) 의 오브젝트 코드를 실행할 것을 명령할 수도 있다. 셰이더 프로세서 (32) 는 그후 정점 셰이더 (38) 의 오브젝트 코드를 실행하여, 애플리케이션 (42) 의 실행에 의해 생성되는 정점들에 대한 픽셀 값들을 프로세싱할 수도 있다. GPU (30) 는, 고정-기능 파이프라인 (34) 및 셰이더 프로세서 (32) 와 함께, 디스플레이를 위해 애플리케이션 (42) 에 대한 그래픽스 콘텐츠를 생성할 수도 있다.

시스템 메모리 (36) 가 오직 하나의 정점 셰이더 (38) 에 대한 소스 코드를 저장하는 것으로 나타내지만, 본 개시물의 양태들은 이에 제한되지 않는다. 예를 들어, 애플리케이션 (42) 은 다수의 상이한 정점 셰이더들을 어쩌면 이용할 수도 있으며, 이들 정점 셰이더들의 각각에 대한 소스 코드는 시스템 메모리 (36) 에 저장될 수도 있다. 예를 들어, 정점 셰이더들은 콘텐츠 의존적이고 심지어 장면 의존적일 수도 있으며, 애플리케이션 (42) 은 렌더링되는 이미지의 장면 또는 콘텐츠에 기초하여 특정의 셰이더를 이용할 수도 있다. 또한, 애플리케이션 (42) 은 정점 셰이더 (38) 의 다수의 인스턴스화들의 실행을 필요로 할 수도 있다. 예를 들어, 셰이더 프로세서 (32) 는 정점 셰이더 (38) 의 다수의 인스턴스화들을 동시에 (예컨대, 병렬로) 실행할 수도 있으며, 여기서, 정점 셰이더 (38) 의 각각의 인스턴스화는 실질적으로 유사한 기능들을, 그러나 상이한 픽셀 값들에 대해 수행한다. 시스템 메모리 (36) 는 프래그먼트 셰이더들에 대한 소스 코드를 유사하게 저장할 수도 있다. 그래픽스 드라이버 (34) 는 프래그먼트 셰이더들에 대한 소스 코드를 취출할 수도 있으며, 컴파일러 (28) 는 소스 코드를 컴파일하여, 프래그먼트 셰이더들에 대한 오브젝트 코드를 정점 셰이더 (38) 에 대해 위에서 설명한 방법과 유사한 방법으로 생성할 수도 있다.

좀더 상세히 설명되는 바와 같이, 본 개시물의 하나 이상의 예시적인 기법들은 컴파일 (compilation) 전에 시야각에 기초하여 정점 셰이더 (38) (예컨대, 정점 셰이더 (38) 의 소스 코드) 를 수정할 수도 있다. 컴파일러 (28) 는 수정된 소스 코드를 컴파일하여, 수정된 정점 셰이더 (40) 의 오브젝트 코드를 생성할 수도 있다. 셰이더 프로세서 (32) 는 GPU (30) 로 하여금 입체적인 3D 그래픽스 콘텐츠 (예컨대, S3D 의 좌측-눈 이미지 및 우측-눈 이미지에 대한 그래픽스 콘텐츠) 를 생성하게 할 수도 있는 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행할 수도 있다. 그러나, 정점 셰이더 (38) 에 대한 변경을 설명하기 전에, 다음은 정점 셰이더 (38) 의 예시적인 기능을 설명하며, 이것은 정점 셰이더 (38) 의 소스 코드에 적용되는 변경의 이해를 도울 수도 있다. 더욱이, 본 개시물에서, 용어들 "지령" 및 "명령" 은 교환가능하게 사용될 수도 있다.

위에서 설명된 바와 같이, 애플리케이션 프로세서 (22) 는, 애플리케이션 (42) 을 통해서, 프리미티브들의 정점들에 대한 좌표들을 생성할 수도 있다. 이들 좌표들은 세계 좌표들로서 지칭될 수도 있으며, 애플리케이션 (42) 에 특정적일 수도 있다. 다시 말해서, 애플리케이션 (42) 에 의해 정의된 바와 같은, 정점들의 좌표들은 반드시 프리미티브들이 디스플레이되는 디스플레이의 좌표들일 필요가 없을 수도 있으며, 또한 어쩌면 시인가능한 영역 (viewable area) 외부에 있는 정점들에 대한 좌표들일 수도 있다. 정점 셰이더 (38) 는 3D 에서의 세계 좌표들일 수도 있는 세계 좌표들을, 디스플레이의 2D 좌표들 (예컨대, 디스플레이 좌표들) 로 변환하도록 설계될 수도 있다. 이 기능을 수행하기 위해, 정점 셰이더 (38) 는 세계 좌표들을 눈 좌표들로, 그후 클리핑 좌표들로 변환할 수도 있다. 예를 들어, 정점 셰이더 (38) 의 출력은, 실행될 때, 정점들의 클리핑 좌표들일 수도 있다. 최종 디스플레이 좌표들 (예컨대, 디스플레이의 좌표들) 은 그 후에 고정-기능 파이프라인 (34) 의 부분으로서 결정될 수도 있다.

클리핑 좌표들은 뷰 프루스툼 (frustum) 을 정의할 수도 있다. 뷰 프루스툼은 3D 그래픽스 콘텐츠의 시인가능한 영역을 정의할 수도 있다. GPU (30) 는 뷰 프루스툼을 이용하여, 뷰 프루스툼 외부에 상주하는 픽셀들을 컬링할 (cull) 수도 있다. 예를 들어, 고정-기능 파이프라인 (34) 의 고정-기능 유닛 (예컨대, 고정-기능 파이프라인 (24) 의 프루스툼 유닛) 은 정점 셰이더 (38) 에 의해 생성되는 클리핑 좌표들에 의해 정의되는 바와 같이, 뷰 프루스툼 외부에 상주하는 픽셀들을 컬링할 수도 있다.

세계 좌표들로부터 클리핑 좌표들을 계산하기 위한 방정식은 다음과 같을 수도 있다:

(방정식 1)

여기서, Vclip 는 정점 클립 좌표들이고, Veye 는 정점 눈 좌표들이며, Vworld 는 애플리케이션 (42) 에 의해 제공되는 정점 세계 좌표들이고, PRJ 는 투영 매트릭스이고, MVT 는 모델 뷰 변환 매트릭스 (또는, 세계 뷰 변환 매트릭스) 이다. 일부 예들에서, PRJ 및 MVT 매트릭스들은 단일 매트릭스로 결합될 수도 있다. 그러나, 이해의 용이성을 위해, 이들 매트릭스들은 따로 설명된다.

투영 매트릭스 (PRJ) 및 모델 뷰, 또는 세계 뷰, 변환 매트릭스 (MVT) 는 API 에 의해 정의될 수도 있다. 용어들 모델 뷰와 세계 뷰는 교환가능하게 사용될 수도 있다. Vclip, Veye, 및 Vworld 는 4개의 성분들 (예컨대, 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 매트릭스들의 변수들의 모두는 애플리케이션 프로세서 (22) 상에서 실행하는 애플리케이션 (42) 에 의해 정의될 수도 있으며, 그래픽스 드라이버 (24) 는 이들 변수들을 정점 셰이더 (38) 의 오브젝트 코드 상에서 실행하고 있는 셰이더 프로세서 (32) 에 제공할 수도 있다. 방정식들 1, 4, 및 5 로부터 볼 수 있는 바와 같이, 이들 변수들에 의해, 정점 셰이더 (38) 는 정점들의 각각에 대해 Vclip 좌표들을 결정할 수도 있다. GPU (30) 는 정점들에 대한 클립 좌표들을 이용하고, 추가적인 기능을, 고정-기능 파이프라인 (34) 및 프래그먼트 셰이더들의 기능과 함께, 수행하여, 디스플레이를 위해 이미지를 렌더링할 수도 있다. 이러한 방법으로, GPU (30) 는 애플리케이션 (42) 에 의해 생성되는 그래픽스 콘텐츠에 대한 모노 뷰를 생성할 수도 있다.

본 개시물의 기법들에 따르면, 정점 셰이더 (38) 는 MVT 및 PRJ 매트릭스들에 대한 변수들을 이용하여 Vclip 좌표들을 결정할 수도 있지만, MVT 및 PRJ 매트릭스들은 입체 뷰를 생성하기 위해 정점 셰이더 (38) 를 수정하는 것 (예컨대, 정점 셰이더 (38) 의 소스 코드를 수정하는 것) 이 요구되지 않을 수도 있다. 다시 말해서, 본 개시물에서 설명하는 기법들이 수정하는 명령들은 MVT 및 PRJ 매트릭스들의 특정의 값들을 필요로 하지 않을 수도 있다.

예를 들어, 정점 셰이더 (38) 를 설계하는 많은 방법들이 존재할 수도 있으며, 정점 셰이더 (38) 는 콘텐츠 및 심지어 장면 의존적일 수 있어, 콘텐츠 개발자들로 하여금 많은 상이한 방법들을 이용하여 프로그램 정점 셰이더 (38) 를 프로그래밍가능하게 할 수도 있다. 따라서, MVT 및 PRJ 매트릭스들이 개발자에 의해 정의되는 특정의 방법들을 결정하는 것은 실현가능하지 않을 수도 있다. 그러나, 본 개시물에서 설명하는 기법들은 개발자가 정점 셰이더 (38) 를 개발한 또는 개발자가 MVT 및 PRJ 매트릭스들을 정의한 방법의 인식을 필요로 하지 않는다.

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

그러나, (예컨대, 정점 셰이더 (38) 를 실행하는 셰이더 프로세서 (32) 가 클리핑 좌표들을 결정하거나 또는 정점 셰이더 (38) 를 실행하는 셰이더 프로세서 (32) 가 클리핑 좌표들을 수신하는) 임의의 경우에, 정점 셰이더 (38) 는 특정의 변수를 이용하여 클리핑 좌표들을 저장할 수도 있다. 특정의 변수는 정점 셰이더 (38) 가 설계되는 API 에 특유할 수도 있다. 예를 들어, 정점 셰이더 (38) 가 OpenGL, OpenGL ES, 또는 OpenGL ES 2.0 API들에 따라서 설계되면, 프로그래밍가능 셰이더들에 의해, 정점 셰이더 (38) 는 클리핑 좌표들을 gl_Position 변수에 저장할 수도 있다. gl_Position 변수는 자동적으로 선언될 수도 있다. 다른 그래픽스 API들에서의 유사한 변수가 있을 수도 있다. 정점 셰이더 (38) 가 OpenGL, OpenGL ES, 또는 OpenGL ES 2.0 API들에 따라서 설계되면, 프로그래밍가능 셰이더들에 의해, 정점 셰이더 (38) 는 gl_Position.x = x_clip, gl_Postion.y = y_clip, gl_Position.z = z_clip, 및 gl_Position.w = w_clip 와 같은 명령들을 포함할 수도 있으며, 여기서, 위에서 방정식 2 에 나타낸 바와 같이,

이다.

본 개시물에서 설명되는 하나 이상의 예시적인 기법들에서, 애플리케이션 프로세서 (22) 상에서 실행하는 소프트웨어일 수도 있는 그래픽스 드라이버 래퍼 (26) 는 입체 뷰에 대한 클리핑 좌표들 (예컨대, 좌측-눈 이미지에 대한 클리핑 좌표들 및 우측-눈 이미지에 대한 클리핑 좌표들) 을 정의하기 위해 모노 뷰에 대한 클리핑 좌표들을 정의하는 정점 셰이더 (38) 의 명령들을 수정할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 결정된 시야각을 애플리케이션 프로세서 (22) 로부터 수신할 수도 있다. 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 의 실행으로 인해, 입체 뷰에 대한 클리핑 좌표들을 정의하기 위해, 애플리케이션 프로세서 (22) 에 의해 결정되는 시야각에 기초하여, 정점 셰이더 (38) 의 명령들을 수정하도록 구성될 수도 있다.

예를 들어, 애플리케이션 프로세서 (22) 는, 정점 셰이더 (38) 의 수정된 명령들이 셰이더 프로세서 (32) 에 의해 첫번째 실행될 때 정점 셰이더 (38) 의 수정된 명령들이 클리핑 좌표들을 시야각에 기초하여 하나의 방향으로 변위시키고 그리고 정점 셰이더 (38) 의 수정된 명령들이 다시 셰이더 프로세서 (32) 에 의해 두번째 실행될 때 정점 셰이더의 수정된 명령들이 동일한 클리핑 좌표들을 시야각에 기초하여 또 다른 방향으로 변위시키도록, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 명령들을 수정할 수도 있다. 그러나, 클리핑 좌표들을 상이한 방향들로 간단히 변위시키고 최종 이미지들을 렌더링하는 것은 입체 뷰로 하여금, 어떤 고정된 양 만큼 디스플레이 (12) 로부터 항상 나오거나 또는 디스플레이 (12) 내에 항상 들어가도록 할 수도 있다. 이러한 결과는 뷰어에게 만족스럽지 않을 수도 있다.

예를 들어, 입체 뷰가 디스플레이 (12) 로부터 튀어 나온다고 가정한다. 이 경우, 뷰어는 디스플레이 (12) 의 전면에 어떤 거리에 있는 평면 상에서 입체 뷰를 인지할 수도 있다. 뷰어가 입체 뷰를 인지하는 이 평면은 제로 디스패리티 평면 (ZDP) 로서 지칭될 수도 있다. 그러나, 뷰어는 현재의 제로 디스패리티 평면과는 상이한 거리에서 제로 디스패리티 평면을 인지하는 것을 원할 수도 있다.

제로 디스패리티 평면 조정을 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 증가시키거나 또는 감소시킬 수도 있다. 예를 들어, 애플리케이션 (42) 은 단일 이미지의 뷰포트를 정의하는 지령을 출력할 수도 있다. 용어 "뷰포트" 는 이미지가 디스플레이 (12) 상에서 둘러싸는 영역을 지칭한다. 예를 들어, 애플리케이션 (42) 은 디스플레이 (12) 상에서의 단일 이미지 (예컨대, 모노 뷰) 의 사이즈 및 로케이션을 정의할 수도 있다. 이 단일 이미지의 사이즈 및 로케이션의 정의는 단일 이미지에 대한 뷰포트로서 간주될 수도 있다. 뷰포트를 정의하기 위해, 애플리케이션 프로세서 (22) 는, 애플리케이션 (42) 을 통해서, glViewport 지령을 발할 수도 있으며, 그 지령의 변수들이 디스플레이 (12) 상에서의 모노 뷰 이미지의 사이즈 및 로케이션을 정의한다. 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 시야각에 기초하여, 단일 이미지의 사이즈 및 로케이션을 정의하는 지령 (예컨대, 애플리케이션 (32) 에 의해 발행되는 glViewport 지령) 을 좌측-눈 이미지 및 우측-눈 이미지의 사이즈 및 로케이션을 정의하는 지령들 (예컨대, 좌측-눈 이미지에 대한 뷰포트 및 우측-눈 이미지에 대한 뷰포트를 정의하는 glViewport 지령들) 로 수정할 수도 있다. 좌측-눈 이미지에 대한 glViewport 지령은 시야각에 기초하여 좌측-눈 이미지를 디스플레이의 하나의 부분에 제한할 수도 있으며, 우측-눈 이미지에 대한 glViewport 지령은 시야각에 기초하여 우측-눈 이미지를 디스플레이의 또 다른 부분에 제한할 수도 있다. 이들 2개의 부분들이 적어도 부분적으로 중첩하는 것이 가능할 수도 있다.

일부 예들에서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 증가시키거나 또는 감소시키기 위해 glViewport 지령을 수정할 수도 있다. 예를 들어, 좌측-눈 이미지가 하나의 부분에 제한되고 우측-눈 이미지가 또 다른 부분에 제한될 때, 좌측-눈 이미지에서의 유사한 오브젝트들의 모두 및 우측-눈 이미지에서의 오브젝트들 사이에 어떤, 고정된 수평 디스패리티가 존재할 수도 있다. 다시 말해서, 좌측-눈 이미지 및 우측-눈 이미지에서 대응하는 정점들의 각각 사이의 수평 디스패리티의 양은 동일할 수도 있다. 실례로서, 애플리케이션 (42) 에 의해 생성되는 이미지가 볼 (ball) 및 블록을 포함한다고 가정한다. 이 예에서, 좌측-눈 이미지 및 우측-눈 이미지에서 볼의 정점들 사이의 수평 디스패리티는 좌측-눈 이미지 및 우측-눈 이미지에서 블록의 정점들 사이의 수평 디스패리티와 동일할 수도 있다. 따라서, 최종 입체 뷰, 볼 및 블록은 제로 디스패리티 평면에서 보일 수도 있으며, 여기서, 제로 디스패리티 평면은 디스플레이 (12) 의 앞에 또는 뒤에 있다. 볼 및 블록이 제로 디스패리티 평면에서 보일 때, 그 볼 및 블록은 제로 디스패리티 평면 내로 들어가거나 또는 제로 디스패리티 평면 외부로 나오는 것처럼 보이지 않을 수도 있다.

제로 디스패리티 평면의 로케이션 (예컨대, 제로 디스패리티 배치가 디스플레이 (12) 의 앞에 또는 뒤에 있는 양) 을 조정하기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 뷰어로 하여금, 좌측-눈 이미지에서의 유사한 오브젝트들과 우측-눈 이미지에서의 오브젝트들 사이의 수평 디스패리티를 정의가능하게 하기 위해 glViewport 지령의 명령들을 수정할 수도 있다. 예를 들어, 뷰어는 좌측-눈 이미지에서의 유사한 오브젝트들과 우측-눈 이미지 사이의 수평 디스패리티를 정의하는 수평 디스패리티 값을 제공할 수도 있다.

이러한 방법으로, 뷰어는 뷰어가 모든 좌측-눈 이미지 및 우측-눈 이미지에서의 유사한 오브젝트들이 수평으로 변위되는 양을 추가로 정의할 수도 있기 때문에, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 정의하는 것으로 간주될 수도 있다. 위에서 설명된 바와 같이, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티의 양은 입체 뷰가 디스플레이 (12) 의 앞에 또는 뒤에 보이는 양을 정의한다. 따라서, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 정의함으로써, 뷰어는 제로 디스패리티 평면의 로케이션을 정의할 수도 있다.

일부 예들에서, 뷰어가 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 정의하는 대신, 애플리케이션 프로세서 (22) 는 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 추정할 수도 있다. 일 예로서, 애플리케이션 프로세서 (22) 또는 그래픽스 드라이버 래퍼 (26) 는 그래픽스 드라이버 래퍼 (26) 가 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 증가시키거나 또는 감소시키는데 이용하는 수평 디스패리티 값으로 사전 로드될 수도 있다. 이 수평 디스패리티 값은 뷰어들이 일반적으로 디스플레이 (12) 를 보는 공통 거리의 가정에 기초할 수도 있다. 예를 들어, 디바이스 (10) 가 모바일 디바이스인 예들에서, 대부분이 뷰어들은 디바이스 (10) 를 그들의 얼굴로부터 대략 동일한 거리에 유지한다. 따라서, 대부분의 뷰어들은 제로 디스패리티 평면이 디스플레이 (12) 앞에 대략 동일한 거리에 보이는 것을 선호할 수도 있다. 애플리케이션 프로세서 (22) 또는 그래픽스 드라이버 래퍼 (26) 는 디스플레이 (12) 의 앞에 일반적으로 선호되는 거리에 제로 디스패리티 평면을 생성하는 수평 디스패리티 값으로 사전 로드될 수도 있다.

또 다른 예로서, 카메라 프로세서 (44) 는 디스플레이 (12) 로부터의 뷰어의 거리의 추정치를 결정하도록 구성될 수도 있다. 예를 들어, 카메라 프로세서 (44) 는 뷰어의 헤드를 식별할 수도 있으며, 헤드 사이즈의 측정치에 기초하여, 카메라 프로세서 (44) 는 디스플레이 (12) 에 대한 뷰어의 거리를 추정할 수도 있다. 이 예에서, 애플리케이션 프로세서 (22) 는 이 뷰어의 거리의 추정을 이용하여 수평 디스패리티 값을 결정할 수도 있으며, 여기서, 수평 디스패리티 값은 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티의 양을 정의한다.

본 개시물에서 설명하는 기법들에서, glViewport 지령은 정점 셰이더 (38) 의 명령이 아닐 수도 있다. 대신, 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛은 glViewport 지령에 기초하여, 좌측-눈 이미지를 하나의 부분에 제한할 수도 있으며, 우측-눈 이미지를 또 다른 부분에 제한할 수도 있다. 이들 예들에서, GPU (30) 는 제로 디스패리티 평면이 디스플레이 (12) 에 대해 원하는 로케이션에 있도록, 시야각에 기초하여 좌측-눈 이미지를 디스플레이 (12) 의 하나의 부분에 제한하고 시야각에 기초하여 우측-눈 이미지를 디스플레이 (12) 의 또 다른 부분에 제한하기 위해, glViewport 지령을 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛에 제공할 수도 있다.

glViewport 지령의 변경의 상기 예에서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 뷰어가 원하는 제로 디스패리티 평면에서 입체 뷰를 인지하도록, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 정의할 수도 있다. 일부 예들에서, 심지어 더 나은 뷰잉 경험은 뷰어로 하여금, 유사한 오브젝트들 사이의 수평 디스패리티를 상이한 양들만큼 증가시키거나 또는 감소시키도록 함으로써, 실현될 수도 있다. 예를 들어, glViewport 지령 변경에서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 모든 좌측-눈 및 우측-눈 이미지에서의 유사한 오브젝트들이 동일한 양 만큼 변위되도록, glViewport 지령을 수정할 수도 있다. 이것은 제로 디스패리티 평면에서 디스플레이 (12) 의 앞에 또는 뒤에 보이는 입체 뷰를 초래한다. 그러나, 뷰어는 또한 일부 오브젝트들로 하여금, 제로 디스패리티 평면의 앞에 보이게 하는 것을, 일부 오브젝트들로 하여금, 제로 디스패리티 평면 뒤에 보이게 하는 것을, 그리고 일부 오브젝트들로 하여금, 제로 디스패리티 평면에 보이게 하는 것을 원할 수도 있다.

일부 예들에서, 뷰어 또는 애플리케이션 프로세서 (22) 가 제로 디스패리티 평면의 로케이션을 정의하는 수평 디스패리티 값을 결정하기 보다는, 뷰어는 제로 디스패리티 평면의 로케이션을 정의할 수도 있거나, 또는 애플리케이션 프로세서 (22) 는 제로 디스패리티 평면의 로케이션을 결정할 수도 있다. 이들 예들에서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, glViewport 지령으로 하여금 두번, 즉, 좌측-눈 이미지에 대해 한번, 및 우측-눈 이미지에 대해 또다른 한번 실행하도록 하는 것 외에, 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 반드시 수정할 필요가 없을 수도 있다. 대신, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 애플리케이션 (42) 에 의해 출력된 프리미티브들의 정점들이 좌측-눈 이미지 및 우측-눈 이미지에서 상이한 양들만큼 변위되도록, 정점 셰이더 (38) 의 명령들을 추가로 수정할 수도 있다.

예를 들어, 그래픽스 드라이버 래퍼 (26) 가 glViewport 지령을 수정하는 예에서, 그래픽스 드라이버 래퍼 (26) 는 이미지 레벨에서의 수평 디스패리티 (예컨대, 우측-눈 이미지와 좌측-눈 이미지 사이의 수평 디스패리티) 를 정의하는 것으로 간주될 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 2개의 glViewport 지령들, 즉 시야각에 기초하여 좌측-눈 이미지를 하나의 부분에 제한하기 위한 하나, 및 시야각에 기초하여 우측-눈 이미지를 또 다른 부분에 제한하기 위한 다른 하나를 생성할 수도 있다. 예를 들어, 애플리케이션 (42) 은 단일 이미지의 뷰포트를 정의하는 glViewport 지령을 발할 수도 있다. 그래픽스 드라이버 래퍼 (26) 는 제 1 실행 인스턴스에서 좌측-눈 이미지의 뷰포트를 정의하기 위해 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수정할 수도 있으며, 제 2 실행 인스턴스에서 우측-눈 이미지의 뷰포트를 정의하기 위해 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수정할 수도 있다.

애플리케이션 프로세서 (22) 가, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 명령들을 추가로 수정하는 예에서, 그래픽스 드라이버 래퍼 (26) 는 정점 레벨에서의 수평 디스패리티 (예컨대, 좌측-눈 이미지에서의 정점과 우측-눈 이미지에서의 정점 사이의 수평 디스패리티) 를 정의하는 것으로 간주될 수도 있다. 따라서, 디스패리티를 조정하기 위해 정점 셰이더 (38) 의 명령들을 수정하는 것은 디스패리티를 조정하기 위해 glViewport 지령의 명령들을 수정하는 것에 비해 더 미세한 디스패리티 조정의 레벨을 제공할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 의 명령들을 추가로 수정하는 예에서, GPU (30) 는 좌측-눈 이미지 및 우측-눈 이미지에 대한 뷰포트들을 정의하기 위해 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 이용할 수도 있다 (예컨대, 어떤 glViewport 지령의 변경도 요구되지 않을 수도 있다). 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령이 두번, 즉, 좌측-눈 및 우측-눈 이미지들의 각각에 대해 한번씩 실행하도록 할 수도 있다. 그러나, 이 예에서, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수정하지 않을 수도 있으며, 정점 셰이더 (38) 의 명령들에 대한 추가적인 변경들은, 일부 오브젝트들이 제로 디스패리티 평면의 앞에 보이고 일부 오브젝트들이 제로 디스패리티 평면의 뒤에 보이고 그리고 일부 오브젝트들이 제로 디스패리티 평면에 보이도록, 정점들이 상이한 양들만큼 변위될 수 있게 할 수도 있다.

예를 들어, 애플리케이션 (42) 은 프리미티브들의 정점들을 3-차원들 (예컨대, x, y, z, w 좌표들) 로 정의할 수도 있으며, 여기서, w 좌표는 동차 좌표 (homogenous coordinate) 이다. 본 개시물에서 설명하는 기법들에서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점의 z-좌표의 값을 이용하여, 정점이 좌측-눈 이미지 및 우측-눈 이미지에서 변위되는 양을 결정할 수도 있다. 예를 들어, z-좌표의 값이 제로 디스패리티 평면의 로케이션과 동일하면, 정점 셰이더 (38) 의 수정된 명령들은 좌측-눈 이미지 및 우측-눈 이미지에서 정점을 변위시키지 않을 수도 있다. 그러나, z-좌표의 값이 제로 디스패리티 평면의 로케이션과 동일하지 않으면, 정점 셰이더 (38) 의 수정된 명령들은 좌측-눈 이미지 및 우측-눈 이미지에서 정점의 로케이션을 변위시킬 수도 있다. 정점 셰이더 (38) 의 수정된 명령들이 정점의 로케이션을 변위시키는 양은 z-좌표의 값에 기초할 수도 있다.

그래픽스 드라이버 래퍼 (26) 가 이미지 레벨에서 디스패리티를 조정하기 위해 glViewport 지령을 수정하는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 정점 레벨에서 디스패리티를 조정하기 위해 정점 셰이더 (38) 의 명령들을 추가로 수정하지 않을 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 레벨에서 디스패리티를 조정하기 위해 정점 셰이더 (38) 의 명령들을 수정하는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 이미지 레벨에서 디스패리티를 조정하기 위해 glViewport 지령을 수정하지 않을 수도 있다. 그러나, 본 개시물의 양태들은 이에 제한되지 않으며, 그래픽스 드라이버 래퍼 (26) 가 glViewport 지령을 수정하여 이미지 레벨에서의 디스패리티를 조정하는 것, 그리고 정점 셰이더 (38) 의 명령들을 수정하여 정점 레벨에서의 정점들 사이의 디스패리티를 추가로 조정하는 것 모두 가능할 수도 있다.

또한, 그래픽스 드라이버 래퍼 (26) 가 단지 glViewport 지령을 수정하여 제로 디스패리티 평면의 로케이션을 조정할 때, GPU (30) 는 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 의 명령들을 수정하여 제로 디스패리티 평면에 대한, 오브젝트들이 보이는 (예컨대, 제로 디스패리티 평면에, 앞에, 또는 뒤에 있는) 장소의 로케이션들을 추가로 조정할 때보다 더 빨리, 입체 뷰를 렌더링가능할 수도 있다. 이것은 고정-기능 파이프라인 (34) 의 뷰포트 조정 유닛이 좌측-눈 이미지 및 우측-눈 이미지의 뷰포트들을 조정하는 것에 비해 정점 셰이더 (38) 가 셰이더 프로세서 (32) 상에서 실행하는데 더 오래 소요하기 때문일 수도 있다. 그러나, 그래픽스 드라이버 래퍼 (26) 가 제로 디스패리티 평면에 대해 오브젝트들이 나타나는 장소의 로케이션들을 조정하기 위해 정점 셰이더 (38) 의 명령들을 추가로 수정할 때, 렌더링된 입체 뷰는 그래픽스 드라이버 래퍼 (26) 가 glViewport 지령을 수정할 때에 비해 더 나은 뷰어 경험을 제공할 수도 있다. 이것은, 정점 셰이더 (38) 에 대한 명령들의 추가적인 변경은 일부 오브젝트들이 제로 디스패리티 평면에, 앞에, 또는 뒤에 보이게 허용하는 반면, glViewport 지령에 대한 변경에 의해 모든 오브젝트들이 디스플레이 (12) 의 앞에 또는 뒤에 있을 수도 있는 제로 디스패리티 평면에 보이기 때문일 수도 있다.

glViewport 지령을 수정할지 또는 정점 셰이더 (38) 의 명령들을 추가로 수정할지는 설계 선택의 문제일 수도 있다. 예를 들어, 렌더링 시간이 중요 인자이면, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, glViewport 지령을 수정할 수도 있다. 더 이상적인 뷰잉 경험이 중요 인자이면, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 명령들을 추가로 수정할 수도 있다.

따라서, 그래픽스 드라이버 래퍼 (26) 는 정점 셰이더 (38) 의 수정된 명령들이 셰이더 프로세서 (32) 를 실행할 때 GPU (30) 가 프리미티브들의 정점들을 시야각에 기초하여 하나의 방향으로, 그리고 시야각에 기초하여 또 다른 방향으로 변위시키도록, 정점 셰이더 (38) 의 명령들을 수정할 수도 있다. 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 정점 셰이더 (38) 의 추가적인 수정된 명령들이 셰이더 프로세서 (32) 상에서 실행할 때 GPU (30) 가 프리미티브들의 정점들을 시야각에 기초하여 그리고 제로 디스패리티 평면의 로케이션에 기초하여 하나의 방향으로 변위시키도록, 정점 셰이더 (38) 의 명령들을 추가로 수정할 수도 있다. 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛이 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 증가시키거나 또는 감소시켜 제로 디스패리티 평면의 로케이션을 조정하도록, 애플리케이션 (42) 에 의해 발행되는 glViewport 지령의 명령들을 수정할 수도 있다.

다음은 애플리케이션 프로세서 (22), GPU (30), 및 시스템 메모리 (36) 가 GPU (30) 로 하여금, 모노-뷰를 생성하는 애플리케이션 (42) 으로부터의 입체 뷰를 렌더링하도록 함께 기능할 수도 있는 예시적인 방법을 설명한다. 예를 들어, 애플리케이션 프로세서 (22) 는 하나 이상의 센서들 (42) 및 카메라 프로세서 (44) 로부터의 하나 이상의 출력들에 기초하여 시야각을 결정할 수도 있다. 애플리케이션 프로세서 (22) 는 시야각을 주기적으로, 예컨대, 일 예로서 GPU (30) 에 의한 좌측-눈 이미지 및 우측-눈 이미지 양쪽의 렌더링 당 한번 (즉, 입체 뷰의 생성 당 한번) 결정할 수도 있다. 그래픽스 드라이버 래퍼 (26) 는 이 결정된 시야각을 이용하여, 애플리케이션 (42) 에 의해 발행되는 명령들을 수정하고 정점 셰이더 (38) 의 명령들을 수정할 수도 있다.

예를 들어, GPU (30) 로 하여금 이미지를 렌더링하도록 하기 위해, 애플리케이션 프로세서 (22) 는 애플리케이션 (42) 의 glShaderSource 지령을 실행할 수도 있다. glShaderSource 지령은 그래픽스 드라이버 (24) 에게 시스템 메모리 (36) 로부터 정점 셰이더 (38) 의 소스 코드를 취출할 것을 명령한다. 본 개시물의 예들에서, 애플리케이션 (42) 에 의해 발행되는 glShaderSource 지령에 응답하여, 그래픽스 드라이버 래퍼 (26) 는 그래픽스 드라이버 (24) 에 도달하기 전에, 정점 셰이더 (38) 의 소스 코드를 인터셉트할 수도 있다. 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 수정된 정점 셰이더 (38) 로 하여금, 실행될 때, 애플리케이션 프로세서 (22) 에 의해 결정되는 시야각에 기초하여 입체 뷰에 대한 그래픽스 콘텐츠를 생성하도록 하는 명령들을 포함하기 위해, 정점 셰이더 (38) 의 소스 코드를 수정할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 수정된 정점 셰이더 (38) 가 2번 실행되게 할 수도 있다. 제 1 실행에서, 수정된 정점 셰이더 (38) 는 시야각에 기초하여 좌측-눈 이미지에 대한 그래픽스 콘텐츠를 생성할 수도 있으며, 제 2 실행에서, 수정된 셰이더 (38) 는 시야각에 기초하여 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성할 수도 있으며, 또는 반대도 마찬가지이다. 게다가, 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 제로 디스패리티 평면의 로케이션에 기초하여 정점들의 로케이션을 결정하기 위해 정점 셰이더 (38) 의 명령들을 추가로 수정할 수도 있다.

그래픽스 드라이버 래퍼 (26) 는, 애플리케이션 프로세서 (22) 에 의해 실행되는 바와 같이, 소스 코드 에디터로서 기능할 수도 있다. 일 예로서, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 명령들을 모니터링할 수도 있다. 애플리케이션 (42) 이 glShaderSource 지령을 발행했다고 그래픽스 드라이버 래퍼 (26) 가 인지할 때, 그래픽스 드라이버 래퍼 (26) 는 정점 셰이더 (38) 의 명령들 (예컨대, 정점 셰이더 (38) 의 소스 코드) 를 캡쳐하여 수정할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 단일 이미지 (예컨대, 모노 뷰) 에 대해 생성되는 클리핑 좌표들의 값을 수정하여 시야각에 기초하여 좌측-눈 이미지 및 우측-눈 이미지 (예컨대, 입체 뷰) 에 대한 클리핑 좌표들을 생성하는 정점 셰이더 (38) 의 소스 코드에 명령들을 포함시킬 수도 있다.

예를 들어, 위에서 나타낸 바와 같이, 정점 셰이더 (38) 는 x_clip 좌표에 대한 값을 저장하는 gl_Position.x 변수, 및 y_clip 에 대한 값을 저장하는 gl_Position.y 변수를 포함할 수도 있다. 더욱더 자세하게 설명되는 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 시야각에 기초하여 제 1 명령을 gl_Position.x (예컨대, x_clip 좌표) 의 값을 업데이트하는 정점 셰이더 (38) 에 포함시킬 수도 있으며, 시야각에 기초하여 제 2 명령을 gl_Position.y (예컨대, y_clip 좌표) 의 값을 업데이트하는 정점 셰이더 (38) 에 포함시킬 수도 있다.

좌측-눈 이미지를 생성하기 위해, 애플리케이션 프로세서 (22) 에 의해 정점 셰이더 (38) 에 추가되는 제 1 명령은, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 로 하여금 제 1 값을 x_clip 값에 가산하도록 한다. 제 1 값은 뷰어의 눈들 사이의 거리 및 시야각에 기초할 수도 있다. 애플리케이션 프로세서 (22) 에 의해 정점 셰이더 (38) 에 추가되는 제 2 명령은, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 로 하여금 제 2 값을 y_clip 값에 가산하게 한다. 제 2 값은 뷰어의 눈들 사이의 거리, 시야각, 및 디스플레이 (12) 의 높이 및 폭에 기초할 수도 있다.

우측-눈 이미지를 생성하기 위해, 그래픽스 드라이버 래퍼 (26) 에 의해 정점 셰이더 (38) 에 추가되는 명령은 정점 셰이더 (38) 로 하여금 제 1 값을 x_clip 값에서 감산하게 한다. 우측-눈 이미지에 대한 제 1 값은 좌측-눈 이미지에 대한 제 1 값과 동일한 값일 수도 있다. 그래픽스 드라이버 래퍼 (26) 에 의해 정점 셰이더 (38) 에 추가되는 제 2 명령은 정점 셰이더 (38) 로 하여금 제 2 값을 y_clip 값에서 감산하게 한다. 우측-눈 이미지에 대한 제 2 값은 좌측-눈 이미지에 대한 제 2 값과 동일한 값일 수도 있다.

예를 들어, 애플리케이션 프로세서 (22) 는, gl_Position.x 변수에 저장된 값 (예컨대, x_clip 좌표) 을 gl_Position.x 변수의 현재의 값 플러스 (z_near*w_world/(R-L)/2)*X 로 변경하는 명령을 추가하기 위해, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 소스 코드를 수정할 수도 있으며, 여기서, z_near, R, 및 L 은 모두 PRJ 매트릭스 (방정식 4) 로부터의 변수들이고, w_world 는 V_world 매트릭스 (방정식 2) 로부터의 변수 (예컨대, 애플리케이션 (42) 에 의해 정의되는 바와 같은 정점 좌표들) 이다. 애플리케이션 프로세서 (22) 는, gl_Position.y 변수에 저장된 값 (예컨대, y_clip 좌표) 을 gl_Position.y 변수의 현재의 값 플러스 (z_near*w_world/(T-B)/2)*Y 으로 변경하는 또 다른 명령을 추가하기 위해, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 소스 코드를 수정할 수도 있으며, 여기서, z_near, T, 및 B 는 모두 PRJ 매트릭스 (방정식 4) 로부터의 변수들이고, w_world 는 V_world 매트릭스 (방정식 2) 로부터의 변수 (예컨대, 애플리케이션 (42) 에 의해 정의되는 바와 같은 정점 좌표들) 이다.

X 의 값은 +D*cos(α) 또는 -D*cos(α) 일 수도 있으며, 여기서, D 는 뷰어의 우측 눈과 좌측 눈 사이의 거리의 절반의 근사치이고, 사용자 정의가능한 또는 사전 프로그래밍된 값일 수도 있으며, alpha, α 는 시야각이다. 애플리케이션 프로세서 (22) 는 일 예로서, 하나 이상의 센서들 (42) 및 카메라 프로세서 (44) 의 출력들에 기초하여, 시야각을 결정할 수 있다. Y 의 값은 +D*sin(α) 또는 -D*sin(α) 일 수도 있다.

예를 들어, 좌측 눈과 우측 눈 사이의 거리가 2*D 라고 가정한다. 이 예에서, 뷰어의 좌측 눈의 좌표들은 (-D_x, -D_y, -D_z) 일 수도 있으며, 뷰어의 우측 눈의 좌표들은 (D_x, D_y, D_z) 일 수도 있다. D_z 좌표는 좌측 눈 및 우측 눈의 좌표들이 뷰어의 얼굴의 전면, 및 눈들의 중간에서 시작할 수도 있기 때문에 제로로 간주될 수도 있다 (즉, (0, 0, 0) 로케이션은 뷰어의 얼굴의 전면 및 뷰어의 좌측 눈과 우측 눈 사이에 있는 지점에 로케이트된다). 시야각이 alpha 이면, 뷰어의 좌측 눈에 대한 좌표들은 (-D_x*cos(α), -D_y*sin(α), 0) 일 수도 있으며, 뷰의 우측 눈에 대한 좌표들은 (D_x*cos(α), D_y*sin(α), 0) 일 수도 있다. 이 예에서, 시야각이 제로이면, 좌측-눈 및 우측-눈의 좌표들은 (-D_x, 0, 0), 및 (D_x, 0, 0) 이 된다. 그러나, 시야각이 제로가 아닐 때, 시야각은 (0, 0, 0) 로케이션에 대한 뷰어의 좌측 눈 및 우측 눈의 로케이션을 정의할 수도 있다. 좌측 눈 및 우측 눈에 대한 좌표들은 다음과 같이 간주될 수도 있다:

(방정식 6)

(방정식 7)

애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 다음 명령을 정점 셰이더 (38) 의 명령들의 세트에 추가할 수도 있다: 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 과 동일할 수도 있는 이유들이 아래에서 좀더 상세히 설명된다.

애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 다음 명령을 정점 셰이더 (38) 의 명령들의 세트에 추가할 수도 있다: gl_Position.y+ = (z_near*w_world/(T-B)/2)*Y. 이것은 gl_Position.y = gl_Position.y + (z_near*w_world/(T-B)/2)*Y 와 동등할 수도 있다. 예를 들어, gl_Position.y+= 지령들은 gl_Position.y+= 명령에 의해 정의되는 값을 gl_Position 지령에 의해 저장되는 값에 가산한다 (예컨대, 그 값을 y_clip 에 가산한다). 일부 상황들에서, gl_Position.y+= 명령은 gl_Position.y+ = Y*디스플레이 (12) 의 높이로 나눈 디스플레이 (12) 의 폭으로 간단하게 할 수도 있다. gl_Position.y+ 변수가 (z_near*w_world/(T - B)/2)*Y 또는 단지 Y*디스플레이 (12) 의 높이로 나눈 디스플레이 (12) 의 폭과 동일할 수도 있는 이유들이 아래에서 좀더 자세히 설명된다.

본 개시물의 기법들에 따르면, 좌측-눈 이미지를 생성하기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 변수 X 의 값을 D*cos(α) 로 정의할 수도 있다. 이것은 좌측에서의 뷰잉 로케이션의 이동이 우측에서 관찰되는 오브젝트의 이동과 동등하기 때문이다. X 가 +D*cos(α) 과 동일할 때, gl_Position.x+= 지령은 정점들로 하여금 좌측으로 D*cos(α) 의 값 만큼 이동하게 하는 애플리케이션 (42) 에 의해 생성되는 정점들의 각각의 x_clip 좌표에의, 상수 (예컨대, (z_near*w_world/(R - L)/2)*D*cos(α) 또는 단지 D*cos(α)) 의 가산을 초래한다. 또한, 좌측-눈 이미지를 생성하기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 (26) 를 통해서, 변수 Y 의 값을 D*sin(α) 로 정의할 수도 있다. 이것은 그 하측으로의 뷰잉 로케이션의 이동이 오브젝트 상측에서 관찰되는 이동과 동등하기 때문이다. Y 가 +D*sin(α) 와 동일할 때, gl_Position.y+= 지령은 정점들로 하여금 좌측으로 D*sin(α)*폭/높이의 값 만큼 이동하게 하는 애플리케이션 (42) 에 의해 생성되는 정점들의 각각의 y_clip 좌표에의, 상수 (예컨대, (z_near*w_world/(T - B)/2)*D*sin(α) 또는 단지 D*sin(α)*디스플레이 (12) 의 높이로 나눈 디스플레이 (12) 의 폭) 의 가산을 초래하며, 여기서, 폭은 디스플레이 (12) 의 폭이고 높이는 디스플레이 (12) 의 높이이다.

우측-눈 이미지를 생성하기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 변수 X 의 값을 -D*cos(α) 로 정의할 수도 있다. 이것은 그 우측에서의 뷰잉 로케이션의 이동이 좌측에서 관찰되는 오브젝트의 이동과 동등하기 때문이다. X 가 -D*cos(α) 와 동일할 때, gl_Position.x+= 지령은 정점들로 하여금 우측으로 -D*cos(α) 의 값 만큼 이동하게 하는 애플리케이션 (42) 에 의해 생성되는 정점들의 각각의 x_clip 좌표로부터의, 상수 (예컨대, (z_near*w_world/(R - L)/2)*-D*cos(α) 또는 단지 -D*cos(α)) 의 감산을 초래한다. 또한, 우측-눈 이미지를 생성하기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 변수 Y 의 값을 -D*sin(α) 로 정의할 수도 있다. 이것은 그 상측에서의 뷰잉 로케이션의 이동이 하측에서 관찰되는 오브젝트의 이동과 동등하기 때문이다. Y 가 -D*sin(α) 와 동일할 때, gl_Position.y+= 지령은 정점들로 하여금 우측으로 -D*sin(α)*폭/높이의 값 만큼 이동하게 하는 애플리케이션 (42) 에 의해 생성되는 정점들의 각각의 y_clip 좌표로부터의, 상수 (예컨대, (z_near*w_world/(T - B)/2)*-D*sin(α)*폭/높이 또는 단지 -D*cos(α)*폭/높이) 의 감산을 초래한다.

정점 셰이더 (38) 의 소스 코드를 수정한 후, 애플리케이션 프로세서 (22) 는 정점 셰이더 (38) 의 수정된 소스 코드를 시스템 메모리에 저장할 수도 있다. 일부 예들에서, 애플리케이션 프로세서 (22) 는 정점 셰이더 (38) 의 수정된 소스를 정점 셰이더 (38) 의 미수정된 소스 코드가 시스템 메모리 (36) 에 저장되는 동일한 로케이션에 저장할 수도 있다. 또 다른 예에서, 애플리케이션 프로세서 (22) 는 정점 셰이더 (38) 의 수정된 소스를 정점 셰이더 (38) 의 미수정된 소스 코드가 저장되는 로케이션과는 상이한 시스템 메모리 (36) 내 로케이션에 저장할 수도 있다.

glShaderSource 지령을 발하는 것에 뒤이어서, 애플리케이션 (42) 은 glCompileShader 지령을 발행한다. glCompileShader 지령은 애플리케이션 프로세서 (22) 상에서 실행하는 컴파일러 (28) 로 하여금, 정점 셰이더 (38) 의 수정된 소스 코드를 컴파일하게 한다. 예를 들어, glCompileShader 지령은 컴파일러 (28) 로 하여금, 시스템 메모리 (36) 로부터 수정된 정점 셰이더 (38) 에 대한 소스 코드를 취출하여, 수정된 정점 셰이더 (38) 를 컴파일하게 할 수도 있다. 컴파일한 후, 컴파일러 (28) 는 최종 오브젝트 코드를 시스템 메모리 (36) 에 저장한다. 예를 들어, 예시된 바와 같이, 시스템 메모리 (36) 는 수정된 정점 셰이더 (40) 를 포함한다. 수정된 정점 셰이더 (40) 는 정점 셰이더 (38) 의 수정된 소스 코드를 컴파일링하는 컴파일러 (28) 로부터 유래하는 오브젝트 코드이다.

더욱이, 위에서 설명한 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 정점 셰이더 (28) 로 하여금 좌측-눈 이미지를 생성하기 위해 상수를 gl_Position.x 변수 및 gl_Position.y 변수에 가산하게 하고 우측-눈 이미지를 생성하기 위해 gl_Position.x 및 gl_Position.y 변수로부터 상수를 감산하게 하는 명령들을 정점 셰이더 (28) 의 소스 코드에 포함시킬 수도 있다. 수정된 정점 셰이더 (40) 의 오브젝트 코드는 수정된 정점 셰이더 (40) 로 하여금 좌측-눈 이미지를 생성하기 위해 상수를 gl_Position.x 변수 및 gl_Position.y 변수에 가산하게 하고 우측-눈 이미지를 생성하기 위해 gl_Position.x 변수 및 gl_Position.y 변수로부터 상수를 감산하게 하는 명령들을 포함한다. 좀더 자세하게 설명되는 바와 같이, 수정된 정점 셰이더 (40) 는 애플리케이션 (42) 으로부터의 그리기 지령에 응답하여, 애플리케이션 프로세서 (22) 로부터, 그래픽스 드라이버 래퍼 (26) 를 통해서, 상수의 값을 수신한다.

일부 예들에서, 위에서 설명한 바와 같이, 애플리케이션 프로세서 (22) 는, 일부 오브젝트들이 제로 디스패리티 평면에, 앞에, 또는 뒤에 보이도록, 좌측-눈 이미지 및 우측-눈 이미지에서 정점들의 로케이션을 추가로 조정하기 위해, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 의 명령을 추가로 수정할 수도 있다. 예를 들어, 위에서 설명한 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 다음 명령들, 즉, gl_Position.x += X 및 gl_Position.y += Y*폭/높이를 포함시키기 위해 정점 셰이더 (38) 의 명령들을 수정할 수도 있으며, 여기서, 좌측-눈 이미지에 대해, X 는 +D*cos(α) 와 동일하며 Y 는 +D*sin(α) 와 동일하며, 우측-눈 이미지에 대해, X 는 -D*cos(α) 와 동일하고 Y 는 -D*sin(α) 와 동일하다.

정점 레벨에서 조정을 추가로 가능토록 하기 위해, 그래픽스 드라이버 래퍼 (26) 는 다음 명령들을 포함하도록 정점 셰이더 (38) 의 명령들을 수정할 수도 있다: gl_Position.x += X*(1 - (gl_Position.w/ZDP_loc)) 및 gl_Position.y += Y*폭/높이*(1 - (gl_Position.w/ZDP_loc)). ZDP_loc 는 디스플레이 (12) 대한 제로 디스패리티 평면의 로케이션을 정의하는 사용자 정의된 또는 미리 구성된 값일 수도 있다. 일부 다른 예들에서, 프로세서 (22) 는 카메라 프로세서 (44) 에 의해 결정되는 바와 같은 뷰어의 로케이션의 추정치에 기초하여, 제로 디스패리티 평면의 로케이션의 추정치를 결정할 수도 있다. gl_Position.w 변수는 w_clip 좌표를 저장한다.

예를 들어, gl_Position.x 및 gl_Position.y 변수들과 유사하게, 정점 셰이더 (38) 는 w_clip 좌표들을 gl_Position.w 변수에 저장할 수도 있다. 본 개시물에서 설명되는 예들에서, w_clip 좌표는 애플리케이션 (42) 에 의해 정의되는 바와 같은 프리미티브의 z-좌표의 음수와 동일할 수도 있다. 위에서 설명된 바와 같이, 애플리케이션 (42) 은 프리미티브들을 (x, y, z, w) 로서 정의할 수도 있다. 이들 좌표들은 세계 공간 (world space) 에서 정의되는 것으로 간주될 수도 있다 (즉, 정점의 v_world 좌표들은 (x_world, y_world, z_world, w_world) 이다).

본 개시물에서 설명하는 기법들에서, gl_Position.w 는 -z_world 와 동일할 수도 있다. gl_Position.w 가 -z_world 과 동일한 이유는 상기 방정식들 3 및 4 에서 정의된 PRJ 매트릭스 때문이다. PRJ 매트릭스에서 나타낸 바와 같이, 제 3 칼럼, 제 4 로우의 값은 -1 이다. 상기 방정식 1 에 정의된 바와 같이, Vclip 는 PRJ*MVT*Vworld 과 동일하다. 따라서, PRJ 매트릭스가 Vworld 매트릭스 및 MVT 매트릭스로 곱해질 때, Vworld 의 z_world 좌표는 PRJ 매트릭스의 제 3 칼럼, 제 4 로우의 -1 로 곱해진다. w_clip 좌표는 -1 과의 곱셈의 결과와 동일하며 (즉, w_clip 는 -z_world 와 동일하며), gl_Position.w 변수는 w_clip 의 값을 저장한다 (즉, gl_Position.w 는 -z_world 와 동일하다).

gl_Position.x += X*(1 - (gl_Position.w/ZDP_loc)) 및 gl_Position.y += Y*폭/높이*(1 - (gl_Position.w/ZDP_loc)) 지령들을, gl_Position.x += X*(1 + (z_world/ZDP_loc)) 및 gl_Position.y += Y*폭/높이*(1 + (z_world /ZDP_loc)) 로 치환하는 것이 가능할 수도 있다. 그러나, 그래픽 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 출력되는 z_world 값들의 모두에 액세스하지 않을 수도 있다. 본 개시물에서 설명하는 기법들에서, 정점 셰이더 (38) 가 OpenGL 2.0 ES API 에 따라 설계되면, 일 예로서, 정점 셰이더 (38) 는 w_clip 과 동일한, 이 경우 또한 -z_world 과 동일한, gl_Position.w 변수를 포함하도록 설계될 수도 있다. 따라서, 그래픽스 드라이버 래퍼 (26) 가 z_world 좌표에 액세스할 수 없더라도, 그래픽스 드라이버 래퍼 (26) 는 gl_Position.w 변수를 이용하여, z_world 의 값을 결정할 수도 있다.

z_world 좌표는 애플리케이션 (42) 에 의해 출력된 단일 이미지 내 정점들의 상대적인 심도의 측정치를 제공할 수도 있다. 예를 들어, 애플리케이션 (42) 에 의해 출력된 단일 이미지는 디스플레이 (12) 의 2D 영역에 제한될 수도 있으며; 그러나, 단일 이미지 내 오브젝트들은 정점들의 z_world 좌표에 기초하여 다른 오브젝트들의 앞에 또는 뒤에 보일 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 gl_Position.x += X*(1 - (gl_Position.w/ZDP_loc)) 및 gl_Position.y += Y*폭/높이*(1 - (gl_Position.w/ZDP_loc)) 지령들을 포함하도록 정점 셰이더 (38) 의 명령들을 수정하는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 좌측-눈 이미지에 대해 하나의 방향으로 그리고 우측-눈 이미지에 대해 다른 방향으로 정점들을 얼마나 변위시킬 지를 결정하기 위해 정점들의 상대적인 심도들을 이용할 수도 있다.

예를 들어, (즉, gl_Position.w 변수에 의해 정의되는 바와 같은) 단일 이미지에서의 정점의 -z_world 가 ZDP_loc 과 동일할 때, gl_Position.x += 0, 및 gl_Position.y += 0 이다. 이 경우, 수정된 정점 셰이더 (38) 는 좌측-눈 이미지에 대한 gl_Position.x 및 gl_Position.y 가 우측-눈 이미지에 대한 gl_Position.x 및 gl_Postion.y 와 각각 동일하기 때문에 좌측-눈 이미지 또는 우측-눈 이미지에서 정점을 변위시키지 않을 수도 있다. 그러나, 단일 이미지에서 정점의 -z_world 가 ZDP_loc 과 동일하지 않을 때, 수정된 정점 셰이더 (38) 는 시야각에 기초하여 좌측-눈 이미지에 대해 하나의 방향으로, 그리고 시야각에 기초하여 우측-눈 이미지에 대해 또 다른 방향으로 정점을 변위시킬 수도 있다. 더욱이, 애플리케이션 (42) 에 의해 생성되는 단일 이미지에서 정점들에 대한 -z_world 좌표가 상이하지 않을 수도 있기 때문에, 수정된 정점 셰이더 (38) 는 좌측-눈 이미지 및 우측-눈 이미지를 생성하기 위해 단일 이미지에서 상이한 정점들을 상이한 양들만큼 변위시킬 수도 있다.

다시 말해서, (1 - (gl_Position.w/ZDP_loc)) 와 X 및 Y*폭/높이 변수들의 추가적인 곱셈은 얼마나 정점이 좌측-눈 이미지 및 우측-눈 이미지에서 변위되는 지의 정점 레벨 결정을 초래한다. 또한, 단일 이미지에서의 정점들이 z_world의 값에 기초하여 상이한 양들만큼 변위될 수도 있기 때문에, 최종 입체 뷰에서, 일부 오브젝트들은 제로 디스패리티 평면의 앞에 보일 수도 있으며, 일부 오브젝트들은 제로 디스패리티 평면에 보일 수도 있으며, 일부 오브젝트들은 제로 디스패리티 평면의 뒤에 보일 수도 있다.

일부 예들에서, X 및 Y*폭/높이 변수들을 (1 - (gl_Position.w/ZDP_loc)) 과 곱하기 위해 정점 셰이더 (38) 의 명령들을 추가로 수정하는 것 대신에 또는 더해서, 그래픽스 드라이버 래퍼 (26) 는 제로 디스패리티 평면의 로케이션을 조정하기 위해 glViewport 지령을 수정할 수도 있다. 예를 들어, 애플리케이션 (42) 은, 프로세서 (22) 에 의한 실행 즉시, 또한 단일 이미지의 뷰포트를 정의하는 지령 (예컨대, 디스플레이 (12) 상에서 단일 이미지의 사이즈 및 로케이션을 정의하는 지령) 을 발할 수도 있다. 이 지령은 glViewport 지령일 수도 있다. glViewport 지령은 이미지에 대한 시작 좌표들 (예컨대, x 및 y 좌표들) 및 이미지의 폭 및 길이를 정의한다. glViewport 지령의 시작 좌표들 및 폭 및 길이 값들은 이미지의 사이즈 및 로케이션을 정의한다.

일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 캡쳐할 수도 있다. 이들 예들에서, 그래픽스 드라이버 래퍼 (26) 는 그래픽스 드라이버 (24) 가 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 GPU (30) 로 송신하는 것을 차단할 수도 있다. 대신, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 것과 같은, glViewport 지령의 시작 좌표들 및 폭 및 길이 값들을 시스템 메모리 (36) 에 저장할 수도 있다.

대안적인 예에서, 그래픽스 드라이버 래퍼 (26) 는 그래픽스 드라이버 (24) 로 하여금 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 GPU (30) 로 송신가능하게 할 수도 있다. 이 예에서, 위와 유사하게, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 바와 같은, glViewport 지령의 시작 좌표들 및 폭 및 길이 값들을 저장할 수도 있다. 이 대안적인 예에서, GPU (30) 가 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 적용하기 전에, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수정하여, 수정된 glViewport 지령을 GPU (30) 로 송신할 수도 있다. 이러한 방법으로, GPU (30) 가 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수신하더라도, GPU (30) 는 그래픽스 드라이버 래퍼 (26) 에 의해 수정되는 그 수정된 glViewport 지령을 실행할 수도 있다.

어느 하나의 예에서, 그래픽스 드라이버 래퍼 (26) 는 그후 애플리케이션 (42) 이 GPU (30) 에게 하나 이상의 프리미티브들을 그릴 것을 명령하는 지령을 GPU (30) 에게 발할 때까지 대기할 수도 있다. 이 그리기 지령은 glDraw 지령일 수도 있다. glDrawArrays 및 glDrawElements 와 같은 glDraw 지령들의 여러 예들이 존재한다. 이들 그리기 지령들의 여러 예들의 각각은 glDraw 지령으로서 일반적으로 지칭된다.

애플리케이션 (42) 이 glDraw 지령을 발할 때, 그래픽스 드라이버 래퍼 (26) 는 glDraw 지령을 캡쳐하고, 그래픽스 드라이버 (24) 가 glDraw 지령을 GPU (30) 로 송신하는 것을 차단한다. 그래픽스 드라이버 래퍼 (26) 는 그후 GPU (30) 로 하여금 좌측-눈 이미지 및 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하도록 하는 명령들을 생성한다. 일 예로서, 그래픽 드라이버 래퍼 (36) 는 GPU (30) 로 하여금 수정된 정점 셰이더 (40) 의 오브젝트 코드를 두번 실행하도록 하는 명령들을 생성하고, 2개의 glViewport 지령들을 발행하여 좌측-눈 이미지에 대한 뷰포트 및 우측-눈 이미지를 정의하고, 2개의 glDraw 지령들을 발행한다.

그래픽스 드라이버 래퍼 (26) 가 X 및 Y*폭/높이 변수들을 (1 - (gl_Position.w/ZDP_loc)) 로 곱하기 위해 정점 셰이더 (38) 의 명령들을 수정하는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령들을 수정하지 않을 수도 있으며, 그러나 여전히 glViewport 지령들을, 좌측-눈 이미지 및 우측-눈 이미지의 각각에 대해 하나씩 발할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 X 및 Y*폭/높이 변수들을 (1 - (gl_Position.w/ZDP_loc)) 로 곱하기 위해 정점 셰이더 (38) 의 명령을 수정하지 않는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령을 수정하여 2개의 glViewport 지령들을 발할 수도 있으며, 여기서, 2개의 glViewport 지령들은 애플리케이션 (42) 에 의해 발행되는 glViewport 지령과 상이하다.

정점들 사이의 디스패리티의 정점 레벨 조정 또는 좌측-눈 이미지와 우측-눈 이미지 사이의 디스패리티의 이미지 레벨 조정을 위한 기법들의 개관으로서, 그래픽스 드라이버 (24) 가 애플리케이션 (42) 에 의해 발행되는 glDraw 지령을 송신하는 것을 그래픽스 드라이버 래퍼 (26) 가 차단한 후, 그래픽스 드라이버 래퍼 (26) 는 셰이더 프로세서 (32) 로 하여금 수정된 정점 셰이더 (40) 를 준비시켜 입체 뷰의 제 1 이미지 (예컨대, 좌측-눈 이미지) 에 대한 클리핑 좌표들을 생성하도록 하는 지령을 GPU (30) 로 발행한다. 그 후, 그래픽스 드라이버 래퍼 (26) 는 디스플레이 상에서 제 1 이미지의 사이즈 및 로케이션을 정의하는 제 1 glViewport 지령을 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛으로 발할 수도 있다. 그래픽스 드라이버 래퍼 (26) 는 그후 GPU (30) 로 하여금 제 1 glViewport 지령에 의해 정의된 바와 같은 디스플레이의 제 1 부분에 제한되는 제 1 이미지를 렌더링하도록 하는 제 1 glDraw 지령을 GPU (30) 로 발할 수도 있다.

그래픽스 드라이버 래퍼 (26) 는 그후 셰이더 프로세서 (22) 로 하여금 수정된 정점 셰이더 (40) 를 준비시켜 입체 뷰의 제 2 이미지 (예컨대, 우측-눈 이미지) 에 대한 클리핑 좌표들을 생성하도록 하는 지령을 GPU (30) 로 발할 수도 있다. 그 후, 그래픽스 드라이버 래퍼 (26) 는 디스플레이 상에서 제 2 이미지의 사이즈 및 로케이션을 정의하는 제 2 glViewport 지령을 뷰포트 대 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛으로 발할 수도 있다. 그래픽스 드라이버 래퍼 (26) 는 그후 GPU (30) 로 하여금 제 2 glViewport 지령에 의해 정의된 바와 같은 디스플레이의 제 2 부분에 제한되는 제 2 이미지를 렌더링하도록 하는 제 2 glDraw 지령을 GPU (30) 로 발할 수도 있다.

위 개관으로서 설명된 바와 같은, 본 개시물의 기법들은, 다음 예들에서 좀더 자세히 설명된다. 단지 이해의 용이성을 위해, 다음 예들에서, 기법들은 GPU (30) 가 좌측-눈 이미지에 대한 그래픽스 콘텐츠를 먼저 생성하고, 이어서 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하는 것으로 설명된다; 그러나, 반대도 또한 가능하다.

예를 들어, 그래픽스 드라이버 래퍼 (26) 가 glViewport 지령을 인터셉트하고 그후 애플리케이션 (42) 에 의해 발행되는 glDraw 지령을 차단한 후, 그래픽스 드라이버 래퍼 (26) 는 GPU (30) 에게 좌측-눈 이미지에 대한 클리핑 좌표들을 생성할 것을 명령하는 명령을 생성한다. 또, 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 GPU (30) 로 발행되는 glViewport 지령의 송신을 차단할 수도 있다는 점에 유의해야 한다. 다른 예들에서, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glViewport 지령이 GPU (30) 로 송신될 수 있게 할 수도 있다.

일 예로서, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, GPU (30) 로 하여금 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하도록 하는 명령을 생성한다. 이에 응답하여, GPU (30) 의 셰이더 프로세서 (32) 는 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행한다. 게다가, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 수정된 정점 셰이더 (30) 가 좌측-눈 이미지에 대한 클리핑 좌표들을 생성하기 위해 gl_Position.x 변수에 가산할 상수 값을 송신한다. 셰이더 프로세서 (42) 의 출력은, 수정된 정점 셰이더 (40) 의 오브젝트 코드의 실행으로 인해, 좌측-눈 이미지의 정점들에 대한 클리핑 좌표들이다.

예를 들어, 위에서 설명한 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 설명될 이유로, 다음 명령들을 정점 셰이더 (38) 의 소스 코드에 포함시킬 수도 있다: gl_Position.x+ = (z_near*w_world/(R-L)/2)*X, 또는 단지 gl_Position.x+ = X 및 gl_Postion.y += (z_near*w_world/(T-B)/2)*Y, 또는 단지 gl_Position.y+ = Y*폭/높이. 위에서 설명된 바와 같이, 정점들 사이의 디스패리티의 정점 레벨 조정을 위해, 그래픽스 드라이버 래퍼 (26) 는 정점 셰이더 (38) 의 소스 코드에서 gl_Position.x 및 gl_Postion.y 지령들을 추가로 수정할 수도 있다. 예를 들어, 이들 예들에서, 그래픽스 드라이버 래퍼 (26) 는 설명될 이유로 다음 명령들을 정점 셰이더 (38) 의 소스 코드에 포함시킬 수도 있다: gl_Position.x+ = (z_near*w_world/(R-L)/2)*X*(1 - (gl_Position.w/ZDP_loc)), 또는 단지 gl_Position.x+ = X*(1 - (gl_Position.w/ZDP_loc)) 및 gl_Postion.y += (z_near*w_world/(T-B)/2)*Y*(1 - (gl_Position.w/ZDP_loc)), 또는 단지 gl_Position.y+ = Y*폭/높이*(1 - (gl_Position.w/ZDP_loc)).

z_near, w_world, R, L, T, 및 B 변수들은 방정식들 (2) 및 (4) 에 대해 위에서 설명한 바와 같이, 셰이더 프로세서 (32) 에 어쩌면 알려져 있을 수도 있다. 그러나, 본 개시물의 양태들은 셰이더 프로세서 (32) 가 z_near, w_world, R, L, T, 및 B 변수들의 값들을 알고 있는 것을 필요로 하지 않는다. 예를 들어, z_near, w_world, R, L, T, 및 B 변수들은 각각 상수들일 수도 있으며, 따라서, (z_near*w_world/(R-L)/2) 및 (z_near*w_world/(T-B)/2) 의 결과는 상수 값일 것이다. 이 경우, (z_near*w_world/(R-L)/2) 및 (z_near*w_world/(T-B)/2) 의 값은 적합한 경우, 추정되거나 또는 사용자 제공되어, X 또는 Y 의 값에 곱해질 수도 있다. 좀더 자세하게 설명되는 바와 같이, 일부 예들에서, (z_near*w_world/(R-L)/2) 는 1 로 간략화할 수도 있으며 (z_near*w_world/(T-B)/2) 는 디스플레이 (12) 의 폭/높이로 간략화할 수도 있다.

일부 예들에서, 셰이더 프로세서 (32) 는 X 및 Y 의 값을 알지 있지 못할 수도 있다. 좌측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 셰이더 프로세서 (32) 에게 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하도록 하는 명령에 더해서, X 및 Y 의 값을 셰이더 프로세서 (32) 로 송신할 수도 있다. 일부 예들에서, 좌측-눈 이미지에 대해, X 의 값은 +D*cos(α) 일 수도 있으며 좌측-눈 이미지에 대해, Y 의 값은 +D*sin(α) 일 수도 있으며, 여기서, D 는 뷰어의 눈들 사이의 거리의 대략 절반과 동일하며 사용자 정의되거나 또는 사전 프로그래밍될 수도 있으며, alpha, α 는 프로세서 (22) 에 의해 결정된 바와 같은 시야각과 동일하다. 변수 X 의 값이 +D*cos(α) 이기 때문에, gl_Position.x+= 지령은 셰이더 프로세서 (32) 로 하여금 D*cos(α) 의 값을 gl_Position.x 변수에 저장된 값에 가산하도록 (예컨대, D*cos(α) 을 x_clip 의 값에 가산하도록) 한다. 또한, Y 의 값이 +D*sin(α) 이기 때문에, gl_Position.y += 지령은 셰이더 프로세서 (32) 로 하여금 D*sin(α)*폭/높이의 값을 gl_Position.y 변수에 저장된 값에 가산하도록 (예컨대, D*sin(α)*폭/높이를 가산하도록) 한다.

또, 정점들의 정점 레벨 조정을 위해, 추가된 gl_Position.x += 지령은 셰이더 프로세서 (32) 로 하여금 D*cos(α)*(1 - (gl_Position.w)/(ZDP_loc) 의 값을 gl_Position.x 변수에 저장된 값에 가산하도록 하며, 추가된 gl_Position.y += 지령은 셰이더 프로세서 (32) 로 하여금 D*sin(α)*(1 - (gl_Position.w)/(ZDP_loc) 의 값을 gl_Position.y 변수에 저장된 값에 가산하도록 한다. 그러나, 정점들의 이러한 정점 레벨 조정은 모든 예에서 필수적인 것은 아니다.

그래픽스 드라이버 래퍼 (26) 는 또한 좌측-눈 이미지에 대한 뷰포트를 정의한다. 예를 들어, 애플리케이션 (42) 이 glDraw 지령을 발할 때 이전에, 애플리케이션 (42) 은 그래픽스 드라이버 래퍼 (26) 가 인터셉트한 glViewport 지령을 발행했다. 그래픽스 드라이버 래퍼 (26) 는 또한 시작 좌표들 및 폭 및 길이 값들을 시스템 메모리 (36) 에 저장하였다. 그래픽스 드라이버 래퍼 (26) 가 정점들 사이의 디스패리티의 정점 레벨 조정을 위한 정점 셰이더 (38) 의 명령들을 수정한 예들에서, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령의 명령들을 수정하지 않을 수도 있으며, 대신 애플리케이션 (42) 에 의해 발행되는 glViewport 지령과는 동일한 2개의 glViewport 지령들 수정할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점들 사이의 디스패리티의 정점 레벨 조정을 위해 정점 셰이더 (38) 의 명령들을 수정하지 않는 예들에서, 그래픽스 드라이버 (26) 는 제로 디스패리티 평면의 로케이션을 결정하기 위해 아래에서 설명되는 바와 같이 glViewport 지령의 명령들을 수정할 수도 있다.

제로 디스패리티 평면의 이미지 레벨 조정을 위한 좌측-눈 이미지에 대한 뷰포트를 정의하기 위해, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 인터셉트한 glViewport 지령을 수정할 수도 있다. 예를 들어, glViewport 지령은 4개의 변수들을 포함하며, 여기서, 처음 2개의 변수들은 디스플레이 상의 이미지에 대한 시작 좌표를 정의하며, 최종 2개의 변수들은 이미지의 폭 및 길이를 정의한다. 폭 및 길이 변수들은 반드시 좌표 값들은 아니다. 대신, 폭 및 길이 변수들은 이미지가 시작 좌표들로부터 연장하는 양을 정의한다. 예를 들어, 애플리케이션 (42) 은 glViewport (0, 0, 폭, 길이) 을 지정하는 glViewport 지령을 발행한다. 이 예에서, (0, 0) 는 디스플레이의 좌하단을 지칭한다. 변수 "폭" 은 디스플레이의 폭을 지칭하며, 변수 "길이" 는 디스플레이의 길이를 지칭한다. 따라서, 이 예에서, 애플리케이션 (42) 은 모노 뷰 이미지에 부합할 디스플레이 전체를 둘러싸도록 이미지의 뷰포트를 정의한다. 그러나, 애플리케이션 (42) 은 예시된 것들 외에, glViewport 지령에 대해 상이한 변수들을 할당할 수도 있다.

본 개시물에 따르면, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령 (예컨대, 이전 예의 glViewport (0, 0, 폭, 길이)) 을 인터셉트하고, 이 뷰포트 지령에 대한 변수들을 수정할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 좌측-눈 이미지를 디스플레이의 원하는 부분에 제한하기 위해 glViewport 지령의 변수들을 수정할 수도 있다. 설명의 용이성을 위해, 기법들은 좌측-눈 이미지를 디스플레이의 좌측 절반에, 그리고 우측-눈 이미지를 디스플레이의 우측 절반에 제한하는 것으로 설명하며; 그러나, 양태들은 이에 한정되지 않는다.

좌측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 glViewport (0, 0, 폭/2, 길이) 로 발행되는 glViewport 지령을 수정할 수도 있다. 이 예에서, 폭/2 은 디스플레이의 폭의 절반일 것이다. 예를 들어, 수정된 glViewport 지령은 좌측-눈 이미지가 디스플레이의 좌측 단으로부터 시작하여 (예컨대, X-축 상의 0 지점으로부터 시작하여) 우측으로 "폭/2" 의 거리를 연장하고 이것이 좌측-눈 이미지를 디스플레이의 좌측 절반에 제한할 것이라는 것을 나타낸다. 또한, 수정된 glViewport 지령은 좌측-눈 이미지가 디스플레이의 하단으로부터 시작하여 (예컨대, Y-축 상의 0 지점으로부터 시작하여) 상방으로 "길이" 의 거리를 연장하고 이것이 이미지를 디스플레이의 상단 및 하단에 제한할 것이라는 것을 나타낸다.

(예컨대, glViewport 지령이 수정되거나 또는 glViewport 지령이 수정되지 않는) 어느 하나의 예에서, 그래픽스 드라이버 래퍼 (26) 는 그후 제 1 glDraw 지령을 GPU (30) 로 발할 수도 있다. glDraw 지령에 응답하여, GPU (30) 는 고정-기능 파이프라인 (34) 및 프래그먼트 셰이더들을 통해서, 수정된 정점 셰이더 (40) 의 오브젝트 코드의 실행에 의해 생성되는 좌측-눈 이미지에 대한 클리핑 좌표들을 프로세싱할 수도 있다. glViewport 지령 변경이 있는 예에서, 제 1 glViewport 지령은 좌측-눈 이미지를 디스플레이의 좌측 절반에 제한할 수도 있다. glViewport 지령 변경이 없는 예에서, 제 1 glViewport 지령은 좌측-눈 이미지를 디스플레이의 좌측 절반에 제한할 수도 있다. glDraw 지령은 그후 GPU (30) 로 하여금 좌측-눈 이미지를 임시의 저장을 위해 프레임 버퍼로 렌더링하도록 할 수도 있다. 예를 들어, 프레임 버퍼는 우측-눈 이미지가 생성될 때까지 좌측-눈 이미지를 저장할 수도 있다. 그 후, GPU (30) 는 프레임 버퍼 전체를 디스플레이 프로세서 (미도시) 로 출력할 수도 있다. 디스플레이 프로세서는 디스플레이로 하여금 좌측-눈 이미지 및 우측-눈 이미지를 디스플레이시켜 입체 뷰를 생성하도록 할 수도 있다.

그래픽스 드라이버 래퍼 (26) 는 우측-눈 이미지를 생성하는 것을 제외한, 좌측-눈 이미지를 생성하는 것에 대해 동일한 단계들을 반복할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 또 다른 명령을 발행하여, 셰이더 프로세서 (32) 로 하여금 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하도록 한다. 게다가, 그래픽스 드라이버 래퍼 (26) 는 수정된 정점 셰이더 (40) 가 우측-눈 이미지에 대한 클리핑 좌표들을 생성하기 위해 gl_Position.x 변수로부터 감산할, 그리고 좌측-눈 이미지에 대한 클리핑 좌표들을 생성하기 위해 gl_Position.y 변수부터 감산할 상수 값을 송신할 수도 있다. 셰이더 프로세서 (32) 의 출력은, 수정된 정점 셰이더 (40) 의 오브젝트 코드의 실행으로 인해, 우측-눈 이미지의 정점들에 대한 클리핑 좌표들이다.

위에서 설명된 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 명령 gl_Position.x+ = (z_near*w_world/(R-L)/2)*X, 또는 단지 gl_Position.x+ = X 를 정점 셰이더 (38) 의 소스 코드에 추가하고, 명령 gl_Position.y += (z_near*w_world/(T-B)/2)*Y, 또는 단지 gl_Position.y+ = Y*폭/높이를 추가할 수도 있다. 좌측-눈 이미지에 대해, 변수 X 의 값은 +D*cos(α) 일 수도 있으며 변수 Y 의 값은 +D*sin(α) 일 수도 있다. 본 개시물의 예들에서, 우측-눈 이미지에 대해, 변수 X 의 값은 -D*cos(α) 일 수도 있으며 변수 Y 의 값은 -D*sin(α) 일 수도 있다. 변수 X 의 값이 -D*cos(α) 이기 때문에, gl_Position.x+= 지령은 셰이더 프로세서 (32) 로 하여금 gl_Position.x 변수에 저장된 값으로부터 D*cos(α) 의 값을 감산시키도록 한다. 또한, 변수 Y 의 값이 -D*sin(α) 이기 때문에, gl_Position.y+= 지령은 셰이더 프로세서 (32) 로 하여금 gl_Position.y 변수에 저장된 값으로부터 D*sin(α)*폭/높이의 값을 감산시키도록 한다.

(예컨대, 좌측-눈 이미지와 우측-눈 이미지 사이의 디스패리티의 이미지 레벨 조정을 위한) 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 또한 우측-눈 이미지에 대한 뷰포트를 정의한다. 위에서 설명한 바와 같이, 좌측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 좌측-눈 이미지를 디스플레이의 좌측 절반에 제한하기 위해 뷰포트를 glViewport (0, 0, 폭/2, 길이) 인 것으로 정의한다. 우측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 뷰포트를 glViewport (폭/2, 0, 폭/2, 길이) 인 것으로 정의할 수도 있다. 이 예에서, (폭/2, 0) 좌표는 우측-눈 이미지가 디스플레이의 중간으로부터 시작하여 우측으로 연장할 것이라는 것을 나타낸다. 또한, glViewport 지령에서 (폭/2, 길이) 변수들은 우측-눈 이미지가 디스플레이 폭의 절반과 디스플레이의 전체 길이를 연장할 것이라는 것을 나타낸다.

따라서, 이 예에서, 수정된 glViewport 지령 (예컨대, glViewport (폭/2, 0, 폭/2, 길이)) 는 우측-눈 이미지를 디스플레이의 우측 절반에 제한할 것이다. 예를 들어, 수정된 glViewport 지령은 우측-눈 이미지가 디스플레이의 중간으로부터 시작하여 (예컨대, X-축 상의 폭/2 지점으로부터 시작하여) 우측으로 "폭/2" 의 거리를 연장할 것이며 이것이 우측-눈 이미지를 디스플레이의 우측 절반에 제한할 것이라는 것을 나타낸다. 또한, 수정된 glViewport 지령은 우측-눈 이미지가 디스플레이의 하단에서 시작하여 (예컨대, Y-축 상의 0 지점에서 시작하여) 상방으로 "길이" 의 거리를 연장할 것이며 이것이 이미지를 디스플레이의 상단 및 하단에 제한할 것이라는 것을 나타낸다.

그래픽스 드라이버 래퍼 (26) 는 그후 제 2 glDraw 지령을 GPU (30) 로 발할 수도 있다. glDraw 지령에 응답하여, GPU (30) 는 고정-기능 파이프라인 (34) 및 프래그먼트 셰이더들을 통해서, 수정된 정점 셰이더 (40) 의 오브젝트 코드의 실행에 의해 생성되는 우측-눈 이미지에 대한 클리핑 좌표들을 프로세싱할 수도 있다. glDraw 지령은 그후 GPU (30) 로 하여금, 우측-눈 이미지를 임시의 저장을 위해 프레임 버퍼로 렌더링하도록 할 수도 있다. 이 경우, GPU (30) 는 좌측-눈 이미지를 프레임 버퍼에 이미 저장하고 있을 수도 있으며, GPU (30) 는 입체 뷰를 생성하기 위해 디스플레이 프로세서에게 프레임 버퍼로부터 그 저장된 좌측-눈 이미지 및 우측-눈 이미지를 취출하여 디스플레이할 것을 명령할 수도 있다.

위에서 설명된 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 명령 gl_Position.x+= 지령 및 gl_Position.y+= 지령을 정점 셰이더 (38) 의 소스 코드에 추가할 수도 있다. 정점 셰이더 (38) 의 소스 코드에 추가되는 gl_Position.x+= 지령 및 gl_Position.y+= 지령은 입체 뷰의 나오게 하거나 또는 들어가는 효과를 일으키기 위해 시야각에 기초하여 좌측-눈 이미지와 우측-눈 이미지 사이의 경미한 변위를 일으킨다.

glViewport 지령에 대한 변경의 상기 예들에서는, glViewport 지령에 대한 변경은 좌측-눈 이미지를 디스플레이 (12) 의 좌측 절반에 제한하였으며, 우측-눈 이미지를 디스플레이 (12) 의 우측 절반에 제한하였다. 그러나, 좌측-눈 이미지를 디스플레이 (12) 의 좌측 절반에 제한하는 것 및 우측-눈 이미지를 디스플레이 (12) 의 우측 절반에 제한하는 것은 시야각, α 을 활용하지 않을 수도 있다. 또한, 좌측-눈 이미지를 디스플레이 (12) 의 좌측 절반에 제한하는 것, 및 우측-눈 이미지를 디스플레이 (12) 의 우측 절반에 제한하는 것은 뷰어가 ZDP 의 원하는 로케이션을 설정하는 것을 허용하지 않을 수도 있다.

다음은 그래픽 드라이버 래퍼 (26) 가 시야각을 활용하여 원하는 로케이션에서 제로 디스패리티 평면의 설정을 가능하도록 glViewport 지령을 수정할 수 있는 방법을 설명한다. 예를 들어, 위와 같이, 애플리케이션 (42) 에 의해 정의되는 뷰포트가 glViewport (0, 0, 폭, 높이) 라고 가정하며, 여기서, 디스플레이 (12) 의 좌하단의 로케이션은 (0, 0) 이고, 디스플레이 (12) 의 우상단의 로케이션은 (폭, 높이) 이다.

이 경우, 좌측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령을 glViewport (-VPshift*cos(α), -VPshift*sin(α), 폭 - VPshift*cos(α), 높이 - Vpshift*sin(α)) 인 것으로 수정할 수도 있으며, 여기서, (-VPshift*cos(α), -VPshift*sin(α)) 는 좌측-눈 이미지의 좌하단이고 (폭 - VPshift*cos(α), 높이 - Vpshift*sin(α)) 는 좌측-눈 이미지의 우측-상부이다. 우측-눈 이미지에 대해, 그래픽스 드라이버 래퍼 (26) 는 glViewport 지령을 glViewport (VPshift*cos(α), VPshift*sin(α), 폭 + VPshift*cos(α), 높이 + VPshift*sin(α)) 인 것으로 수정할 수도 있으며, 여기서, (VPshift*cos(α), VPshift*sin(α)) 는 우측-눈 이미지의 좌하단이고, (폭 + VPshift*cos(α), 높이 + VPshift*sin(α)) 는 우측-눈 이미지의 우측-상부이다.

상기 예에서, VPshift 변수는 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티의 양을 정의할 수도 있다. 예를 들어, VPshift 는 위에서 설명된 수평 디스패리티 값일 수도 있다. 수평 디스패리티 값은 좌측-눈 이미지 및 우측-눈 이미지의 뷰포트들이 서로에 대해 시프트되는 양 (즉, 뷰포트 시프트의 양), 따라서 변수 VPshift 를 나타낼 수도 있다. 뷰어는 제로 디스패리티 평면의 로케이션을 정의하기 위해 VPshift 의 값을 정의할 수도 있다. 또 다른 예로서, 프로세서 (22) 는 뷰어가 디스플레이 (12) 에 대해 얼마나 멀리 떨어져 있는지의 추정에 기초하여 VPshift 의 값을 결정하도록 구성될 수도 있다. 또 다른 예로서, 애플리케이션 (22) 또는 그래픽스 드라이버 래퍼 (26) 는 VPshift 에 대한 값으로 미리 구성될 수도 있다.

일부 예들에서, 그래픽스 드라이버 래퍼 (26) 는 뷰포트 스트레치를 위해 좌측-눈 및 우측-눈 이미지들에 대한 glViewport 지령들을 추가로 수정할 수도 있다. 뷰포트 스트레칭은 좌측-눈 이미지와 우측-눈 이미지 사이에 중첩이 잠재적으로 존재하도록, 좌측-눈 이미지 및 우측-눈 이미지의 뷰포트들을 확장시킨다. 예를 들어, 뷰포트 스트레치 없이, 좌측-눈 이미지 및 우측-눈 이미지는 디스플레이 상의 각각의 부분들에 제한될 수도 있으며, 중첩이 없을 수도 있다. 중첩을 증가시키거나 또는 감소시키기 위해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 뷰포트 스트레치를 포함하도록 glViewport 지령들을 추가로 수정할 수도 있다. 뷰포트 스트레칭은 또한 제로 디스패리티 평면의 로케이션에 영향을 미칠 수도 있으며, 제로 디스패리티 평면의 로케이션을 원하는 로케이션으로 제어하는 여전히 또 다른 방법을 제공할 수도 있다.

뷰포트 스트레치를 포함하기 위해 glViewport 지령을 수정하는 것은 모든 예에서 필수적인 것은 아니다. 더욱이, 본 개시물에서 설명하는 기법들에 따르면, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 시야각에 기초하여 뷰포트 스트레치를 포함하도록 glViewport 지령을 수정할 수도 있다. 예를 들어, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 다음과 같이 glViewport 지령들을 수정할 수도 있다. 좌측-눈 이미지의 뷰포트에 대해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, glViewport 지령을 glViewport(-VPshift*cos(α), -VPshift*sin(α), 폭, 높이) 로 수정할 수도 있다. 우측-눈 이미지의 뷰포트에 대해, 애플리케이션 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, glViewport 지령을 glViewport(0, 0, 폭+VPshift*cos(α), 높이+VPshift*sin(α)) 로 수정할 수도 있다.

위에서 설명된 바와 같이, 본 개시물에서 설명하는 기법들은 실행 또는 런 타임 동안 모노 뷰에 대한 이미지를 생성하여 입체 뷰에 대한 이미지들을 생성하기 위해 명령들을 수정할 수도 있다. 예를 들어, 뷰어는 실행을 위해 애플리케이션 (42) 을 선택할 수도 있으며, 이것은 애플리케이션 (42) 의 실행에 의해 생성되는 그래픽스를 프로세싱하기 위한 정점 셰이더 (38) 의 실행을 필요로 할 수도 있다. 애플리케이션 (42) 이 디바이스 (10) 상에서 실행 중이거나 작동 중에 있는 동안, 그래픽스 드라이버 (24), 그래픽스 드라이버 래퍼 (26), 및 컴파일러 (28) 는 애플리케이션 프로세서 (22) 상에서 그들의 각각의 기능들을 수행하여, 애플리케이션 프로세서 (22) 로 하여금 정점 셰이더 (38) 의 소스 코드를 수정하고 수정된 정점 셰이더 (40) 에 대한 오브젝트 코드를 생성하게 할 수도 있다. 다시 말해서, 3D 그래픽스 대 S3D 그래픽스 변환은 사전 프로그래밍된 S3D 그래픽스 콘텐츠 또는 사전 기록된 S3D 이미지들 또는 비디오를 필요로 하기 보다는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 애플리케이션 프로세서 (22) 에 의해, 런-타임으로 수행된다.

또한, 상기 예들은 애플리케이션 프로세서 (22) 가, 그래픽스 드라이버 래퍼 (26) 를 통해서, 명령들을 추가하여 정점 셰이더 (38) 의 명령들을 수정하고 뷰포트를 정의하는 명령을 수정하는 상황에서 설명되지만, 본 개시물의 양태들은 이에 제한되지 않는다. 일부 예들에서, 그래픽스 드라이버 래퍼 (26) 보다는, 애플리케이션 프로세서 (22) 가, 그래픽스 드라이버 (24) 또는 컴파일러 (28) 를 통해서, 정점 셰이더 (38) 의 명령들 및 애플리케이션 (42) 에 의해 출력되는 명령들을 수정하는 것이 가능할 수도 있다. 그러나, 이들 예들은 그래픽스 드라이버 (24) 또는 컴파일러 (28) 에 대한 변경을 필요로 할 수도 있다.

그래픽스 드라이버 (24) 또는 컴파일러 (28) 에 대한 변경은, 그래픽스 드라이버 래퍼 (26) 를 개발하는 것, 및 GPU (30) 가 입체 뷰에 대한 좌측-눈 이미지 및 우측-눈 이미지를 생성하도록 애플리케이션 프로세서 (22) 가 그래픽스 드라이버 래퍼 (26) 를 통해서 본 개시물에서 설명되는 기능들을 수행하도록 하는 것보다, 더 어려울 수도 있다. 예를 들어, 디바이스 (10) 는 기존 그래픽스 드라이버 (24) 및 컴파일러 (28) 로 로드되어 있을 수도 있으며, 그래픽스 드라이버 (24) 및 컴파일러 (28) 를 변경하는 것이 어려울 수도 있다. 애플리케이션 프로세서 (22) 로 하여금 정점 셰이더 (38) 에 대한 변경을 수행할 수 있도록 하기 위해 그래픽스 드라이버 래퍼 (26) 를 추가함으로써, 예시적인 기법들은 기존 그래픽스 드라이버 (24) 및 컴파일러 (28) 에 대한 변경을 필요로 하지 않을 수도 있다.

더욱이, 위에서 설명된 기법들은 GPU (30) 에게 애플리케이션 (42) 에 대한 변경 없이 입체 뷰에 대한 이미지들을 생성이능하게 할 수도 있다. 예를 들어, 입체 뷰를 생성하기 위한 일부 다른 기법들은 애플리케이션 (42) 의 개발자들이 좌측-눈 및 우측-눈 이미지들에 대한 픽셀 값들을 생성하기 위해 애플리케이션 (42) 의 소스 코드를 수정하도록 요구할 수도 있다. 이들 기법들은 입체 뷰에 대한 그들의 애플리케이션들을 수정하기 위해 애플리케이션 (42) 의 개발자로부터의 지원을 필요로 하였으며, 이것은 애플리케이션 (42) 의 개발자에게 잠재적으로 번거로운 태스크일 수도 있다. 위에서 설명된 예시적인 기법들은 애플리케이션 (42) 의 개발자로부터의 어떤 지원 없이, 모노 뷰 용으로 개발된 애플리케이션 (42) 에 입체 뷰를 제공할 수도 있다.

더욱이, 일부 다른 기법들은 3D 그래픽스를 S3D 그래픽스로 런-타임으로 변환하도록 제안되었다. 그러나, 이들 다른 기법들은 시야각을 이용하지 않을 수도 있다. 예를 들어, 이들 다른 기법들에서, 시야각이 변하면, 최종 입체 뷰는 오히려 이상적이지 않게 보일 수도 있다. 시야각을 활용함으로써, 본 기법들은 뷰어가 디스플레이 (12) 를 보고 있는 각도에 관계없이 또는 디스플레이 (12) 의 각도에 관계없이 더 풍부한 뷰잉 경험을 제공한다.

또한, 위에서 설명된 기법들은 입체 뷰에 대한 좌측-눈 및 우측-눈 이미지들을 생성하기 위해 시스템 메모리 (26) 에 대한 다수의 호출들을 필요로 하지 않을 수도 있다. 예를 들어, 일부 다른 기법들에서, 입체 뷰를 생성하기 위해 GPU 는 좌측-눈 이미지를 생성할 것이다. 좌측-눈 이미지의 생성의 완료 즉시, GPU 는 우측-눈 이미지를 생성하기 위해 좌측-눈 이미지를 생성하는 동시에, 시스템 메모리 (36) 에 저장된 심도 정보를 이용할 것이다. 그러나, 심도 정보를 취출하기 위한 시스템 메모리 (36) 에 대한 반복된 호출들 (calls) 은 계산적으로 비쌀 수도 있으며 과도한 소비 전력을 필요로 할 수도 있다.

위에서 설명된 예시적인 기법들은 우측-눈 이미지를 생성하기 위해 좌측-눈 이미지에 대한 심도 정보에 대한 이러한 시스템 메모리 (36) 에 대한 다수의 호출들을 필요로 하지 않을 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 다른 이미지를 생성하기 위해 하나의 이미지의 심도 정보를 반드시 필요로 함이 없이 좌측-눈 및 우측-눈 이미지들을 서로 독립적으로 생성하도록, 정점 셰이더 (38) 의 소스 코드 및 뷰포트를 정의하는 명령을 수정할 수도 있다.

위에서 설명된 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 gl_Position.x 변수의 값을 수정하는 gl_Position.x+ = (z_near*w_world/(R - L)/2)*X 또는 단지 gl_Position.x+ = X 지령을 정점 셰이더 (28) 의 소스 코드에 포함시키고, gl_Position.y+= (z_near*w_world/(T - B)/2)*Y 또는 단지 gl_Position.x+ = Y*폭/높이를 포함시킬 수도 있으며, 여기서, X 는 D*cos(α) 또는 -D*cos(α) 와 동일하며, Y 는 D*sin(α) 또는 -D*sin(α) 와 동일하다. 또, 정점들의 정점 레벨 조정이 소망되면, 그래픽스 드라이버 래퍼 (26) 는 X 및 Y 변수들을 (1 - gl_Position.w/ZDP_loc) 와 추가로 곱할 수도 있으며, 여기서, gl_Position.w 는 -z_world 와 동일한 w_clip 좌표를 저장하며, ZDP_loc 는 원하는 제로 디스패리티 평면 로케이션이다. 다음은 정점 셰이더 (38) 의 소스 코드에의 이러한 명령들의 포함에 대한 이유들을 제공한다.

상기 방정식 (1) 에서 나타낸 바와 같이,

이다. Vclip 에 대한 방정식은 좌측-눈 및 우측-눈에 대한 클리핑 좌표들을 생성하도록 수정될 수도 있다. 예를 들어, 좌측-눈 및 우측-눈에 대한 클리핑 좌표들은 다음과 같을 수도 있다:

(방정식 8), 및

(방정식 9).

VTleft-eye 및 VTright-eye은 모노 뷰로부터 떨어진 좌측 눈 및 우측 눈의 가정된 거리에 기초하는 4x4 매트릭스들일 수도 있다. 모노 뷰의 좌표들은 (0, 0, 0) 일 수도 있으며, 방정식 6 에서 설명된 바와 같이, 좌측 눈은 (D*cos(α), D*sin(α), 0) 에 로케이트되는 것으로 간주될 수도 있으며, 우측 눈은 (-D*cos(α), -D*sin(α), 0) 에 로케이트되는 것으로 간주될 수도 있다. 다시 말해서, (0, 0, 0) 로케이션은 뷰어의 우측 눈 및 좌측 눈의 중간에 있는 것으로 간주될 수도 있다. 좌측 눈이 우측 눈과 좌측 눈의 중간으로부터 (D*cos(α), D*sin(α)) 에 로케이트되는 것으로 간주되고 우측 눈이 우측 눈과 좌측 눈의 중간으로부터 (-D*cos(α), -D*sin(α)) 에 로케이트되는 것으로 간주되면, D 는 뷰어의 우측 눈과 좌측 눈 사이의 거리의 절반을 나타내며, alpha, α 는, 시야각을 나타낸다.

VTleft-eye 및 VTright-eye 에 대한 매트릭스들은 다음과 같이 정의될 수도 있다:

및

VTleft-eye 및 VTright-eye 는 2개의 매트릭스들의 합계로서 다시 쓰여질 수도 있다. 예를 들어, VTleft-eye 는

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

VTright-eye 는

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

VTleft-eye 매트릭스를 Vclip_left-eye 에 대한 방정식 (방정식 7) 로 치환함으로써, Vclip_left-eye 는 다음과 동일하다: Vclip_left-eye =

(방정식 10).

VTright-eye 매트릭스를 Vclip_right-eye 에 대한 방정식 (방정식 8) 로 치환함으로써, Vclip_right-eye 는 다음과 같다: VTclip_right-eye =

(방정식 11).

(예컨대, Vclip_left-eye 및 Vclip_right-eye 에 대한) 양쪽의 방정식들 10 및 11 에서,

는

가 단위 매트릭스이고 1 로 곱한 것과 동등하기 때문에 PRJ*MVT*Vworld 로 간단히 될 수 있다.

위에서 방정식 1 에서 설명된 바와 같이, PRJ*MVT*Vworld 는 Vclip 과 동일하다. 따라서, Vclip_left-eye 및 Vclip_right-eye 방정식들 (예컨대, 각각, 방정식들 10 및 11) 은 다음과 같이 다시 쓰여질 수 있다: Vclip_left-eye = Vclip +

(방정식 12),

및

(방정식 13).

PRJ 및 MVT (각각, 방정식들 4 및 5) 에 대한 매트릭스들을 치환하고 방정식 11 의 매트릭스 곱셈을 수행함으로써, Vclip_left-eye 에 대한 방정식은 다음과 같이 간략화할 수도 있다:

Vworld 를 치환하면:

매트릭스들을 곱함으로써, Vclip_left-eye 에 대한 최종 값은 다음과 같다:

좀더 구체적으로:

Vclip_left-eye 의 상기 방정식에서, x_clip 는 단일 이미지에 대한 x-클리핑 좌표이고, y_clip 는 단일 이미지에 대한 y-클리핑 좌표이다. ((z_near/((R - L)/2)*D*cos(α)*w_world 는 좌측-눈 이미지에 대한 x_clip 에 가산되는 값이다. ((z_near/((T - B)/2)*D*sin(α)*w_world 는 좌측-눈 이미지에 대한 y_clip 에 가산되는 값이다. z_near 및 w_world 값들은 애플리케이션 (42) 에 의해 생성되는 단일 이미지에 대해 동일하다. x_clip 및 y_clip 에 가산되는 값은 시야각 (α) 및 디스플레이 (12) 의 폭과 높이 사이의 비에 기초한다.

Vclip_left-eye 에 대한 치환들과 유사한 치환들에 의해, Vclip_right-eye 방정식은 다음과 같이 간략화할 수도 있다:

(방정식 14).

좀더 구체적으로:

(방정식 15).

방정식들 14 및 15 로부터, 상수

를 계산된 x_clip 좌표에 가산하고 상수

를 계산된 y_clip 에 가산하고 모든 다른 클리핑 좌표들을 동일하게 유지함으로써, 정점 셰이더 (38) 는 좌측-눈 이미지에 대한 클리핑 좌표들을 생성할 수도 있다는 것을 알 수 있다. 이와 유사하게, x_clip 좌표로부터 상수

를 감산하고 y_clip 좌표로부터 상수

를 감산하고 모든 다른 클리핑 좌표들을 동일하게 유지함으로써, 정점 셰이더 (38) 는 우측-눈 이미지에 대한 클리핑 좌표들을 생성할 수도 있다. 적어도 이들 이유들로 인해, 그래픽스 드라이버 래퍼 (16) 는 명령 gl_Position.x+ = z_near*w_world/((R-L)/2)*X, 및 명령 gl_Position.y += z_near*w_world/((T-B)/2)*Y 를 포함할 수도 있으며, 여기서, 좌측-눈 이미지를 생성하기 위해 X 는 +D*cos(α) 과 동일하고 Y 는 +D*sin(α) 과 동일하며, 그리고 여기서, 우측-눈 이미지를 생성하기 위해 X 는 -D*cos(α) 과 동일하고 Y 는 -D*sin(α) 과 동일하다.

일부 예들에서, 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 에서 정의되는 프루스툼이다. 또한, 시야각이 45 도들로 설정되는 것이 일반적이며, 이것은 cot(fov_x) 가 1 과 동일하다는 것을 의미한다. 이것은

가 1 과 동일하다는 것을 의미한다. 따라서, 이들 예들에서,

는 단지 X 로 간단하게 된다 (예컨대,

는 1 과 동일하며, w_world 는 1 과 동일하다). 이들 예들에서, gl_Position.x+= 변수는 gl_Position.x+ = X 로 간단히 될 수도 있다.

또한, 디스플레이 (12) 의 폭은 R - L 과 동일할 수도 있으며, 디스플레이 (12) 의 높이는 T - B 과 동일할 수도 있다. 따라서, 명령 gl_Position.y += z_near*w_world/((T-B)/2)*Y 는 명령 gl_Position.y += Y*폭/높이로 간략화할 수도 있다.

따라서, 상기 방정식들은 명령 gl_Position.x += (z_near*w_world/(R - L)/2) * X, 또는 gl_Position.x+ = X 및 gl_Position.y+= (z_near*w_world/(T - B)/2) * Y, 또는 gl_Position.y+ = Y 를 정점 셰이더 (38) 에 추가하는 것이 두번 실행될 때, 시야각에 기초하여, 입체 뷰를 생성하기 위해 모노 뷰 이미지를 변위시키기에 충분할 수도 있는 이유들을 예시하는 수학적 기초를 제공하며, 여기서, 제 1 실행에서, X 는 +D*cos(α) 과 동일하고 Y 는 +D*sin(α) 과 동일하며, 그리고 여기서, 제 2 실행에서, X 는 -D*cos(α) 과 동일하고 Y 는 -D*sin(α) 과 동일하다. 더욱이, 심지어 (z_near*w_world/(R - L)/2) 이 1 과 동일하지 않는 예들에서, 그리고 (z_near*w_world/(T - B)/2) 가 폭/높이와 동일하지 않는 예들에서, z_near*w_world/(R - L)/2*D 는 뷰어가 선택할 수도 있는 상수 값일 수도 있으며, 유사하게, z_near*w_world/(T - B)/2*D 는 뷰어가 선택할 수도 있는 상수 값일 수도 있다.

다시 말해서, 본 개시물에서 설명하는 기법들에서 z_near, w_world, R, L, T, B, 및 D 의 실제 값들은 요구되지 않을 수도 있다. 대신, 뷰어는 z_near*w_world/(R - L)/2*D 에 대한 제 1 값, 및 z_near*w_world/(R - L)/2*D 에 대한 제 2 값을 선택할 수도 있다. 그래픽스 드라이버 래퍼 (26) 는 제 1 값을 cos(α) 과 곱하여, 그 결과 값을 정점 셰이더 (38) 에 제공할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 에 포함시킨, 정점 셰이더 (38) 에서의 gl_Position.x+= 지령은, 좌측-눈 이미지에 대한 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 1 실행에서 정점의 x-클리핑 좌표를 결정하기 위해 그 제공된 값을 그래픽스 드라이버 래퍼 (26) 에 의해 gl_Position.x 의 현재의 값에 가산할 수도 있다. 또한, 그래픽스 드라이버 래퍼 (26) 는 제 2 값을 sin(α) 과 곱하여, 그 결과 값을 정점 셰이더 (38) 에 제공할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 에 포함시킨, 정점 셰이더 (38) 에서의 gl_Position.y+= 지령은, 좌측-눈 이미지에 대한 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 1 실행에서 정점의 y-클리핑 좌표를 결정하기 위해 그 제공된 값을 그래픽스 드라이버 래퍼 (26) 에 의해 gl_Position.y 의 현재의 값에 가산할 수도 있다.

이와 유사하게, 그래픽스 드라이버 래퍼 (26) 는 제 1 값을 -1 및 cos(α) 과 곱하여, 그 결과 값을 정점 셰이더 (38) 에 제공할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 에 포함시킨, 정점 셰이더 (38) 에서의 gl_Position.x+= 지령은, 우측-눈 이미지에 대한 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행에서 정점의 x-클리핑 좌표를 결정하기 위해 그 제공된 값을 그래픽스 드라이버 래퍼 (26) 에 의해 gl_Position.x 의 현재의 값에 가산할 수도 있다. 또한, 그래픽스 드라이버 래퍼 (26) 는 제 2 값을 -1 및 sin(α) 과 곱하여, 그 결과 값을 정점 셰이더 (38) 에 제공할 수도 있다. 그래픽스 드라이버 래퍼 (26) 가 정점 셰이더 (38) 에 포함시킨, 정점 셰이더 (38) 에서의 gl_Position.y+= 지령은, 우측-눈 이미지에 대한 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행에서 정점의 y-클리핑 좌표를 결정하기 위해 그 제공된 값을 그래픽스 드라이버 래퍼 (26) 에 의해 gl_Position.y 의 현재의 값에 가산할 수도 있다.

일부 예들에서, 뷰어는 gl_Position.x += 지령 및 gl_Position.y += 지령의 변경을 위한 제 1 값 및 제 2 값의 값들 및/또는 VPshift 및 ZDP_loc 의 값들을 선택할 수도 있다. 이것은 뷰어로 하여금, 입체적인 효과를 원하는 대로 미세 조정가능하게 할 수도 있다. 예를 들어, 뷰어는 정점들이 변위되는 양 및 제로 디스패리티 평면의 로케이션을 정의함으로써, 입체적인 효과를 개인화가능하게 할 수도 있다.

이러한 방법으로, 본 개시물의 기법들은, 수정된 정점 셰이더가 컴파일되어 실행될 때 (예컨대, 수정된 정점 셰이더 (40) 의 오브젝트 코드의 실행), 최종 이미지들이 뷰어에게 입체 뷰를 제공할 수 있도록, 모노 뷰 용으로 설계되는 정점 셰이더 (38) 에 대해 사소한 변경을 제공할 수도 있다. 입체 뷰는 뷰어에게, 디스플레이의 2D 영역에 의해 제한되는 뷰잉 이미지와 비교할 때, 더 풍부하고 더 충만한 경험일 수도 있는 3D 경험을 제공할 수도 있다.

도 6 은 제로 디스패리티 평면의 로케이션을 예시하는 개념도이다. 예를 들어, 원래 관찰 지점의 로케이션은 (0, 0, 0) 로케이션일 수도 있다. 좌측 눈은 원래 관찰 지점으로부터 떨어진 거리 D 일 수도 있으며, 우측 눈은 원래 관찰 지점으로부터 떨어진 거리 -D 일 수도 있다. 예를 들어, 좌측 눈은 (-D*cos(α), -D*sin(α)) 에 로케이트될 수도 있으며, 우측 눈은 (D*cos(α), D*sin(α)) 에 로케이트될 수도 있다.

좌측 눈 관찰 지점 및 우측 눈 관찰 지점으로부터 연장하는 각진 라인들은 좌측 눈 및 우측 눈이 각각 보는 영역을 예시한다. 좌측 눈 관찰 지점 및 우측 눈 관찰 지점으로부터 연장하는 직선들은 디스플레이 (12) 의 배향에 대한 뷰어의 배향 (즉, 시야각) 을 예시한다. 이 예에서, 시야각은 제로이다.

도 6 에 예시된 바와 같이, ZDP 의 로케이션은 디스플레이 (12) 의 전면에, 그리고 애플리케이션 (42) 에 의해 정의되는 z_near 및 z_far 클리핑 평면들 내에 있다. ZDP 의 로케이션은 2개의 인자들에 기초할 수도 있다. 하나의 인자는 D 의 선택된 값일 수도 있다. 또 다른 인자는 좌측-눈 이미지와 우측-눈 이미지 사이의 디스패리티를 나타내는 VPshift (즉, 수평 디스패리티 값) 의 값일 수도 있다. D 및 VPshift 의 값을 선택함으로써, 뷰어는 ZDP 의 원하는 로케이션을 선택할 수도 있다. 이들 예들에서, 애플리케이션 (42) 에 의해 생성되는 이미지에서 모든 오브젝트들은 ZDP 내에 (예컨대, 디스플레이 (12) 의 표면 내에 제한되기 보다는, 디스플레이 (12) 의 전면에) 보일 수도 있다. 위에서 설명된 바와 같이, 애플리케이션 프로세서 (22) 가 D 및 VPshift 의 값을 결정하는 것이 가능할 수도 있다.

더욱이, 일부 예들에서, VPshift 는 필요하지 않을 수도 있으며, 뷰어 또는 애플리케이션 프로세서 (22) 는 ZDP 의 로케이션을 결정할 수도 있다. 이들 예들에서, 그래픽스 드라이버 래퍼 (26) 는 일부 오브젝트들이 ZDP 의 앞에 보이고 일부 오브젝트들이 ZDP 에 보이고 그리고 다른 오브젝트들이 ZDP 뒤에 보이도록, ZDP 의 로케이션에 기초하여 gl_Postion.x 및 gl_Position.y 변수들에 저장된 값들을 수정할 수도 있다.

도 7 은 본 개시물에서 설명되는 하나 이상의 예시적인 기법들에 따른, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티를 예시하는 개념도이다. 예를 들어, 도 7 은 우측-눈 이미지 (45A) 및 좌측-눈 이미지 (45B) 를 예시한다. 수평 디스패리티는 이 예에서 VPshift*2 인 것으로 표시된다. 도 7 에 나타낸 바와 같이, 수평 디스패리티는 이미지 레벨에 있다 (즉, 우측-눈 이미지 (45A) 및 좌측-눈 이미지 (45B) 에서 모든 정점들 사이의 디스패리티가 동일하다). 위에서 설명된 바와 같이, 애플리케이션 프로세서 (22) 또는 뷰어는 VPshift 의 값을 선택할 수도 있다. VPshift 의 값을 선택함으로써, 뷰어 또는 애플리케이션 프로세서 (22) 는 제로 디스패리티 평면의 로케이션을 정의할 수도 있다.

도 8 은 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 일 예를 예시하는 블록도이다. 예를 들어, 도 8 은 GPU (30) 의 구성요소들을 더욱더 자세하게 예시한다. 도 8 에 예시된 바와 같이, GPU (30) 는 지령 프로세서 (66), 셰이더 프로세서 (32), 및 고정-기능 파이프라인 (34) 을 포함한다. 지령 프로세서 (66) 는 GPU (30) 와 애플리케이션 프로세서 (22) 사이에 인터페이스로서 기능할 수도 있다. 예를 들어, 지령 프로세서 (66) 는 애플리케이션 프로세서 (22) 로부터 지령들을 수신할 수도 있으며, 지령들이 셰이더 프로세서 (32) 또는 고정-기능 파이프라인 (34) 으로 포워딩되어야 하는지 여부를 결정할 수도 있다. 또 다른 예로서, 지령 프로세서 (66) 는 애플리케이션 프로세서 (22) 로부터 시야각을 수신할 수도 있다.

일 예로서, 위에서 설명한 바와 같이, 애플리케이션 (42) 을 실행하는 애플리케이션 프로세서 (22) 는 GPU (30) 에게 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행할 것을 명령할 수도 있다. 이 예에서, 지령 프로세서 (66) 는 애플리케이션 프로세서 (22) 로부터 지령을 수신할 수도 있으며, 셰이더 프로세서 (32) 에게 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행할 것을 명령할 수도 있다. 또 다른 예로서, 일부 예들에서, 위에서 설명한 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glViewport 지령을 수정하여, 그 수정된 glViewport 지령들을 GPU (30) 에 제공할 수도 있다. 이 예에서, 지령 프로세서 (66) 는 수정된 glViewport 지령들을 수신하고, 이 지령이 고정-기능 파이프라인 (34) 의 뷰포트 변환 유닛 (54) 에 대한 것이라고 결정할 수도 있다. 지령 프로세서 (66) 는 좌측-눈 이미지 및 우측-눈 이미지에 대해 뷰포트들을 적용하기 위해 그 수정된 glViewport 지령들을 뷰포트 변환 유닛 (54) 으로 포워딩할 수도 있다.

예를 들어, 위에서 설명한 바와 같이, 애플리케이션 (42) 은 그래픽스 드라이버 래퍼 (26) 가 GPU (30) 로의 송신을 차단하는 glDraw 지령을 발할 수도 있다. glDraw 지령은 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하기 위해, 제 1 명령을 셰이더 프로세서 (42) 로 발하는 것으로 그래픽스 드라이버 래퍼 (26) 를 트리거할 수도 있다. 결국, 셰이더 프로세서 (42) 는 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하고, 그 최종 클리핑 좌표들을 그의 로컬 메모리 또는 시스템 메모리 (36) 에 저장한다.

glDraw 지령은 또한 그래픽스 드라이버 래퍼 (26) 로 하여금 지령 프로세서 (66) 에 의해 수신되는 제 1 glViewport 명령을 발하도록 한다. 좌측-눈과 우측-눈 이미지들 사이의 수평 디스패리티의 이미지 레벨 조정이 요구되지 않는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 제 1 glViewport 지령을 수정하지 않을 수도 있다. 좌측-눈과 우측-눈 이미지들 사이의 수평 디스패리티의 이미지 레벨 조정이 요구되는 예들에서, 그래픽스 드라이버 래퍼 (26) 는 시야각 및 VPshift 의 값에 기초하여 제 1 glViewport 지령을 수정할 수도 있다.

그 후, 그래픽스 드라이버 래퍼 (26) 는 지령 프로세서 (66) 에 의해 수신되는 제 1 glDraw 지령을 발행한다. 이에 응답하여, 지령 프로세서 (66) 는, 고정-기능 파이프라인 (34) 의 고정-기능 유닛들 및 셰이더 프로세서 (32) 로 하여금 그들의 각각의 기능들을 수행시켜 입체 뷰의 제 1 이미지 (예컨대, 좌측-눈 이미지) 에 대한 그래픽스 콘텐츠를 생성하게 한다. 예를 들어, 좀더 자세하게 설명되는 바와 같이, 제 1 glDraw 지령에 응답하여, 그리고, 수평 디스패리티의 이미지 레벨 조정이 소망될 때, 뷰포트 변환 유닛 (54) 은 제 1 이미지를 디스플레이의 제 1 부분에 제한하며, 프래그먼트당 동작 유닛 (62) 은 제 1 이미지의 그래픽스 콘텐츠를 프레임 버퍼 (64) 로 출력한다.

입체 뷰의 제 1 이미지가 프레임 버퍼 (64) 에 저장된 후, GPU (30) 는 입체 뷰의 제 2 이미지에 대한 그래픽스 콘텐츠를 생성하기 위해 그 단계들을 반복한다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하기 위해 제 2 명령을 셰이더 프로세서 (32) 로 발행한다. 결국, 셰이더 프로세서 (32) 는 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하고, 그 최종 클리핑 좌표들을 그의 로컬 메모리 또는 시스템 메모리 (36) 에 저장한다. 그래픽스 드라이버 래퍼 (26) 는 또한 제 2 glViewport 명령을 발하며, 그것은 지령 프로세서 (66) 에 의해 수신된다. 또, glViewport 명령은 이미지 레벨에서의 디스패리티의 조정이 소망되면 수정될 수도 있으며, 이미지 레벨에서의 디스패리티의 조정이 소망되지 않으면 수정되지 않을 수도 있다.

그 후, 그래픽스 드라이버 래퍼 (26) 는 지령 프로세서 (66) 에 의해 수신되는 제 2 glDraw 지령을 발행한다. 이에 응답하여, 지령 프로세서 (66) 는 고정-기능 파이프라인 (34) 의 고정-기능 유닛들 및 셰이더 프로세서 (32) 로 하여금 그들의 각각의 기능들을 수행하여 입체 뷰의 제 2 이미지 (예컨대, 우측-눈 이미지) 에 대한 그래픽스 콘텐츠를 생성하도록 한다. 예를 들어, 제 2 glDraw 지령에 응답하여, 그리고 수평 디스패리티의 이미지 레벨 조정이 소망될 때, 뷰포트 변환 유닛 (54) 은 제 2 이미지를 디스플레이의 제 2 부분에 제한하며, 프래그먼트당 동작 유닛 (62) 은 제 2 이미지의 그래픽스 콘텐츠를 프레임 버퍼 (64) 로 출력한다.

도 8 에 파선 박스들로 예시된 바와 같이, 셰이더 프로세서 (32) 는 수정된 정점 셰이더 (40) 및 프래그먼트 셰이더 (58) 를 포함한다. 파선 박스들은 셰이더 프로세서 (32) 가 수정된 정점 셰이더 (40) 및 프래그먼트 셰이더 (58) 를 실제로 포함하지 않을 수도 있다는 것을 나타내는 것이다. 대신, 셰이더 프로세서 (32) 는 프래그먼트 셰이더 (58) 및 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행할 수도 있다. 프래그먼트 셰이더 (58) 및 수정된 정점 셰이더 (40) 의 오브젝트는 시스템 메모리 (36) 에 저장될 수도 있다.

고정-기능 파이프라인 (34) 은 프리미티브 어셈블리 유닛 (48), 프루스툼 유닛 (50), 관점 분할 유닛 (52), 뷰포트 변환 유닛 (54), 래스터화 유닛 (56), 및 프래그먼트당 동작 유닛 (62) 과 같은 하나 이상의 고정-기능 유닛들을 포함할 수도 있다. 고정-기능 파이프라인 (34) 의 이들 고정-기능 유닛들의 각각은 특정의 그래픽스 관련된 기능들을 수행하도록 하드와이어드된 하드웨어 유닛들일 수도 있다. 고정-기능 파이프라인 (34) 의 이들 고정-기능 유닛들은 별개의 구성요소들로서 예시되지만, 본 개시물의 양태들은 이에 제한되지 않는다. 고정-기능 파이프라인 (34) 의 고정-기능 유닛들 중 하나 이상이 공통 고정-기능 유닛으로 함께 결합될 수도 있다. 또한, 도 8 에 예시된 것들보다 더 많은 고정-기능 파이프라인 (34) 의 고정-기능 유닛들이 있을 수도 있다. 고정-기능 파이프라인 (34) 의 하나 이상의 고정-기능 유닛들은 용이한 이해를 용이하게 하기 위해 별개로 예시된다.

더욱이, 고정-기능 파이프라인 (34) 의 고정-기능 유닛들의 특정의 순서정렬이 예시적인 목적들을 위해 예시되며 한정하는 것으로 간주되어서는 안된다. 예를 들어, 고정-기능 파이프라인 (34) 의 고정-기능 유닛들을 재정리하는 것이 가능할 수도 있다. 일 예로서, 프래그먼트당 동작 유닛 (62) 의 기능들 중 하나는 중첩하는 픽셀들에 의해 가려지는 픽셀들을 컬링하는 것일 수도 있다. 이 기능은 고정-기능 파이프라인 (34) 에서 더 일찍 수행되는 것이 가능할 수도 있다.

이들 고정-기능 파이프라인 (34) 의 고정-기능 유닛들은 셰이더 프로세서 (32) 에 비해, 매우 제한된 기능적 유연성을 제공할 수도 있다. 예를 들어, 셰이더 프로세서 (32) 는 수정된 정점 셰이더 (40) 및 프래그먼트 셰이더 (58) 와 같은 프로그래밍가능 셰이더 프로그램들을 실행하도록 특히 설계될 수도 있다. 이들 셰이더 프로그램들은 셰이더 프로세서 (32) 로 하여금 셰이더 프로그램들에 의해 정의되는 방법으로 기능하도록 한다. 다시 말해서, 셰이더 프로그램들은 셰이더 프로세서 (32) 의 기능을 정의할 수도 있으며, 반면 고정-기능 파이프라인 (34) 의 고정-기능 유닛들의 기능은 설정된다.

위에서 설명된 바와 같이, 그래픽스 드라이버 래퍼 (26) 는 GPU (30) 에게 수정된 정점 셰이더 (40) 의 오브젝트 코드를 2번 실행할 것을 명령할 수도 있으며, 여기서, 제 1 실행은 시야각에 기초한 입체 뷰의 이미지들 중 하나 (예컨대, 좌측-눈 이미지) 의 정점들에 대한 클리핑 좌표들의 생성을 위한 것이며 제 2 실행은 시야각에 기초한 입체 뷰의 다른 이미지 (예컨대, 우측-눈 이미지) 의 정점들에 대한 클리핑 좌표들의 생성을 위한 것이다. 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행하라는 이들 명령들의 각각에 응답하여, 지령 프로세서 (66) 는 셰이더 프로세서 (32) 에게 수정된 정점 셰이더 (40) 의 오브젝트 코드를 취출하여 그 수정된 정점 셰이더 (40) 의 오브젝트 코드를 실행할 것을 명령할 수도 있다. 위에서 설명된 바와 같이, 컴파일러 (28) 는 수정된 정점 셰이더의 소스 코드를 컴파일하고, 최종 오브젝트 코드를 수정된 정점 셰이더 (40) 의 오브젝트 코드로서 저장할 수도 있다.

도 8 에 예시된 바와 같이, 수정된 정점 셰이더 (40) 는 정점 어레이 (46) 및 텍스쳐들 (60) 을 입력들로서 수신할 수도 있다. 정점 어레이들 (46) 은 위에서 설명한 바와 같은, 애플리케이션 (42) 에 의해 생성되는 정점들에 대한 픽셀 값들 (예컨대, 정점들의 좌표들, 정점들의 칼라 값들, 및 정점들의 투명도 값들) 을 생성하기 위한 정보를 포함할 수도 있다. 예를 들어, 정점 어레이 (46) 의 정점들의 좌표들은 애플리케이션 (42) 에 의해 정의되는 바와 같은 세계 좌표들일 수도 있다. 텍스쳐들 (60) 은 좀더 실제적인 그래픽스 콘텐츠의 뷰를 제공하기 위해 그 생성된 그래픽스 상에 걸쳐서 오버레이하는 텍스쳐들에 대한 픽셀 값들일 수도 있다.

셰이더 프로세서 (32) 상에서 실행하는 수정된 정점 셰이더 (40) 는 정점들의 각각에 대한 클리핑 좌표들을 생성할 수도 있다. 예를 들어, 수정된 정점 셰이더 (40) 는 도 1 과 관련하여 위에서 설명한 바와 같이, 방정식 1 의 매트릭스 곱셈을 수행함으로써, 애플리케이션 (42) 에 의해 정의되어 정점 어레이 (46) 에 저장된 바와 같은 정점들의 세계 좌표들을 정점들의 각각에 대한 클리핑 좌표들로 변환할 수도 있다. 더욱이, 셰이더 프로세서 (32) 상에서 실행하는 수정된 정점 셰이더 (40) 는 정점 셰이더 (40) 의 오브젝트 코드의 제 1 실행에서, 좌측-눈 이미지에 대한 변위를 제공하기 위해, 그리고 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행에서, 우측-눈 이미지에 대한 변위를 제공하기 위해, 시야각에 기초하여, 정점들의 각각의 클리핑 좌표들에 대한 gl_Position.x 및 gl_Position.y 변수들을 업데이트할 수도 있다. 또한, 수정된 정점 셰이더 (40) 는 추가적인, 종래의 정점 셰이더 태스크들을 수행할 수도 있다. 예를 들어, 수정된 정점 셰이더 (40) 는 정점들에 관한 조명 기능들을 수행할 수도 있다.

수정된 정점 셰이더 (40) 가 모델 뷰 변환 (예컨대, gl_Position.x += 지령 및 gl_Position.y += 지령에 의한 변위를 포함한, 세계 뷰 좌표들 대 클리핑 좌표들의 변환) 을 수행한 후, 수정된 정점 셰이더 (40) 는 정점들에 대한 클리핑 좌표들을 고정-기능 파이프라인 (34) 의 프리미티브 어셈블리 유닛 (48) 에 제공한다. 프리미티브 어셈블리 유닛 (48) 은 정점들에 대한 클리핑 좌표들을 이용하여, 정점들을 프리미티브들로 조립할 수도 있다. 예를 들어, 프리미티브 어셈블리 유닛 (48) 은 정점들에 대한 클리핑 좌표들에 기초하여 복수의 삼각형들을 조립할 수도 있으며, 여기서, 삼각형들의 각각의 정점들은 수정된 정점 셰이더 (40) 로부터 수신된 정점들에 대응한다. 복수의 삼각형들은 프리미티브들의 일 예이다. 일반적으로, 프리미티브 어셈블리 유닛 (48) 은 수신된 정점들에 대한 클리핑 좌표들에 기초하여 그 수신된 정점들을 임의의 다각형으로 조립할 수도 있다.

프리미티브 어셈블리 유닛 (48) 은 조립된 프리미티브들을 프루스툼 유닛 (50) 으로 송신할 수도 있다. 프루스툼 유닛 (50) 은 조립된 프리미티브들이 뷰 체적 내에 있는지 여부를 결정할 수도 있다. 예를 들어, 위에서 설명한 바와 같이, OpenGL, OpenGL ES, 및 OpenGL ES 2.0 은 특정의 뷰 체적을 (fov_x) 로서 정의할 수도 있다. 그러나, 프루스툼은 예를 들어, gl프루스툼 기능을 이용하여 사용자 정의가능할 수도 있다. 프루스툼 유닛 (50) 은 프리미티브가 뷰 체적 내에 완전히 있는지, 뷰 체적 외부에 완전히 있는지, 또는 뷰 체적 내에 부분적으로 있는지 및 뷰 체적 외에 부분적으로 있는지 여부를 결정할 수도 있다. 프루스툼 유닛 (50) 은 추가적인 프로세싱으로부터, 뷰 체적 외부에 완전히 있는 프리미티브들 및 뷰 체적 외부에 있는 프리미티브들의 부분들을 컬링할 수도 있다. 프루스툼 유닛 (50) 은 추가적인 프로세싱을 위해, 뷰 체적 내에 완전히 있는 프리미티브들 및 뷰 체적 내에 있는 프리미티브들의 부분들을 유지할 수도 있다.

프루스툼 유닛 (50) 은 나머지 프리미티브들 및 프리미티브들의 부분들을 관점 분할 유닛 (52) 으로 송신할 수도 있다. 관점 분할 유닛 (52) 은 프리미티브들을 그들의 심도에 기초하여 확장하거나 또는 수축시킬 수도 있다. 예를 들어, 프리미티브들의 각각은 x, y, 및 z 좌표들에 의해 정의될 수도 있다. z 좌표는 프리미티브가 얼마나 가깝거나 또는 떨어져 있는지를 나타낼 수도 있다. 이 스테이지에서, GPU (30) 가 입체 뷰를 위한 이미지들 중 하나에 대한 그래픽스 콘텐츠를 생성하고 있다는 점에 유의해야 한다. 따라서, 프리미티브의 근접성의 컨셉은 입체 뷰가 아닌, 모노 뷰의 상황에서 이다.

예를 들어, 관점 분할 유닛 (52) 은 일부 프리미티브들을 수축시키고, 다른 프리미티브들을 확장할 수도 있다. 이것은 수축된 프리미티브들이 모노 뷰에서의 확장된 프리미티브들에 비해 멀리 떨어져 있다는 지각을 생성할 수도 있다. 위에서 설명된 바와 같이, 뷰어가 입체 뷰를 인지하는 것은 이들 모노 뷰 이미지들이 디스플레이될 때이다. 다시 말해서, 관점 분할 유닛 (52) 은 좌측-눈 이미지 및 우측-눈 이미지가 디스플레이의 2D 영역에서 디스플레이되는 3D 이미지들이 되게 할 수도 있다. 뷰어가 이들 3D 이미지들을 볼 때, 좌측-눈 이미지 및 우측-눈 이미지에서, gl_Position.x += 지령 및 gl_Position.y+= 지령의 추가에 의해 초래되는 변위는 뷰어로 하여금 3D 체적을 둘러싸는 입체적인 3D (S3D) 이미지를 인지하게 한다.

관점 분할 유닛 (52) 은 프리미티브들을 뷰포트 변환 유닛 (54) 으로 송신할 수도 있다. 뷰포트 변환 유닛 (54) 은 정의된 뷰포트에 맞추기 위해 이미지의 사이즈 및 로케이션을 수정한다. 예를 들어, 뷰포트 변환 유닛 (54) 이전에, 수정된 정점 셰이더 (40) 및 고정-기능 파이프라인 (34) 의 고정-기능 유닛들은 마치 이미지가 디스플레이 전체 상에 디스플레이되는 것처럼 그래픽스 데이터를 프로세싱한다. 뷰포트 변환 유닛 (54) 의 기능은 이미지가 정의된 뷰포트에 제한되도록, 이미지의 사이즈 및 로케이션을 수정하는 것일 수도 있다.

좌측-눈 이미지 및 우측-눈 이미지에서 정점들 사이의 디스패리티의 정점 레벨 조정이 소망되는 예들에서, 뷰포트 변환 유닛 (54) 은 좌측-눈 이미지의 뷰포트를 애플리케이션 (42) 에 의해 정의되는 단일 이미지의 뷰포트와 동일한 것으로 정의할 수도 있는 것으로 이해되어야 한다. 이와 유사하게, 이 예에서, 뷰포트 변환 유닛 (54) 은 우측-눈 이미지의 뷰포트를 애플리케이션 (42) 에 의해 정의되는 단일 이미지의 뷰포트와 동일한 것으로 정의할 수도 있다. 좌측-눈 이미지 및 우측-눈 이미지에서 정점들 사이의 디스패리티의 정점 레벨 조정이 소망되지 않는 예들에서, 뷰포트 변환 유닛 (54) 은 좌측-눈 이미지를 수정된 glViewport 지령에 의해 정의되는 바와 같은 하나의 부분에 제한하고, 우측-눈 이미지를 수정된 glViewport 지령에 의해 정의되는 바와 같은 또 다른 부분에 제한할 수도 있다.

예를 들어, 위에서 설명한 바와 같이, 좌측-눈 이미지에 대한 그래픽스 콘텐츠 (예컨대, 정점들에 대한 클리핑 좌표들) 을 생성할 수도 있는, 정점 셰이더 (40) 의 오브젝트 코드의 제 1 실행 이후, 그래픽스 드라이버 래퍼 (26) 는 좌측-눈 이미지를 디스플레이 (12) 의 하나의 부분 (예컨대, 디스플레이 (12) 의 좌측 절반) 에 제한하기 위해 좌측-눈 이미지의 뷰포트를 수정할 수도 있다. 예를 들어, 정점 셰이더 (40) 의 오브젝트 코드의 제 1 실행 이후, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 이전에 발해져 GPU (30) 로부터 차단된 glViewport (0, 0, 폭, 길이) 지령을, glViewport (-VPshift*cos(α), -VPshift*sin(α), 폭 - Vpshift*cos(α), 높이 - Vpshift*sin(α)) 으로 수정하고, 이 제 1 수정된 glViewport 지령을 GPU (40) 에 제공할 수도 있다. 지령 프로세서 (66) 는 제 1 수정된 glViewport 지령을 뷰포트 변환 유닛 (54) 에 제공할 수도 있다. 뷰포트 변환 유닛 (54) 은 그후 이 예에서, 이들 프리미티브들이 디스플레이의 하나의 절반에 제한되도록, 관점 분할 유닛 (52) 으로부터 수신되는 프리미티브들의 사이즈들을 수정할 수도 있다.

정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행 이후, 뷰포트 변환 유닛 (54) 은 우측-눈 이미지를 제외하고는, 유사한 기능들을 수행할 수도 있다. 예를 들어, 정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행은 우측-눈 이미지에 대한 그래픽스 콘텐츠 (예컨대, 정점들에 대한 클리핑 좌표들) 의 생성을 위한 것일 수도 있다. 이 정점 셰이더 (40) 의 오브젝트 코드의 제 2 실행 이후, 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 이전에 발해져 GPU (30) 로부터 차단된 glViewport (0, 0, 폭, 길이) 지령을, glViewport (VPshift*cos(α), VPshift*sin(α), 폭 + VPshift*cos(α), 높이 + VPshift*sin(α)) 으로 수정하고, 이 제 2 수정된 glViewport 지령을 GPU (30) 에 제공할 수도 있다. 지령 프로세서 (66) 는 제 2 수정된 glViewport 지령을 뷰포트 변환 유닛 (54) 으로 포워딩할 수도 있다. 이러한 방법으로, GPU (40) 는 애플리케이션 (32) 의 런-타임 동안, 그리고 심도 정보에 의존함이 없이 애플리케이션 (32) 에 의해 생성되는 모노 뷰 이미지로부터 입체 뷰를 위한 좌측-눈 및 우측-눈 이미지들을 생성하여 좌측-눈 이미지로부터 우측-눈 이미지를 생성하도록 동작가능할 수도 있으며, 반대의 경우도 마찬가지이다.

뷰포트 변환 유닛 (54) 은 제 1 수정된 glViewport 지령 및 제 2 수정된 glViewport 지령의 각각 이후 뷰포트를 수정한 후 프리미티브들을 래스터화 유닛 (56) 으로 포워딩할 수도 있다. 래스터화 유닛 (56) 은 프리미티브들을 디스플레이의 픽셀들로 변환할 수도 있다. 예를 들어, 래스터화 유닛 (56) 은 어느 디스플레이의 픽셀들이 프리미티브들의 각각에 의해 둘러 싸여지는 지를 결정할 수도 있다. 래스터화 유닛 (56) 은 또한 디스플레이들 상에서의 이들 픽셀들의 각각의 로케이션을 결정할 수도 있다.

래스터화 유닛 (56) 은 그의 그래픽스 데이터를 프래그먼트 셰이더 (58) 로 출력할 수도 있다. 픽셀 셰이더로서 종종 지칭되는, 프래그먼트 셰이더 (58) 는 셰이더 프로세서 (32) 상에서 실행하는 셰이더 프로그램일 수도 있다. 예를 들어, 프래그먼트 셰이더 (58) 에 대한 소스 코드는 시스템 메모리 (36) 에 저장될 수도 있으며, 컴파일러 (28) 는 프래그먼트 셰이더 (58) 의 소스 코드를 컴파일하여 프래그먼트 셰이더 (58) 의 오브젝트 코드를 생성할 수도 있다. 이의 대안으로, 시스템 메모리 (36) 는 프래그먼트 셰이더 (58) 에 대한 오브젝트 코드를 컴파일러 (28) 에 의해 반드시 생성됨이 없이 저장할 수도 있다.

프래그먼트 셰이더 (58) 는 디스플레이 상에서의 픽셀들의 각각에 대한 칼라 값들을 출력할 수도 있다. 예를 들어, 프래그먼트 셰이더 (58) 는 적색-녹색-청색 (RGB) 성분에 기초하여 각각의 픽셀의 칼라를 정의할 수도 있다. 프래그먼트 셰이더 (58) 는 하나의 실례로서, 적색 성분을 정의하는데 8-비트들, 녹색 성분을 정의하는데 8-비트들, 및 청색 성분을 정의하는데 8-비트들을 이용할 수도 있다. 프래그먼트 셰이더 (58) 는 칼라 값들을 프래그먼트당 동작 유닛 (62) 으로 출력할 수도 있다.

프래그먼트당 동작 유닛 (62) 은 시인불가능한 픽셀들을 컬링할 수도 있다. 예를 들어, 더 멀리 떨어져 있는 오브젝트의 픽셀은 프래그먼트당 동작 유닛 (62) 이 z-버퍼로부터 결정할 수도 있는 더 가까운 오브젝트의 픽셀에 의해 중첩될 수도 있다. 중첩하는 것은 더 멀리 떨어져 있는 오브젝트의 픽셀이 완전히 가려지게 할 수도 있다. 이 경우, 프래그먼트당 동작 유닛 (62) 은 중첩된 픽셀을 컬링할 수도 있다. 프래그먼트당 동작 유닛 (62) 은 또한 픽셀들을 함께 혼합할 수도 있다. 예를 들어, 중첩하는 픽셀은 중첩된 픽셀을 완전히 가리지 않도록, 반투명할 수도 있다. 이 경우, 프래그먼트당 동작 유닛 (62) 은 이들 픽셀들의 칼라를 함께 혼합할 수도 있다.

프래그먼트당 동작 유닛 (62) 의 출력은 디스플레이 상에서의 픽셀들에 대한 픽셀 값들 (예컨대, 칼라) 일 수도 있다. 프래그먼트당 동작 유닛 (62) 은 픽셀 값들을 임시 저장을 위해 시스템 메모리 (36) 의 프레임 버퍼 (64) 로 출력할 수도 있다. 프레임 버퍼 (64) 는 디스플레이 상의 픽셀들의 각각에 대한 픽셀 값들을 저장할 수도 있다.

프레임 버퍼 (64) 는 저장 로케이션들의 2D 어레이로서 간주될 수도 있다. 프레임 버퍼 (64) 에 의한 저장 로케이션들의 개수는 디스플레이 (12) 의 픽셀들의 개수의 2배일 수도 있다. 또한, 프레임 버퍼 (64) 내 2개의 저장 로케이션들은 디스플레이 상에서의 하나의 로케이션에 대응할 수도 있다. 예를 들어, 프레임 버퍼 (64) 는 2개의 절반들을 포함할 수도 있으며, 여기서, 각각의 절반은 디스플레이 (12) 전체에 대한 저장 로케이션들을 포함한다. 이 예에서, 프레임 버퍼 (64) 내에서 제 1 절반 내 좌상단 저장 로케이션 및 제 2 절반 내 좌상단 저장 로케이션은 디스플레이의 좌상단 픽셀에 대응할 수도 있으며, 프레임 버퍼 (64) 내에서 제 1 절반 내 좌상단 저장 로케이션의 우측에 있는 저장 로케이션 및 제 2 절반 내 좌상단 저장 로케이션의 우측에 있는 저장 로케이션은 디스플레이의 좌상단 픽셀의 우측에 있는 픽셀에 대응할 수도 있으며, 기타 등등으로 대응할 수도 있다.

제 1 glDraw 지령의 완료 후, 프레임 버퍼 (64) 의 제 1 절반 에 로케이트되는 저장 로케이션들은 좌측-눈 이미지에 대한 픽셀 값들을 저장할 수도 있다. 이와 유사하게, 제 2 glDraw 지령의 완료 후, 프레임 버퍼 (64) 의 제 2 절반에 로케이트되는 저장 로케이션들은 우측-눈 이미지에 대한 픽셀 값들을 저장할 수도 있다. 따라서, 제 1 및 제 2 glDraw 지령들의 완료 후, 프레임 버퍼 (64) 는 좌측-눈 이미지에 대한 픽셀 값들 및 우측-눈 이미지에 대한 픽셀 값들을 저장할 수도 있다.

도 9 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들을 구현할 수도 있는 그래픽 프로세싱 유닛 (GPU) 의 또 다른 예를 예시하는 블록도이다. 예를 들어, 도 9 는 OpenGL ES 2.0 그래픽스 파이프라인을 예시하며, 본 개시물에서 설명하는 기법들이 OpenGL ES 2.0 그래픽스 파이프라인에서 구현될 수도 있는 방법을 예시한다. 도 8 과 유사한 도 9 에서의 유닛들은 동일한 도면부호로 주어지며, 도 9 와 관련하여 더 이상 설명되지 않는다.

도 9 는 그래픽 드라이버 (24) 가 구현하는 API 일 수도 있는 OpenGL ES 2.0 API (66) 을 예시한다. 다시 말해서, OpenGL ES 2.0 API (66) 는 그래픽스 드라이버 (24) 의 일 예일 수도 있다. 예시된 바와 같이, OpenGL ES 2.0 은 지령들을 정점 어레이 (46), 수정된 정점 셰이더 (40), 텍스쳐들 (60), 및 프래그먼트 셰이더 (58) 로 출력한다. 수정된 정점 셰이더 (40) 는 정점 어레이 (46) 로부터 세계 좌표 정점들을 그리고 텍스쳐들 (60) 로부터 텍스쳐들을 수신하여, 시야각에 기초하여 클리핑 좌표들을 생성한다. 프리미티브 어셈블리 유닛 (48), 래스터화 유닛 (56), 프래그먼트 셰이더 (58), 프래그먼트당 동작 유닛 (62), 및 프레임 버퍼 (64) 는 도 7 과 관련하여 설명된 기능들과 유사한 기능들을 수행할 수도 있다.

도 10a 내지 도 10c 는 본 개시물에서 설명되는 하나 이상의 기법들에 따른, 예시적인 결과들을 을 예시하는 개념도들이다. 도 10a 내지 도 10c 의 예에서, 애플리케이션 (42) 에 의해 생성되는 단일 이미지의 해상도는 디스플레이 (12) 의 해상도의 절반일 수도 있다. 따라서, 도 10a 내지 도 10c 에서, 좌측-눈 이미지는 디스플레이 (12) 의 절반 상에 나타나며, 우측-눈 이미지는 디스플레이 (12) 의 다른 절반 상에 나타난다. 예를 들어, 도 10a 는 좌측-눈 이미지 (68A) 및 우측-눈 이미지 (68B) 를 예시하며, 도 10b 는 좌측-눈 이미지 (70A) 및 우측-눈 이미지 (70B) 를 예시하고, 도 10c 는 좌측-눈 이미지 (72A) 및 우측-눈 이미지 (72B) 를 예시한다. 도 10a 내지 도 10c 에서, 뷰어의 좌측 눈은 오직 좌측-눈 이미지를 볼 수도 있으며 우측-눈 이미지를 보지 않을 수도 있으며, 뷰어의 우측 눈은 오직 우측-눈 이미지를 볼 수도 있으며 좌측-눈 이미지를 보지 않을 수도 있다.

도 10a 는 시야각이 제로일 때 (즉, 풍경 모드에서) 예시적인 결과들을 예시한다. 도 10b 는 뷰어가 디바이스 (10) 를 도 10a 의 예에 대해 90°인 시야각으로 수직으로 회전하는 예를 예시한다. 도 10b 의 예에서, 뷰어가 디바이스 (10) 의 배향을 90° 만큼, 그리고 렌더링된 이미지 콘텐츠를 90° 만큼 변경하였더라도, 좌측-눈 이미지 (70A) 와 우측-눈 이미지 (70B) 사이의 디스패리티는 여전히 수평 방향이다. 따라서, 도 9c 에 예시된 바와 같은 임의의 주어진 시야각에 대해, 좌측-눈 이미지 (72A) 와 우측-눈 이미지 (72B) 사이의 디스패리티는 여전히 수평 방향이다.

도 11 은 도 5 의 예시적인 디바이스를 좀더 상세히 예시하는 블록도이다. 예를 들어, 도 11 은 도 5 의 디바이스 (10) 을 좀더 상세히 예시한다. 예를 들어, 위에서 나타낸 바와 같이, 디바이스 (10) 의 예들은, 모바일 무선 전화기들, PDAs, 비디오 디스플레이들을 포함하는 비디오 게이밍 콘솔들, 모바일 화상 회의 유닛들, 랩탑 컴퓨터들, 데스크탑 컴퓨터들, 텔레비전 셋-탑 박스들 등을 포함하지만 이에 한정되지 않는다.

도 11 에 예시된 바와 같이, 디바이스 (10) 는 디스플레이 (12), 애플리케이션 프로세서 (22), GPU (30), 프레임 버퍼 (64) 를 포함하는 시스템 메모리 (36), 카메라 프로세서 (44), 송수신기 모듈 (74), 사용자 인터페이스 (76), 디스플레이 프로세서 (78), 및 카메라 (80) 를 포함할 수도 있다. 디스플레이 (12), 애플리케이션 프로세서 (22), GPU (30), 시스템 메모리 (36), 하나 이상의 센서들 (42), 및 카메라 프로세서 (44) 는 도 1 및 도 5 에 예시된 것들과 실질적으로 유사하거나 또는 동일할 수도 있다. 간결성의 목적들을 위해, 단지 도 11 에 도시되지만 도 1 및 도 5 에는 도시되지 않은 구성요소들만이 자세하게 설명된다.

디바이스 (10) 는, 도 11 에 예시된 바와 같이, 명료성의 목적들을 위해 도 11 에 미도시된 추가적인 모듈들 또는 유닛들을 포함할 수도 있다. 예를 들어, 디바이스 (10) 는 디바이스 (10) 가 모바일 무선 전화기 또는 스피커이거나 디바이스 (10) 가 미디어 플레이어인 예들에서 회선 통신들 (telephonic communications) 을 실시하기 위해 도 11 에 어느 것도 도시되지 않은 스피커 및 마이크로폰을 포함할 수도 있다. 더욱이, 디바이스 (10) 에 나타낸 여러 모듈들 및 유닛들은 디바이스 (10) 의 모든 예에서 필요하지 않을 수도 있다. 예를 들어, 사용자 인터페이스 (76) 및 디스플레이 (12) 는 디바이스 (10) 가 데스크탑 컴퓨터, 또는 외부 사용자 인터페이스 또는 디스플레이와 인터페이스하기 위해 탑재되는 다른 디바이스인 예들에서 디바이스 (10) 의 외부에 있을 수도 있다.

카메라 (80) 는 비디오 또는 이미지들을 캡쳐하도록 구성된 전방 광학 카메라일 수도 있다. 카메라 (80) 는 그의 캡쳐된 비디오 또는 이미지들을 카메라 프로세서 (44) 로 출력할 수도 있다. 카메라 프로세서 (44) 는 위에서 설명한 바와 같은 캡쳐된 비디오 또는 이미지들에 기초하여 뷰어 배향을 결정할 수도 있다.

사용자 인터페이스 (76) 의 예들은 트랙볼, 마우스, 키보드, 및 다른 유형들의 입력 디바이스들을 포함하지만 이에 한정되지 않는다. 사용자 인터페이스 (76) 는 또한 터치 스크린일 수도 있으며, 디스플레이 (12) 의 일부분으로서 포함될 수도 있다. 송수신기 모듈 (74) 은 디바이스 (10) 와 또 다른 디바이스 또는 네트워크 사이에 무선 또는 유선 통신을 가능하게 하기 위해 회로를 포함할 수도 있다. 송수신기 모듈 (74) 은 하나 이상의 변조기들, 복조기들, 증폭기들, 안테나들 및 유선 또는 무선 통신을 위한 이러한 다른 회로를 포함할 수도 있다.

디스플레이 프로세서 (78) 는 디스플레이 (12) 로 하여금 입체 뷰를 디스플레이하도록 구성될 수도 있다. 디스플레이 프로세서 (78) 가 디스플레이 (12) 로 하여금 입체 뷰를 디스플레이하게 하기 위해 이용할 수도 있는 여러 기법들이 있을 수도 있으며, 본 개시물의 양태들은 이들 기법들 중 임의의 기법을 이용할 수도 있다. 예를 들어, 디스플레이 프로세서 (78) 는 프레임 버퍼 (64) 의 하나의 절반으로부터 좌측-눈 이미지를 취출하고, 프레임 버퍼 (64) 의 다른 절반으로부터 우측-눈 이미지를 취출하고, 그리고 2개의 이미지들을 함께 인터리브하여, 입체 뷰를 제공할 수도 있다.

또 다른 예로서, 디스플레이 프로세서 (78) 는 디스플레이 (12) 의 리프레시 레이트를 제어할 수도 있다. 이 예에서, 각각의 리프레시 사이클 동안, 디스플레이 프로세서 (78) 는 좌측-눈 이미지와 우측-눈 이미지 사이에 순환할 수도 있다. 예를 들어, 디스플레이 프로세서 (78) 는 프레임 버퍼 (64) 의 하나의 절반으로부터 좌측-눈 이미지를 취출하고, 좌측-눈 이미지를 디스플레이 (12) 전체로 확장하고, 하나의 리프레시 사이클 동안 디스플레이 (12) 상에 좌측-눈 이미지를 디스플레이할 수도 있다. 그 후, 다음 리프레시 사이클 동안, 디스플레이 프로세서 (78) 는 프레임 버퍼 (64) 의 다른 절반에 저장된 우측-눈 이미지를 제외하고는, 실질적으로 유사한 기능들을 수행할 수도 있다. 다시 말해서, 디스플레이 (12) 는 좌측-눈 이미지를, 그후 우측-눈 이미지를, 그후 좌측-눈 이미지를, 기타 등등으로 디스플레이할 수도 있다.

뷰어는 디스플레이 프로세서 (78) 의 리프레시 레이트와 동기화되는 특수 안경을 착용하고 있을 수도 있다. 예를 들어, 디스플레이 (12) 가 좌측-눈 이미지를 디스플레이하고 있는 동안, 특수 안경은 단지 뷰어의 좌측 눈만이 좌측-눈 이미지를 캡쳐하도록 우측 렌즈 셔터를 닫을 수도 있다. 그 후, 디스플레이 (12) 가 우측-눈 이미지를 디스플레이하고 있는 동안, 특수 안경은 단지 뷰어의 우측 눈만이 우측-눈 이미지를 캡쳐하도록, 좌측 렌즈 셔터를 닫는, 등등을 행할 수도 있다. 리프레시 레이트가 충분히 빠르면, 뷰어는 이미지가 디스플레이 (12) 로부터 나오거나 또는 디스플레이 내에 들어가고 3D 체적을 둘러싸는 입체 뷰를 인지한다.

일부 예들에서, 일부 종래의 디스플레이 프로세서들은 디스플레이 (12) 로 하여금 입체 뷰를 디스플레이하도록 구성되지 않을 수도 있다. 이들 예들에서, 뷰어는 디바이스 (10) 를, 디스플레이 (12) 로 하여금 입체 뷰를 제시하도록 구성된, 디스플레이 프로세서 (78) 와 같은, 디스플레이 프로세서를 포함하는 디스플레이에 커플링할 수도 있다. 예를 들어, 뷰어는 디바이스 (10) 를 송수신기 모듈 (74) 을 통해서 입체 뷰 이용가능 텔레비전 (stereoscopic view enabled television) 에 커플링할 수도 있다. 예를 들어, 뷰어는 송수신기 모듈 (74) 을 HDMI (고-정세 멀티미디어 인터페이스) 와이어를 통해서 텔레비전에 커플링할 수도 있다. 이 예에서, 애플리케이션 프로세서 (22) 또는 GPU (30) 는 송수신기 모듈 (74) 에게 프레임 버퍼 (64) 에 저장된 픽셀 값들을 텔레비전의 디스플레이 프로세서로 송신할 것을 명령할 수도 있다. 이 텔레비전의 디스플레이 프로세서는 그후 텔레비전으로 하여금 좌측-눈 및 우측-눈 이미지들을 디스플레이하여 입체 뷰를 형성하게 할 수도 있다.

도 12 는 본 개시물에서 설명되는 하나 이상의 예시적인 기법들에 따른, 예시적인 동작을 예시하는 플로우차트이다. 예시의 목적을 위해, 도 3 을 참조한다.

프로세서 (22) 는 애플리케이션 (42) 을 실행하여 모노 뷰에 대한 이미지를 생성할 수도 있다 (82). 프로세서 (22) 는 애플리케이션 (42) 의 런-타임 동안 도 12 의 다른 블록들을 실행할 수도 있다. 예를 들어, 프로세서 (22) 는 디스플레이 (12) 에 대한 시야각을 결정할 수도 있다. 일부 예들에서, 프로세서 (22) 는 디스플레이 (12) 에 대한 시야각을 입체 뷰의 생성 당 한번 결정할 수도 있다. 시야각을 결정하기 위해, 프로세서 (22) 는 예컨대 카메라 프로세서 (44) 에 의한 뷰어 배향, 및 예컨대 하나 이상의 센서들 (42) 에 의한 디스플레이 배향 중 적어도 하나를 결정할 수도 있다.

프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더 (38) 에 대한 명령들을 수신할 수도 있다 (84). 정점 셰이더 (38) 는 애플리케이션 (42) 의 실행에 의해 생성되는 모노 뷰의 이미지에 관해 동작하도록 구성될 수도 있다.

프로세서 (22) 는, 수정된 정점 셰이더 (예컨대, 명령들의 포함 이후 컴파일러 (28) 가 정점 셰이더 (38) 를 컴파일한 후 수정된 정점 셰이더 (40)) 를 생성하기 위해, 시야각에 기초하여 하나 이상의 명령들을 포함하도록, 그래픽스 드라이버 래퍼 (26) 를 통해서, 정점 셰이더의 명령들을 수정할 수도 있다 (86). 이 예에서, 수정된 정점 셰이더 (40) 는, GPU (30) 의 셰이더 프로세서 (32) 상에서 실행될 때, 입체 뷰의 정점들에 대한 정점 좌표들을 생성할 수도 있다.

예를 들어, 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 시야각에 기초하여 애플리케이션 (42) 에 의해 생성되는 모노 뷰의 이미지의 정점의 제 1 클리핑 좌표 (예컨대, x_clip) 를 수정하는 제 1 명령을 정점 셰이더 (38) 에 추가할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 gl_Position.x += X 지령을 추가할 수도 있으며, 여기서, X 는 수정된 정점 셰이더 (40) 의 제 1 실행에서 D*cos(α) 과 동일하며 수정된 정점 셰이더 (40) 의 제 2 실행에서 -D*cos(α) 과 동일하다. 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 시야각에 기초하여 애플리케이션 (42) 에 의해 생성되는 모노 뷰의 이미지의 정점의 제 2 클리핑 좌표 (예컨대, y_clip) 를 수정하는 제 2 명령을 정점 셰이더 (38) 에 추가할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 gl_Position.y += Y*폭/높이를 추가할 수도 있으며, 여기서, 폭 및 높이는 디스플레이 (12) 의 폭 및 높이이고, Y 는 수정된 정점 셰이더 (40) 의 제 1 실행에서 D*sin(α) 와 동일하며, 수정된 정점 셰이더 (40) 의 제 2 실행에서 -D*sin(α) 와 동일하다.

일부 예들에서, 옵션으로서, 그래픽스 드라이버 래퍼 (26) 가 추가하는 제 1 및 제 2 명령들은 또한 제로 디스패리티 평면의 로케이션에 기초할 수도 있다. 예를 들어, 그래픽스 드라이버 래퍼 (26) 는 gl_Position.x += X*(1 - gl_Position.w/ZDP_loc) 를 추가할 수도 있으며, gl_Position.y += Y*폭/높이*(1 - gl_Position.w/ZDP_loc) 를 추가할 수도 있다. gl_Position.w 변수는 -z_world 와 동일한 w_clip 좌표를 저장하며, 여기서, z_world 는 애플리케이션 (42) 에 의해 정의되는 정점의 z-좌표이다. ZDP_loc 는 디스플레이 (12) 에 대한 제로 디스패리티 평면의 로케이션을 나타낸다.

옵션으로서, 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, 애플리케이션 (42) 에 의해 발행되는 뷰포트 지령 (예컨대, glViewport) 을 수정할 수도 있다 (90). 이 뷰포트 지령의 변경은 옵션적이며 따라서 파선들로 예시된다. 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, glViewport 지령을 수정하여, 입체 뷰의 제 1 이미지와 제 2 이미지 사이의 수평 디스패리티 (예컨대, 좌측-눈 이미지와 우측-눈 이미지 사이의 수평 디스패리티) 를 조정할 수도 있다. 수평 디스패리티를 조정함으로써, 그래픽스 드라이버 래퍼 (26) 는 그 수정된 glViewport 지령을 이용하여, 제로 디스패리티 평면의 로케이션을 조정할 수도 있다.

프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, GPU (30) 에게 수정된 정점 셰이더 (40) 를 실행할 것을 명령할 수도 있다 (92). 예를 들어, 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, GPU (30) 에게 시야각에 기초하여 입체 뷰의 제 1 이미지 (예컨대, 좌측-눈 이미지) 를 생성하기 위해 셰이더 프로세서 (32) 상에서의 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 1 인스턴스를 실행할 것을 명령할 수도 있다. 프로세서 (22) 는, 그래픽스 드라이버 래퍼 (26) 를 통해서, GPU (30) 에게 시야각에 기초하여 입체 뷰의 제 2 이미지 (예컨대, 우측-눈 이미지) 를 생성하기 위해 셰이더 프로세서 (32) 상에서의 수정된 정점 셰이더 (40) 의 오브젝트 코드의 제 2 인스턴스를 실행할 것을 명령할 수도 있다.

다음 의사-코드는 그래픽스 드라이버 래퍼 (26) 및 애플리케이션 (42) 의 기능의 일 예를 제공한다. 이 의사-코드는 이해를 돕도록 의도되며 제한하는 것으로 간주되지 않아야 한다.

1. 그래픽 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 발행되는 glShaderSource 지령을 인터셉트하여 정점 셰이더 (28) 의 소스 코드를 인터셉트한다.

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

3. 그래픽스 드라이버 래퍼 (26) 는 "gl_Position.x+ = X" 및 "gl_Position.y+= Y*폭/높이" 지령을 정점 셰이더 (38) 의 소스 코드에 삽입한다.

3a. 그래픽스 드라이버 래퍼 (26) 는 "gl_Position.x+ = X*(1-gl_Position.w/ZDP_loc" 및 "gl_Position.y+= Y*폭/높이*(1-gl_Position.w/ZDP_loc" 을 삽입한다.

4. 애플리케이션 (42) 은 컴파일러 (28) 로 하여금 정점 셰이더 (38) 의 수정된 소스 코드 명령들을 컴파일하게 하는 glCompileShader 지령을 실행하여, 수정된 정점 셰이더 (40) 의 오브젝트 코드를 생성한다.

5. 애플리케이션 (42) 은 다음 지령들을 실행하여, 수정된 정점 셰이더 (40) 의 오브젝트 코드에 링크한다:

programObject = glCreateProgram();

glAttachShader(programObject, vertexShader);

glAttachShader(programObject, fragmentShader);

glLinkProgram(programObject)

6. 그래픽스 드라이버 래퍼 (26) 는 애플리케이션 (42) 에 의해 호출될 때 glDraw 지령들 (예컨대, glDrawArrays 및 glDrawElements) 을 인터셉트하고, 지령들이 GPU (30) 로 전송되는 것을 차단한다.

7. 그래픽스 드라이버 래퍼 (26) 는 다음 지령들을 발행한다:

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

일부 예들에서, 위에서 설명한 바와 같이, 좌측-눈 이미지에 대한 뷰포트를 생성하기 위해 glViewport 지령을 수정한다.

p1 = glGetUniformLocation(program, X); 균일한 X 에 대한 포인터를 획득하기 위함

p2 = glGetUniformLocation(program, Y); 균일한 Y 에 대한 포인터를 획득하기 위함

glUniform1f(p1,D*cos(α)); //X 의 값을 D*cos(α) 과 동일하게 설정하기 위함.

glUniform1f(p2,D*sin(α)); //Y 의 값을 D*sin(α) 과 동일하게 설정하기 위함

glDraw 지령 //GPU (30) 로 하여금, 좌측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하도록 하기 위함

8. 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하기 위해, 7 다음에 뒤따르는 단계들을, 다음 변경들로 반복한다:

위에서 설명한 바와 같이 우측-눈 이미지에 대한 뷰포트를 생성하기 위해 glViewport 지령을 수정한다.

glUniform1f(p1, -D*cos(α)) //X 의 값을 -D*cos(α) 과 동일하게 설정하기 위함.

glUniform1f(p2,-D*sin(α)) //Y 의 값을 -D*sin(α) 과 동일하게 설정하기 위함.

glDraw 지령 //GPU (30) 로 하여금, 우측-눈 이미지에 대한 그래픽스 콘텐츠를 생성하도록 하기 위함.

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

코드는 하나 이상의 디지털 신호 프로세서들 (DSPs), 범용 마이크로프로세서들, 주문형 집적회로들 (ASICs), 필드 프로그래밍가능 로직 어레이들 (FPGAs), 또는 다른 등가의 집적 또는 이산 로직 회로와 같은, 하나 이상의 프로세서들에 의해 실행될 수도 있다. 따라서, 용어 "프로세서" 는, 본원에서 사용될 때 전술한 구조 중 임의의 구조 또는 본원에서 설명하는 기법들의 구현에 적합한 임의의 다른 구조를 지칭할 수도 있다. 또한, 이 기법들은 하나 이상의 회로들 또는 로직 엘리먼트들로 전적으로 구현될 수 있다.

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

여러 예들이 설명되었다. 이들 및 다른 예들은 다음 청구항들의 범위 이내이다.

Claims (37)

1. 그래픽스 프로세싱을 위한 방법으로서,
   뷰어 배향 또는 디스플레이 배향 중 적어도 하나를 결정하는 단계;
   프로세서에 의해, 결정된 상기 뷰어 배향 또는 결정된 상기 디스플레이 배향 중 적어도 하나에 기초하여 디스플레이에 대한 시야각을 결정하는 단계;
   상기 프로세서에 의해, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하는 단계;
   상기 프로세서에 의해, 상기 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 상기 정점 셰이더에 대한 명령들을 수정하는 단계로서, 입체 뷰의 정점들에 대한 정점 좌표들을 생성하기 위해, 상기 수정된 정점 셰이더의 제 1 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 프리미티브들의 정점들을 상기 시야각에 기초하여 일 방향으로 변위시키고, 상기 수정된 정점 셰이더의 제 2 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 상기 프리미티브들의 정점들을 상기 시야각에 기초하여 다른 방향으로 변위시키는, 상기 명령들을 수정하는 단계;
   상기 프로세서에 의해, 그래픽 프로세싱 유닛 (GPU) 에게 상기 입체 뷰의 제 1 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 1 인스턴스를 실행할 것을 명령하는 단계; 및
   상기 프로세서에 의해, 상기 GPU 에게 상기 입체 뷰의 제 2 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 2 인스턴스를 실행할 것을 명령하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
2. 제 1 항에 있어서,
   상기 명령들을 수정하는 단계는,
   상기 시야각에 기초하여 상기 모노 뷰의 상기 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하는 단계; 및
   상기 시야각에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
3. 제 1 항에 있어서,
   상기 명령들을 수정하는 단계는,
   상기 시야각 및 제로 디스패리티 평면의 로케이션에 기초하여 상기 모노 뷰의 상기 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하는 단계; 및
   상기 시야각 및 상기 제로 디스패리티 평면의 로케이션에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
4. 제 1 항에 있어서,
   상기 모노 뷰의 상기 이미지의 뷰포트를 정의하는 명령을 상기 입체 뷰의 제 1 이미지에 대한 뷰포트를 정의하는 명령으로, 그리고, 상기 입체 뷰의 제 2 이미지에 대한 뷰포트를 정의하는 명령으로 수정하는 단계를 더 포함하는, 그래픽스 프로세싱을 위한 방법.
5. 제 4 항에 있어서,
   상기 모노 뷰의 상기 이미지의 상기 뷰포트를 정의하는 명령을 수정하는 단계는, 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
6. 제 5 항에 있어서,
   상기 수평 디스패리티를 조정하는 단계는, 제로 디스패리티 평면의 로케이션을 조정하기 위해 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
7. 제 1 항에 있어서,
   상기 프로세서에 의해, 상기 모노 뷰의 상기 이미지를 생성하기 위해 애플리케이션을 실행하는 단계를 더 포함하며,
   상기 정점 셰이더에 대한 명령들을 수정하는 단계는 상기 애플리케이션의 실행 동안 상기 정점 셰이더에 대한 명령들을 수정하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
8. 제 1 항에 있어서,
   상기 시야각을 결정하는 단계는 상기 시야각을 상기 입체 뷰의 생성 당 한번 결정하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
9. 제 1 항에 있어서,
   상기 명령들을 수신하는 단계는 상기 프로세서 상에서 실행중인 그래픽스 드라이버 래퍼에 의해, 상기 정점 셰이더에 대한 명령들을 수신하는 단계를 포함하며,
   상기 명령들을 수정하는 단계는 상기 프로세서 상에서의 그래픽스 드라이버 래퍼 실행에 의해, 상기 정점 셰이더의 명령들을 수정하는 단계를 포함하는, 그래픽스 프로세싱을 위한 방법.
10. 그래픽 프로세싱 유닛 (GPU); 및
    프로세서를 포함하며,
    상기 프로세서는,
    뷰어 배향 또는 디스플레이 배향 중 적어도 하나를 결정하고;
    결정된 상기 뷰어 배향 또는 결정된 상기 디스플레이 배향 중 적어도 하나에 기초하여 디스플레이에 대한 시야각을 결정하고;
    상기 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록, 모노 뷰의 이미지 상에서 동작하도록 구성된 정점 셰이더에 대한 명령들을 수정하는 것으로서, 입체 뷰의 정점들에 대한 정점 좌표들을 생성하기 위해, 상기 수정된 정점 셰이더의 제 1 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 프리미티브들의 정점들을 상기 시야각에 기초하여 일 방향으로 변위시키고, 상기 수정된 정점 셰이더의 제 2 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 상기 프리미티브들의 정점들을 상기 시야각에 기초하여 다른 방향으로 변위시키는, 상기 명령들을 수정하고;
    상기 GPU 에게 상기 입체 뷰의 제 1 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 1 인스턴스를 실행할 것을 명령하며; 그리고
    상기 GPU 에게 상기 입체 뷰의 제 2 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 2 인스턴스를 실행할 것을 명령하도록
    구성되는, 장치.
11. 제 10 항에 있어서,
    상기 명령들을 수정하기 위해, 상기 프로세서는,
    상기 시야각에 기초하여 모노 뷰의 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하고;
    상기 시야각에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하도록
    구성되는, 장치.
12. 제 10 항에 있어서,
    상기 명령들을 수정하기 위해, 상기 프로세서는,
    상기 시야각 및 제로 디스패리티 평면의 로케이션에 기초하여 모노 뷰의 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하고; 그리고
    상기 시야각 및 상기 제로 디스패리티 평면의 로케이션에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하도록
    구성되는, 장치.
13. 제 10 항에 있어서,
    상기 프로세서는,
    모노 뷰의 이미지의 뷰포트를 정의하는 명령을 상기 입체 뷰의 제 1 이미지에 대한 뷰포트를 정의하는 명령으로, 그리고 상기 입체 뷰의 제 2 이미지에 대한 뷰포트를 정의하는 명령으로 수정하도록 구성되는, 장치.
14. 제 13 항에 있어서,
    상기 모노 뷰의 상기 이미지의 상기 뷰포트를 정의하는 명령을 수정하기 위해, 상기 프로세서는 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하도록 구성되는, 장치.
15. 제 14 항에 있어서,
    상기 수평 디스패리티를 조정하기 위해, 상기 프로세서는,
    제로 디스패리티 평면의 로케이션을 조정하기 위해 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하도록
    구성되는, 장치.
16. 제 10 항에 있어서,
    상기 프로세서는 애플리케이션을 실행하여 모노 뷰의 이미지를 생성하고, 그리고 상기 애플리케이션의 실행 동안 상기 정점 셰이더의 명령을 수정하도록 구성되는, 장치.
17. 제 10 항에 있어서,
    상기 시야각을 결정하기 위해, 상기 프로세서는 상기 시야각을 상기 입체 뷰의 생성 당 한번 결정하도록 구성되는, 장치.
18. 제 10 항에 있어서,
    상기 프로세서는 그래픽스 드라이버 래퍼를 실행하도록 구성되며, 상기 프로세서는 상기 그래픽스 드라이버 래퍼를 통해서 상기 정점 셰이더의 명령들을 수정하도록 구성되는, 장치.
19. 제 10 항에 있어서,
    상기 장치는 모바일 무선 전화기, 개인 휴대정보 단말기, 비디오 게이밍 콘솔, 모바일 화상 회의 유닛, 랩탑 컴퓨터, 데스크탑 컴퓨터, 디지털 미디어 플레이어, 및 태블릿 컴퓨팅 디바이스 중 하나를 포함하는, 장치.
20. 제 10 항에 있어서,
    가속도계, 자이로스코프, 및 카메라 중 적어도 하나를 더 포함하며,
    상기 프로세서는 상기 가속도계, 상기 자이로스코프, 및 상기 카메라 중 하나 이상으로부터의 출력들에 기초하여 상기 디스플레이에 대한 상기 시야각을 결정하도록 구성되는, 장치.
21. 뷰어 배향 또는 디스플레이 배향 중 적어도 하나를 결정하고, 결정된 상기 뷰어 배향 또는 결정된 상기 디스플레이 배향 중 적어도 하나에 기초하여 디스플레이에 대한 시야각을 결정하고, 모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하고, 상기 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 상기 정점 셰이더에 대한 명령들을 수정하는 것으로서, 입체 뷰의 정점들에 대한 정점 좌표들을 생성하기 위해, 상기 수정된 정점 셰이더의 제 1 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 프리미티브들의 정점들을 상기 시야각에 기초하여 일 방향으로 변위시키고, 상기 수정된 정점 셰이더의 제 2 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 상기 프리미티브들의 정점들을 상기 시야각에 기초하여 다른 방향으로 변위시키는, 상기 명령들을 수정하고, 그래픽 프로세싱 유닛 (GPU) 에게 상기 입체 뷰의 제 1 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 1 인스턴스를 실행할 것을 명령하며, 그리고 상기 GPU 에게 상기 입체 뷰의 제 2 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 2 인스턴스를 실행할 것을 명령하도록 구성되는, 프로세서.
22. 그래픽 프로세싱 유닛 (GPU);
    뷰어 배향 또는 디스플레이 배향 중 적어도 하나를 결정하는 수단;
    결정된 상기 뷰어 배향 또는 결정된 상기 디스플레이 배향 중 적어도 하나에 기초하여 디스플레이에 대한 시야각을 결정하는 수단;
    모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하는 수단;
    상기 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 상기 정점 셰이더에 대한 명령들을 수정하는 수단으로서, 입체 뷰의 정점들에 대한 정점 좌표들을 생성하기 위해, 상기 수정된 정점 셰이더의 제 1 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 프리미티브들의 정점들을 상기 시야각에 기초하여 일 방향으로 변위시키고, 상기 수정된 정점 셰이더의 제 2 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 상기 프리미티브들의 정점들을 상기 시야각에 기초하여 다른 방향으로 변위시키는, 상기 명령들을 수정하는 수단;
    그래픽 프로세싱 유닛 (GPU) 에게 상기 입체 뷰의 제 1 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 1 인스턴스를 실행할 것을 명령하는 수단; 및
    상기 GPU 에게 상기 입체 뷰의 제 2 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 2 인스턴스를 실행할 것을 명령하는 수단을 포함하는, 장치.
23. 제 22 항에 있어서,
    프로세서를 더 포함하며,
    상기 프로세서는 상기 결정하는 수단, 상기 수신하는 수단, 상기 수정하는 수단, 및 상기 명령하는 수단을 포함하는, 장치.
24. 제 22 항에 있어서,
    상기 수정하는 수단은,
    상기 시야각에 기초하여 상기 모노 뷰의 상기 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하는 제 1 수단; 및
    상기 시야각에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하는 제 2 수단을 포함하는, 장치.
25. 제 22 항에 있어서,
    상기 수정하는 수단은,
    상기 시야각 및 제로 디스패리티 평면의 로케이션에 기초하여 상기 모노 뷰의 상기 이미지의 정점의 제 1 클리핑 좌표를 수정하는 제 1 명령을 상기 정점 셰이더에 추가하는 제 1 수단; 및
    상기 시야각 및 상기 제로 디스패리티 평면의 로케이션에 기초하여 상기 모노 뷰의 상기 이미지의 상기 정점의 제 2 클리핑 좌표를 수정하는 제 2 명령을 상기 정점 셰이더에 추가하는 제 2 수단을 포함하는, 장치.
26. 제 22 항에 있어서,
    상기 모노 뷰의 상기 이미지의 뷰포트를 정의하는 명령을 상기 입체 뷰의 제 1 이미지에 대한 뷰포트를 정의하는 명령으로, 그리고, 상기 입체 뷰의 제 2 이미지에 대한 뷰포트를 정의하는 명령으로 수정하는 수단을 더 포함하는, 장치.
27. 제 26 항에 있어서,
    상기 모노 뷰의 상기 이미지의 상기 뷰포트를 정의하는 명령을 수정하는 수단은, 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하는 수단을 포함하는, 장치.
28. 제 27 항에 있어서,
    상기 수평 디스패리티를 조정하는 수단은, 제로 디스패리티 평면의 로케이션을 조정하기 위해 상기 입체 뷰의 제 1 이미지와 상기 입체 뷰의 제 2 이미지 사이의 수평 디스패리티를 조정하는 수단을 포함하는, 장치.
29. 제 22 항에 있어서,
    상기 모노 뷰의 상기 이미지를 생성하기 위해 애플리케이션을 실행하는 수단을 더 포함하며,
    상기 정점 셰이더에 대한 명령들을 수정하는 수단은 상기 애플리케이션의 실행 동안 상기 정점 셰이더에 대한 명령들을 수정하는 수단을 포함하는, 장치.
30. 제 22 항에 있어서,
    상기 시야각을 결정하는 수단은 상기 시야각을 상기 입체 뷰의 생성 당 한번 결정하는 수단을 포함하는, 장치.
31. 명령들이 저장되는 비-일시적 컴퓨터-판독가능 저장 매체로서,
    상기 명령들은, 실행될 때, 하나 이상의 프로세서들로 하여금,
    뷰어 배향 또는 디스플레이 배향 중 적어도 하나를 결정하게 하고;
    결정된 상기 뷰어 배향 또는 결정된 상기 디스플레이 배향 중 적어도 하나에 기초하여 디스플레이에 대한 시야각을 결정하게 하고;
    모노 뷰의 이미지 상에서 동작하도록 구성되는 정점 셰이더에 대한 명령들을 수신하게 하고;
    상기 시야각에 기초하여 수정된 정점 셰이더를 생성하기 위한 하나 이상의 명령들을 포함하도록 상기 정점 셰이더에 대한 명령들을 수정하게 하는 것으로서, 입체 뷰의 정점들에 대한 정점 좌표들을 생성하기 위해, 상기 수정된 정점 셰이더의 제 1 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 프리미티브들의 정점들을 상기 시야각에 기초하여 일 방향으로 변위시키고, 상기 수정된 정점 셰이더의 제 2 인스턴스의 실행은 상기 모노 뷰의 이미지에서의 상기 프리미티브들의 정점들을 상기 시야각에 기초하여 다른 방향으로 변위시키는, 상기 명령들을 수정하게 하고;
    그래픽 프로세싱 유닛 (GPU) 에게 상기 입체 뷰의 제 1 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 1 인스턴스를 실행할 것을 명령하게 하며; 그리고
    상기 GPU 에게 상기 입체 뷰의 제 2 이미지를 생성하기 위해 상기 수정된 정점 셰이더의 상기 제 2 인스턴스를 실행할 것을 명령하게 하는, 비-일시적 컴퓨터-판독가능 저장 매체.
32. 삭제
33. 삭제
34. 삭제
35. 삭제
36. 삭제
37. 삭제

Images