KR100357296B1

KR100357296B1 - 그래픽 렌더링 수행 방법과 그에 관한 컴퓨터 시스템 및 컴퓨터로 사용 가능한 기록 매체, 그리고 하이 레벨의 컴퓨터 프로그램 인스트럭션 시퀀스의 수행 방법

Info

Publication number: KR100357296B1
Application number: KR1020000014747A
Authority: KR
Inventors: 데빈스로버트제이; 샤넬리폴엠
Original assignee: 인터내셔널 비지네스 머신즈 코포레이션
Priority date: 1999-03-31
Filing date: 2000-03-23
Publication date: 2002-10-19
Also published as: TW463104B; KR20010006855A; JP3375074B2; CN100342396C; US6952215B1; JP2000311240A; CN1270366A

Abstract

본 발명은 단지 명목상으로만 호스트 시스템의 동작을 필요로 하고, 요청시에 그래픽 서브시스템상에서 그래픽 렌더링을 수행하는 방법 및 시스템에 관한 것이다. 렌더링될 그래픽을 요구하는 응용 프로그램은 기본적인 렌더링 함수에 대한 호출의 시퀀스를 한정하도록 코딩되어, 프로그램의 시작을 나타내는 식별자와 프로그램의 종료를 나타내는 식별자 사이에 렌더링될 원하는 이미지를 정의한다. 응용 프로그램이 호스트 동작 시스템상에서 실행될 때, 프로그램의 시작을 나타내는 식별자는 호스트 시스템 내의 그래픽 장치 드라이버 내의 함수를 호출한다. 이 함수는 응용 프로그램 내의 렌더링 함수에 대한 호출을 그래픽 서브시스템에 대한 하드웨어 인스트럭션으로 메모리 내에 포착한다. 함수가 프로그램의 종료를 나타내는 식별자를 만나면, 이는 포착된 하드웨어 인스트럭션을 호스트 시스템에 실행 가능한 프로그램으로 등록한다. 그 후, 응용 프로그램은 요청시에 상기 등록된 실행 가능한 프로그램을 호출하여 이미지를 렌더링할 수 있으며, 이는 단지 명목상으로만 호스트 프로세서의 동작을 필요로 하면서 그래픽 서브시스템상에서 메모리로부터 실행된다.

Description

그래픽 렌더링 수행 방법과 그에 관한 컴퓨터 시스템 및 컴퓨터로 사용 가능한 기록 매체, 그리고 하이 레벨의 컴퓨터 프로그램 인스트럭션 시퀀스의 수행 방법{METHOD AND COMPUTER SYSTEM FOR PERFORMING GRAPHICS RENDERING, COMPUTER-USABLE MEDIUM, AND METHOD FOR PERFORMING HIGH-LEVEL COMPUTER PROGRAM INSTRUCTION SEQUENCES}

본 발명은 컴퓨터 그래픽 시스템에 관한 것으로서, 더 구체적으로 말하자면 렌더링(rendering) 동작을 호스트 프로세서(host processor)로부터 그래픽 렌더링이 요구될 때 이를 수행할 수 있는 레지스터 기반형(register-based) 그래픽 서브시스템(subsystem)으로 오프로딩(offloading)함으로써, 단지 명목상으로만 호스트 프로세서의 동작을 필요로 하여 그래픽 렌더링 속도 및 효율을 높이는 방법 및 시스템에 관한 것이다.

일반적으로, 컴퓨터 그래픽 이미지는 프레임 버퍼(frame buffer)라고 하는 어떤 메모리 위치에 저장된 화소 해상도 값(pixel definition)[휘도(intensity) 및 색(color)]을 디스플레이 스크린에 전송함으로써 생성된다. 현재, 대부분의 디스플레이 시스템은 래스터 기반형(raster-based)인데, 여기서 '래스터 기반형'이란 전자 비임(beam)이 형광체가 코팅된(phosphor-coated) 디스플레이 스크린 내벽을 적절한 주파수로 스캔할 때, 프레임 버퍼에 저장된 값이 어느 특정 화소에서의 전자 비임의 휘도 및 색을 결정한다는 것을 의미한다.

프로그램 코드에 있는 이미지 해상도 값(image definition)의 집합을 CRT에 물리적으로 디스플레이될 수 있는 화소값 집합으로 변환한 다음, 그 화소값을 CRT에 스캔하는 과정을 보통 "렌더링(rendering)"이라고 한다. 이러한 렌더링에 있어서, 프로세서는 응용 프로그램으로부터 좀 더 복잡한 이미지를 만들기 위한 기본적인 구성 요소인 그래픽 프리미티브(graphical primitive)의 내역(內譯)을 가져오고 이것을 화소 해상도 값으로 변환해야 한다.

그래픽 동작이 실행되어야 하는 응용 프로그램은 선, 원, 다각형 등과 같은 프리미티브를 렌더링하는 기본적인 렌더링 함수를 요구하는 것이 보통이다. 이러한 기본적인 렌더링 함수는 하위 레벨(low-level) 코드로 작성되며, 그래픽 라이브러리(library)에 존재한다. 기본적인 렌더링 함수의 집합은 API(Application Programmer's Interface)라고 알려져 있으며, 프로그래머가 하위 레벨의 코드를 작성하지 않고도 이러한 기본적인 함수를 이용하여 C 언어나 포트란(Fortran) 언어와 같은 고급 언어로 그래픽 응용 프로그램을 작성할 수 있도록 한다. 시중에서 구득 가능한 몇 가지 표준 API로는 OpenGL, PHIGS(Programmers Hierarchical Graphics Standard), GKS(Graphical Kernel System)가 있다.

이미지를 렌더링하기 위해서는, 응용 프로그램 내에 있는 상위 레벨(high-level)의 API 내역을 해석하여 하드웨어 레벨의 코드로 만들어야 한다. 다음으로, 프레임 버퍼를 채우거나 수정하는 데에 필요한 실제 물리적인 I/O 동작을 실행하려면, 이 하드웨어 레벨 코드를 실행하여야 한다.

이러한 작업은 이미지가 비록 간단한 것이라 하더라도 프로세서 시간과 시스템 메모리의 상당히 많은 부분을 차지할 수 있다. 그러나, 그래픽 응용 프로그램은 점점 더 복잡해져서 명암, 그림자 등을 포함하고 칼라로 렌더링되는 복잡하고 사실적인 이미지를 요구한다. 예컨대, 비디오 게임과 같이 어떤 이미지를 반복적으로 만들 필요가 있는 경우에, 프로세서 시간 및 시스템 메모리에 대한 과다한 요구로인해 이미지 렌더링이 느려지고 사용자를 실망시킬 수 있다.

따라서, 반복 작업을 호스트 프로세서로부터 오프로딩하여 호스트 프로세서가 자유롭게 다른 필요한 작업을 수행할 수 있도록 하는 렌더링 기법이 요구된다. 좀 더 구체적으로 설명하면, 만약에 반복적으로 렌더링되어야 하는 어떠한 이미지에 대해 그래픽 응용 프로그램의 상위 레벨의 API 내역으로부터 하드웨어로 실행 가능한(hardware-executable) 인스트럭션(instruction)을 생성하는 데에 필요한 호스트 프로세서 동작을 한번만 실행하고, 그 이미지를 렌더링하라는 요구가 있는 경우에 상기 하드웨어로 실행 가능한 인스트럭션을 그 다음에 실행할 수 있다면, 호스트 프로세서 사이클 및 메모리를 절약할 수 있으며, 렌더링 속도는 증가될 것이다. 이러한 기법은 현존하는 종래 기술에는 알려져 있지 않다.

본 발명은 렌더링 작업을 호스트 프로세서로부터 그 렌더링 작업이 요구될 때 이를 수행할 수 있는 그래픽 서브시스템으로 오프로딩하는 방법 및 시스템을 제공한다. 본 발명에 따른 방법 및 시스템에 있어서, 그래픽 응용 프로그램에 의해 호출된 기본적인 렌더링 함수로 발생된 그래픽 하드웨어에 대한 하드웨어 인스트럭션이 메모리 내에 포착된다. 이러한 하드웨어 인스트럭션이 포착되면, 이 하드웨어 인스트럭션은 단지 명목상으로만 호스트 프로세서의 동작을 필요로 하며, 요청시에 이미지를 렌더링하기 위하여 그래픽 서브시스템상에서 수행될 수 있다.

본 발명에 따른 소프트웨어는 하드웨어 인스트럭션으로 포착될 기본적인 렌더링 함수의 시퀀스를 정의하는 임의의 그래픽 응용 프로그램 내의 인스트럭션에응답한다. 이러한 응용 프로그램 내의 인스트럭션은 본 발명에 의해 제공되는 장점을 이용하기를 원하는 프로그래머에 의해 통상적으로 코딩되며, 프로그램의 시작을 나타내는 식별자 및 프로그램의 종료를 나타내는 식별자로 한정된 특정 이미지를 렌더링하는 API 내의 기본적인 렌더링 함수에 대한 상위 레벨 호출의 시퀀스를 포함할 수 있다.

바람직한 실시예에 따르면, 응용 프로그램이 실행될 때에 프로그램의 시작을 나타내는 식별자는 본 발명의 소프트웨어를 호출한다. 이 소프트웨어는 프로그램의 시작을 나타내는 식별자 및 프로그램의 종료를 나타내는 식별자 사이에 한정된 기본적인 렌더링 함수에 대한 상위 레벨의 호출에 해당하는 하드웨어 인스트럭션을 발생하는 인스트럭션을 실행한다. 상기 하드웨어 인스트럭션은 실행되지 않고 메모리 내에 저장된다. 그 후, 상기 소프트웨어가 프로그램의 종료를 나타내는 식별자를 만나면, 그 소프트웨어는 누적적으로 저장된 하드웨어 인스트럭션을 호스트 시스템에 실행 가능한 프로그램으로 등록한다.

그 후에, 응용 프로그램이 렌더링될 이미지를 요구할 때마다, 그 응용 프로그램은 상기 등록된 실행 가능한 프로그램에 대한 호출을 발행하고, 저장된 하드웨어 인스트럭션은 단지 명목상으로만 호스트 프로세서의 동작을 필요로 하면서 그래픽 서브시스템 내에서 실행되어 이미지를 렌더링한다. 따라서, 응용 프로그램에 의해 특정된 기본적인 렌더링 함수의 시퀀스에 해당하는 하드웨어 인스트럭션이 한번만 발생되면 되므로 호스트 프로세서의 사이클을 절약하여 다른 작업을 수행할 수 있으며, 필요한 시스템 메모리를 줄이게 된다.

도 1은 종래 그래픽 렌더링 시스템의 전체적인 개략도.

도 2는 본 발명을 구현하는 시스템의 기본적인 소프트웨어 및 하드웨어 부품을 도시한 도면.

도 3은 본 발명에 따른 포착 루틴의 흐름도.

도 4는 본 발명을 사용하는 응용 프로그램의 예를 나타낸 도면.

[도면의 주요 부분에 대한 부호의 설명]

5 : 호스트 시스템

10 : 그래픽 서브시스템

15 : 그래픽 장치 드라이버

20 : 메모리

25 : DLP

30 : 그래픽 가속기

35 : 프레임 버퍼

40 : 디스플레이 장치

도 1은 종래 그래픽 렌더링 시스템을 개념적으로 도시하고 있다. 도 1에 도시된 시스템에 있어서, 호스트 동작 시스템(host operating system)(5)에는 그래픽 장치 드라이버 소프트웨어(7)가 있는데, 이는 그래픽 응용 프로그램(8)에 있는 상위 레벨의 그래픽 렌더링 내역에 응답하여 그래픽 서브시스템(6) 내의 그래픽 가속기(30)에 하위 레벨 인스트럭션을 발행한다. 그래픽 장치 드라이버(7)의 제어하에서, 가속기(30)는 화소 해상도 값을 프레임 버퍼(35)에 기록하고, 그 화소 해상도 값은 디스플레이 장치(40)상에서 스캔되어 이미지를 물리적으로 렌더링한다.

이와 대조적으로, 도 2는 본 발명에 따른 그래픽을 렌더링하는 방법 및 시스템의 기본적인 소프트웨어 및 하드웨어를 도시하고 있다. 그 구성 요소로는 RAM(20), 디스플레이 리스트 프로세서(Display List Processor; DLP)(25)로 알려진 주문형 그래픽 프로세서, 가속기(30), 프레임 버퍼(35) 및 CRT와 같은 디스플레이 장치(40)로 구성된 그래픽 서브시스템(10)을 포함한다. DLP(25)는 메모리(20)에 저장된 하드웨어 인스트럭션을 페치(fetch)하고 가속기(30)를 제어하기 위하여 그 인스트럭션을 발행할 수 있다. 가속기(30)는 고속 레지스터를 포함하는데, 이 고속 레지스터는 DLP(25)에 의해 발행된 인스트럭션에 따라 화소 해상도 값을 프레임 버퍼(35)에 기록한다. 그 다음, 그 화소 해상도 값은 프레임 버퍼(35)로부터 디스플레이 장치(40)에 스캔되어 이미지를 생성한다.

도 2 및 도 3을 참조하면, 본 발명의 특징을 달성하기 위한 컴퓨터로 실행 가능한(computer-executable) 인스트럭션이 그래픽 장치 드라이버(15) 내에 구현되어 있다. 장치 드라이버(15)는 포착 루틴(50) 및 API 세트(set)(17)를 포함하는데, 여기서 API 세트(17)는 프리미티브를 렌더링하는 기본적인 렌더링 함수의 집합이다. API 내의 각 함수는 하드웨어 레벨에서 컴퓨터로 실행 가능한 인스트럭션의 시퀀스를 포함하는데, 그 인스트럭션은 주로, 예컨대 주어진 프리미티브의 크기 및 색과 프레임 버퍼 내의 그 위치를 특정하는 레지스터 기록(register-write) 인스트럭션이다.

API(17) 내의 함수는, 예컨대 "Draw_Line", "Draw_Circle" 또는 "Fill_Circle"과 같은 그 고유의 부호 식별자(mnemonic identifier)로 함수를 특정하여 이에 선의 길이, 원의 반경 또는 채우기 색과 같은 적절한 파라미터를 전달함으로써, 상위 레벨의 프로그램 내의 인스트럭션에 의해 호출될 수 있다.

포착 루틴(50)은 호스트 컴퓨터(5)에서 실행되는 상위 레벨의 응용 프로그램(45) 내의 인스트럭션에 응답하여 하드웨어 인스트럭션으로서 RAM(20)에 미리 저장되는 "API 함수 호출"(47)의 시퀀스를 식별하는 컴퓨터로 실행 가능한 인스트럭션을 포함한다. 상위 레벨의 프로그램 내의 인스트럭션은 본 발명에 의해 제공되는 이로운 특징들을 호출하기 위하여, 통상적으로 프로그래머에 의해 렌더링될 그래픽을 요구하는 응용 프로그램 내에 코딩된다.

본 발명의 특징들을 호출하는 상위 레벨의 응용 프로그램(45) 내의 인스트럭션은 API 함수 호출 시퀀스(47)를 포괄하거나 한정하는 "Begin_Program"(46) 및 "End_Program"(48)을 나타내는 식별쌍을 포함하는데, 이는 프로그래머에 의해, 장치 드라이버(15) 내에 제공되는 API 세트(17) 내의 특정 렌더링 함수에 대한 부호식별자에 의한 호출로서 필요한 파라미터와 함께 코딩된다. 프로그래머는 원하는 이미지를 생성하기 위해 상기 API 시퀀스를 임의로 코딩한다. Begin_Program/End_Program 한정쌍은 하드웨어 인스트럭션으로서 메모리(20) 내에 미리 저장되는 API 시퀀스를 식별한다.

응용 프로그램 내의 Begin_Program 인스트럭션(46)이 실행되면, 함수 호출이 장치 드라이버 코드(15) 내의 포착 루틴(50)에 발행된다. 도 3은 포착 루틴의 기본적인 흐름을 도시하고 있다. 이 시퀀스는 응용 프로그램(45) 내의 Begin_Program 인스트럭션(46)에 의해 시작된다. 먼저, 도면 부호 55로 표시된 블록에 나타낸 바와 같이, 포착 루틴은 API 함수 호출(47)에 의해 발생된 하드웨어 인스트럭션을 가속기(30)에 발행하여 실행시키지 않고 메모리(20)에 저장하도록 장치 드라이버(15)를 지시하는 플래그를 세트시킨다. 이어서, 도면 부호 60으로 표시된 블록에 나타낸 바와 같이, 프로그래머에 의해 지정된 파라미터를 API 라이브러리(17) 내의 해당 API에 전달함으로써 Begin_Program 인스트럭션(46)에 뒤이은 API 함수 호출(47)을 계산하여 해당 하드웨어 인스트럭션을 발생하고, 그 하드웨어 인스트럭션을 메모리(20)에 저장한다. 이 API는 프로그래머에 의해 호출 파라미터 내에 특정된 특정 렌더링 함수를 수행하기 위하여, 프레임 버퍼(35)에 기록하기 위한 완전히 기계로 실행 가능한(fully machine-executable) 레지스터 인스트럭션을 포함한다.

포착 루틴(50)은 각 API 함수 호출(47)에 대하여 도면 부호 60의 블록에 표시된 연산을 수행한다. 포착 루틴 동안에, 장치 드라이버는 메모리(20) 내에 저장된 인스트럭션의 크기 및 시작 주소를 계산 및 기록한다. 그 다음, 도면 부호 65로표시된 블록에 나타낸 바와 같이, 응용 프로그램(45)이 End_Program 인스트럭션(48)을 발행하면, 포착 루틴은 Begin_Program 인스트럭션(46)에 의해 세트된 플래그를 리셋시키고, 집합적으로 저장된 하드웨어로 실행 가능한 인스트럭션을 호스트 시스템(5)에 실행 가능한 프로그램으로 등록한다. 그 프로그램은 장치 드라이버에 의해 계산된 숫자를 포함하는 변수인 고유의 부호 식별자 "id"를 사용함으로써 호출될 수 있다. 그 변수 "id"에는 통상적으로 Begin_Program 인스트럭션(46)에서 프로그래머에 의해 의미 있는 이름이 주어진다.

장치 드라이버는 응용 프로그램(45) 내의 각 Begin_Program/End_Program 쌍에 대해 전술한 처리 과정을 수행한다. 이러한 식별쌍으로는 여러 가지가 있을 수 있으나, 일단 한정된 API 시퀀스(47)가 하드웨어 인스트럭션으로 변환되고 메모리(20)에 저장된 후 호스트 시스템(5)에 실행 가능한 프로그램으로 등록되면, 이는 요청시에 통상적인 호스트 프로세서, 즉 장치 드라이버의 동작을 요구하지 않고도 그래픽 서브시스템(10)에 의해 수행될 수 있다. 도 3에 도시된 바와 같이, 응용 프로그램(45)은 단지 그 할당된 부호인 "id"를 Execute_Program 인스트럭션(49) 내에 특정함으로써, 원할 때마다 이미지를 디스플레이 스크린상에 렌더링할 수 있다. Execute_Program 인스트럭션(49)은 DLP(25)로 하여금 메모리(20)에 저장된 "id"에 해당하는 하드웨어 인스트럭션을 판독하여, 이를 가속기(30)에 발행하게 한다. 가속기는 그 레지스터 인스트럭션을 수행하여 프레임 버퍼(35)를 채운다. 그 다음, 프레임 버퍼(35)로부터 디스플레이 장치(40)상으로 화소 해상도 값을 스캔하여 원하는 이미지를 생성한다.

요구되는 유일한 장치 드라이버의 동작은 이미지를 Locate_Scene 인스트럭션(70)에서 특정된 바대로 프레임 버퍼(35) 내에 위치시키고, 그 다음 이미지를 물리적으로 렌더링하기 위하여 Execute_Program 인스트럭션(49)에 특정된 저장된 하드웨어 인스트럭션을 개시하는 것이다. 따라서, 응용 프로그램이 API 함수를 요구할 때마다 그 API 함수를 실제로 실행함으로써 API 함수의 시퀀스를 수행하는 데 요구되는 장치 드라이버의 동작은 불필요하게 되어, 이러한 동작에 요구되는 메모리 및 호스트 프로세서의 사이클을 기타 용도에 사용할 수 있게 된다.

이하에서는, 프로그래머가 비디오 게임에 사용되는 자동차의 이미지를 생성하기를 원하는 경우에 있어서의 본 발명의 응용예를 설명한다.

통상적으로, 프로그래머는 호스트 프로세서, 메모리, 판독/기록 디스크 저장 장치 및 사용자가 소프트웨어 작성 및 편집용 텍스트 편집기를 포함하는 응용 소프트웨어 및 운영 체제와 대화하는 것을 가능하게 하는 키보드 및 마우스와 같은 I/O 장치를 포함하는 컴퓨터 시스템상에서 작업하게 된다. 그 프로그래머는 텍스트 편집기를 사용하여 본 발명의 장치 드라이버 소프트웨어에 의해 인식 가능한 인스트럭션을 포함하는 소스 코드를 작성 또는 편집할 수 있다. 본 발명을 구현하기 위하여, 그 컴퓨터 시스템은 통상적으로 도 2에 도시된 구성 요소들을 포함하는 그래픽 서브 시스템을 더 필요로 하게 된다.

상기 비디오 게임용 소스 코드에 있어서, 프로그래머는 통상적으로 Begin_Program/End_Program 쌍을 정의하는 프로그램 인스트럭션을 기록하여 자동차 이미지의 구성 요소를 렌더링하는 API 함수의 시퀀스를 한정할 수 있다. 예컨대,자동차의 타이어를 렌더링하는 API 함수의 시퀀스를 한정하는 의사 코드(pseudo-code)는 다음과 같이 작성할 수 있다.

htire = Begin_Program(); // 기본적인 타이어를 렌더링하기 위하여

// 저장된 프로그램을 정의함;

Draw_Circle(100); // 타이어의 윤곽을 그림;

Fill_Circle(Black); // 그 원을 검정색으로 채색함;

Draw_Circle(10); // 타이어의 중앙에 더 작은 원을

// 직접 그림;

Fill_Circle(Silver); // 타이어에 크롬 도금한 휠 모양을 생성함;

End_Program(); // 타이어를 렌더링하는 하드웨어

// 인스트럭션을 저장함;

이 예에 있어서, 첫번째 인스트럭션인 "htire = Begin_Program()"은 본 발명의 방법에 따라 하드웨어 인스트럭션으로 변환되어 메모리 내에 저장될 API 함수의 시퀀스의 시작을 표시한다. 부호 "htire"는 프로그래머에 의해 임의로 할당되며, 장치 드라이버(15)에 의해 계산되고 발생될 저장된 프로그램을 식별 및 추적하는 데 사용되는 숫자를 포함하는 변수를 나타낸다.

후속 인스트럭션들, 즉 "Draw_Circle(100)"(여기서, 숫자 100은 함수 파라미터이며, 참조 번호가 아님), "Fill_Circle(Black)", "Draw_Circle(10)" 및 "Fill_Circle(Silver)"는 프리미티브를 렌더링하는 API(17) 내의 함수에 대한 호출을 나타낸다. 여기서, 상기 API 함수는 타이어를 표현하기 위하여 중앙에 작은 은색 원이 있는 검정색 원을 렌더링할 것이다.

최종 인스트럭션인 "End_Program()"은 저장될 API 시퀀스의 마지막을 표시한다.

비디오 게임의 소스 코드는 기타 자동차의 몸체, 창문, 범퍼 등을 렌더링하는 API 시퀀스를 한정하기 위하여 위와 유사하게 작성될 수 있다.

통상적으로, 본 발명에 의한 장점을 가장 잘 구현하기 위해서, 프로그래머는 응용 프로그램의 예비 단계 또는 초기화 단계로서 위와 같이 하드웨어 인스트럭션으로 미리 저장될 모든 API 시퀀스를 식별할 수 있다. 하드웨어 인스트럭션을 실행하는 소스 코드는, 일단 그 하드웨어 인스트럭션이 저장되었다면 상기 초기화 단계 다음에 올 수 있다. 자동차의 예에 있어서, 저장된 하드웨어 인스트럭션을 실행하는 의사 코드는 다음과 같이 작성할 수 있다.

Locate_Scene(front); // 앞 타이어가 그려질 위치를 설정함;

Execute_Program(htire); // 자동차의 앞부분에서 타이어 전체를

// 렌더링함;

Locate_Scene(rear); // 뒷 타이어가 그려질 위치를 설정함;

Execute_Program(htire); // 자동차의 뒷부분에서 타이어 전체를

// 렌더링함;

Locate_Scene(top); // 자동차의 몸체가 그려질 위치를 설정함;

Execute_Program(hbody); // 자동차의 몸체를 그림("hbody"는 "htire"

// 와 같은 미리 저장된 프로그램임);

전술한 바와 같이 미리 저장된 API 시퀀스를 식별 및 실행하기 위해 편집된 비디오 게임의 소스 코드는 후속 실행을 위하여 저장 장치에 저장될 수 있다.

도 4는 상기 프로그램예의 실행을 설명하고 있다(자동차 몸체의 렌더링은 나타내지 않음). 이 프로그램은 호스트 시스템(5) 내의 그래픽 응용 프로그램(45)으로서 실행된다. "htire = Begin_Program" 인스트럭션(46)의 실행으로 포착 루틴(50)에 대한 함수 호출이 수행되며, 도 3에 도시된 기본적인 처리 과정이 개시된다. 특정 예를 설명하기 위하여 처리 과정의 흐름을 도 4에 도시하였다.

우선, 포착 루틴(50)은 API 함수 호출(47)에 해당하는 하드웨어 인스트럭션이 실행되지 않고 메모리(20)에 저장되도록 지시하는 플래그를 세트시킨다. 따라서, 도면 부호 60a로 표시된 블록에 나타낸 바와 같이 "Draw_Circle(100)"(47a)에 대한 API 호출은 포착 루틴으로 하여금 해당 하드웨어 인스트럭션을 발생 및 저장하는 인스트럭션을 실행시킨다. 이를 위하여, 포착 루틴은 원하는 원 반경을 정의하는 프로그래머가 특정한 파라미터 "100"을 레지스터 I/O 인스트럭션을 포함하는 기본적인 렌더링 함수인 "Draw_Circle()"(18)에 전달하고, 그 레지스터 인스트럭션을 메모리(20) 내에 저장한다.

다음으로, 도면 부호 60b에 도시된 바와 같이, 포착 루틴은 그 다음 인스트럭션인 "Fill_Circle(Black)"(47b)에 응답하여, 색 파라미터인 "Black"을 기본적인 렌더링 함수인 "Fill_Circle()"(19)로 전달하고 그 레지스터 인스트럭션을 메모리(20)에 저장함으로써, 그 원을 검정색으로 채우는 하드웨어 인스트럭션을 발생한다.

도면 부호 60c 및 60d로 표시된 블록은 이와 유사하게 도면 부호 47c 및 도면 부호 47d로 표시된 API 내역에 응답한다.

그 후, 응용 프로그램은 End_Program 인스트럭션(48)을 발행하고, 포착 루틴은 도면 부호 65로 표시된 블록에 나타낸 바와 같이 응답한다. Begin_Program 인스트럭션에 의해 세트된 플래그는 리셋되고, 상기 처리 과정 동안에 메모리(20) 내에 저장된 집합적인 하드웨어 인스트럭션은 호스트 시스템(5)에 실행 가능한 프로그램 "htire"로서 등록된다.

응용 프로그램(45)은 실행을 계속하며, 타이어의 이미지를 렌더링하는 데 필요한 모든 하드웨어 레벨의 인스트럭션이 메모리(20) 내에 실행 가능한 프로그램인 "htire"로 저장된다. 따라서, 그 후에 응용 프로그램이 디스플레이 장치(40)상에 타이어를 렌더링하고자 할 때마다, 응용 프로그램은 필요한 때에 "Execute_Program(htire)" 인스트럭션(49)을 발행하고, 그래픽 서브시스템은 장치 드라이버의 동작 없이도 이미지를 Locate_Scene 인스트럭션(70a, 70b) 내에 위치시켜 이미지를 물리적으로 렌더링하도록 Execute_Program 인스트럭션(49) 내에 특정된 저장된 하드웨어 인스트럭션을 개시함으로써 타이어를 렌더링한다. Execute_Program 인스트럭션(49)에 응답하여, DLP(25)는 메모리(20) 내에 저장된 "htire"에 해당하는 하드웨어 인스트럭션을 판독하고 이를 가속기(30)에 발행한다. 가속기는 그 레지스터 인스트럭션을 수행하여 프레임 버퍼(35)를 채운다. 그 다음, 화소 해상도 값이 프레임 버퍼(35)로부터 디스플레이 장치(40)상으로 스캔되어 타이어 이미지를 발생한다.

상기 자동차 이미지의 렌더링 예에 있어서, Locate_Scene(front)(70a) 및 Locate_Scene(rear)(70b)의 의사 코드 인스트럭션은 포착된 하드웨어 인스트럭션을 사용하여 타이어를 렌더링하기 위한 프레임 버퍼의 위치를 특정하는 동작을 나타낸다. 자동차의 합성 장면은 Locate_Scene 인스트럭션에 특정된 위치에서, 타이어, 몸체 등의 구성 요소를 결합함으로써 구성된다.

또한, Execute_Program 인스트럭션을 조합함으로써 자동차의 이미지를 렌더링할 수 있다. 예컨대, "hcar"라는 주 프로그램은 "htire", "hbody" 등을 호출하는 Execute_Program 인스트럭션으로 구성될 수 있다. 이러한 Execute_Program 인스트럭션은 주요 장면에 대하여 객체가 렌더링 될 주요 장면 내의 위치를 특정하는 Locate_Scene_Object 인스트럭션 다음에 올 수 있다. 그 다음, "hcar"가 포착되면 전체 자동차는 단일의 Execute_Program(hcar) 인스트럭션으로 렌더링될 수 있다.

자동차 이미지의 렌더링 예로 설명한 바와같이, 본 발명에 의해 제공되는 장점은 전술한 방법 및 시스템에 따른 하드웨어 인스트럭션으로서 포착된 간단하고 재배치 가능한 부장면을 이용하여 복잡한 장면을 효과적으로 구성할 수 있다는 점이다. 프레임 버퍼 내의 주장면의 위치를 특정할 수 있으며, 그 후 복잡한 장면은 포착된 하드웨어 인스트럭션을 사용하여 부장면들을 주장면 내에 배치시킴으로써 신속하게 렌더링될 수 있다.

이러한 특징의 구체화는 Locate_Scene 동작 자체를 재배치 가능한 부장면과 함께 하드웨어 인스트럭션으로서 포착함으로써 얻어질 수 있다. 그 일예를 아래의 의사 코드로 설명한다.

// 오른쪽 바닥 모서리 근처의 대각선을 포함하는

// 재배치 가능한 부장면의 생성

hprog = Begin_Program() // "hprog"라고 불리는 저장된 프로그램을

// 생성하도록 포착 루틴을 개시함;

Locate_Scene_Object(20,20) // 특정된 주장면의 좌표에 대한

// (20, 20) 좌표에서 객체를 위치시키는

// 하드웨어 인스트럭션의 발생 및 저장;

Draw_in_Object(0,0,10,10) // 10 개의 화소로 이루어진 대각선을

// 렌더링하는 하드웨어 인스트럭션을

// 발생 및 저장;

End_Program(hprog) // 포착 루틴을 종료하고 "hprog"를

// 호스트 시스템에 실행 가능한

// 프로그램으로 등록;

이 의사 코드가 응용 프로그램(45) 내에 코딩되어 도 2 및 도 3에 나타낸 바와 같이 호스트 시스템(5)상에서 실행될 때, 그 의사 코드는 메모리(20)상의 하드웨어 인스트럭션으로 구성된 저장된 프로그램을 생성하며, 이는 DLP(25)에 의해 실행될 때 주장면의 특정된 좌표에 대해 (20, 20)의 직교 좌표를 가지는 프레임 버퍼 위치에서 10 개의 화소로 이루어진 대각선을 렌더링하게 된다.

아래의 의사 코드는 상기 포착된 프로그램인 "hprog"를 사용하여 주장면 내에 부장면을 효과적으로 재배치 및 렌더링하는 예를 나타낸다.

Locate_Scene(primary_scene,0,0) // 주장면 내의 (0,0) 좌표에

// 부장면을 위치시킴;

Execute_Program(hprog) // 포착된 하드웨어 인스트럭션을

// 사용하여 (0,0)에 대하여

// (20,20)에서 부장면(10 개의 화소

// 의 대각선)을 렌더링함;

Locate_Scene(primary_scene,55,59) // 주장면 내의 (59,59) 좌표에

// 부장면을 위치시킴;

Execute_Program(hprog) // 포착된 하드웨어 인스트럭션을

// 사용하여 (0,0)에 대하여

// (55,59)에서 부장면(10 개의 화소

// 의 대각선)을 렌더링함;

이 의사 코드의 예는 응용 프로그램(45) 내에서 실행될 때, DLP(25)로 하여금 포착된 하드웨어 인스트럭션인 "hprog"를 실행하도록 하여, "primary_scene"에 의해 식별된 주장면 내의 (20,20) 좌표 및 (55,59) 좌표에서 10 개의 화소로 이루어진 대각선을 포함하는 부장면을 렌더링한다.

전술한 본 발명은 폭넓게 적용 가능하며, 응용 프로그램에 의해 특정되는 여러 형태의 하드웨어 레벨의 컴퓨터 프로그램 인스트럭션의 시퀀스로부터, 저장된 재사용 가능한 하드웨어 레벨의 인스트럭션을 발생하는 데 사용될 수 있다. 그 후, 그 저장된 하드웨어 인스트럭션은 최소한의 호스트 동작 시스템에 의해 요구되는동작으로 서브시스템상에서 실행되어, 호스트 프로세서 사이클 및 메모리의 요구를 감소시킬 수 있다.

전술한 바와 같이, 본 발명은 그래픽 서브 시스템의 그래픽 장치 드라이버 내의 컴퓨터로 실행 가능한 인스트럭션으로 구현될 수 있다. 그 구현에 있어서, 장치 드라이버 코드를 적절한 위치에서 임의의 컴퓨터로 사용 가능한(computer-usable) 매체상에, 예컨대 컴퓨터 메모리 내에 호스트 운영 체제의 완전히 링크된(fully-linked) 서브루틴으로서 상주시킬 수 있다. 본 발명을 적극적으로 구현하지 않을 때에는, 그 코드를 테이프, 플로피 디스크, 하드 디스크, CD-ROM 등과 같은 휴대용 컴퓨터로 사용 가능한 매체상에 상주시킬 수 있다.

전술한 기재는 본 발명을 설명한다. 또한, 이러한 기재는 본 발명의 바람직한 실시예만을 설명하고 있으나, 본 발명은 여러 가지 기타 조합, 변형 및 환경에서 사용 가능하며, 전술한 설명 및/또는 당업계의 기술 또는 지식 수준에 부합하여 본 명세서에 설명된 발명의 범위 내에서 변경 또는 변형이 가능하다. 또한, 전술한 실시예는 본 발명을 실시하는 데 알려진 최적의 상태를 설명하고, 당업자가 본 발명을 이러한 또는 기타 실시예와 특정 응용 또는 본 발명의 사용에 요구되는 여러 변형에 사용하는 것을 가능하도록 하였다. 따라서, 전술한 설명은 본 발명을 본 명세서에 설명된 형태로 제한하기 위한 것이 아니다. 또한, 첨부된 청구 범위는 대체 실시예를 포함하는 것으로 해석될 수 있다.

본 발명에 따르면, 그래픽 렌더링 동작을 호스트 시스템으로부터 그래픽 서브시스템으로 렌더링함으로써, 호스트 시스템의 프로세서 사이클 및 메모리를 절약할 수 있으며, 그래픽 렌더링 속도 및 효율을 높일 수 있다.

Claims

그래픽의 렌더링(rendering)을 수행하는 방법으로서,

a) 그래픽 응용 프로그램에 의해 호출된 기본적인 렌더링 함수로 발생된 하드웨어 인스트럭션(instruction)을 메모리 내에 실행 가능한 프로그램으로서 포착하는 단계와,

b) 이미지를 렌더링하기 위하여, 상기 포착된 하드웨어 인스트럭션을 요청시에 그래픽 서브시스템(graphics subsystem)상에서 실행하는 단계

를 포함하는 그래픽 렌더링의 수행 방법.
삭제
삭제
제1항에 있어서, 상기 실행 단계 b)는

b1) 그래픽 프로세서를 이용하여, 상기 포착된 하드웨어 인스트럭션을 상기 메모리로부터 발행하는 단계와,

b2) 그래픽 가속기를 이용하여, 상기 포착된 인스트럭션을 수신하고 상기 포착된 인스트럭션으로부터 유도된 화소 정보를 프레임 버퍼(frame buffer)에 기록함으로써, 이미지를 렌더링하는 단계

를 포함하는 것인 방법.
그래픽 렌더링을 수행하는 컴퓨터 시스템으로서,

a) 호스트 동작 시스템과,

b) 렌더링 동작을 수행하는 하드웨어를 포함하는 그래픽 서브시스템

을 포함하고,

상기 호스트 동작 시스템은 그래픽 응용 프로그램에 의해 발행된 인스트럭션에 응답하여, 그래픽 응용 프로그램에 의해 호출된 기본적인 렌더링 함수로 발생된 그래픽 서브시스템에 대한 하드웨어 인스트럭션을 메모리 내에 실행 가능한 프로그램으로 포착하는 컴퓨터로 실행 가능한(computer-executable) 인스트럭션을 포함하는 소프트웨어를 포함하는 것인 그래픽 렌더링을 수행하는 컴퓨터 시스템.
제5항에 있어서, 상기 소프트웨어는 상기 하드웨어 인스트럭션을

i) 상기 렌더링 함수에 해당하는 하드웨어 인스트럭션을 발생함으로써, 기본적인 렌더링 함수의 시퀀스를 한정하는 상기 그래픽 응용 프로그램 내의 인스트럭션에 응답하는 단계와,

ii) 상기 하드웨어 인스트럭션을 메모리 내에 저장하는 단계와,

iii) 상기 저장된 하드웨어 인스트럭션을 호스트 동작 시스템에 실행 가능한 프로그램으로 정의하는 단계

에 의해 포착하는 것인 컴퓨터 시스템.
제5항에 있어서, 상기 하드웨어 인스트럭션은 사용자가 특정한 파라미터를 기본적인 렌더링 함수의 집합으로부터 획득된 기본적인 렌더링 함수로 전달함으로써 발생되는 것인 컴퓨터 시스템.
제5항에 있어서, 상기 그래픽 렌더링을 수행하는 하드웨어는

i) 상기 포착된 하드웨어 인스트럭션을 상기 메모리로부터 발행하는 그래픽 프로세서와,

ii) 이미지를 렌더링하기 위하여, 상기 포착된 인스트럭션을 수신하고 상기 포착된 인스트럭션으로부터 유도된 화소 정보를 프레임 버퍼에 기록하는 그래픽 가속기

를 포함하는 것인 컴퓨터 시스템.
그래픽 렌더링의 수행 방법을 구현한 컴퓨터로 실행 가능한 프로그램 코드를 구체화한 컴퓨터로 사용 가능한(computer-usable) 기록 매체로서,

상기 코드는 그래픽 응용 프로그램 내의 인스트럭션에 응답하여, 상기 응용 프로그램에 의해 호출된 기본적인 렌더링 함수로 발생된 하드웨어 인스트럭션을 메모리 내에 실행 가능한 프로그램으로 포착하는 인스트럭션을 포함하는 것인 컴퓨터로 사용 가능한 기록 매체.
제9항에 있어서, 상기 코드는

i) 상기 렌더링 함수에 해당하는 하드웨어 인스트럭션을 발생함으로써, 기본적인 렌더링 함수의 시퀀스를 한정하는 그래픽 응용 프로그램 내의 인스트럭션에 응답하는 인스트럭션과,

ii) 상기 하드웨어 인스트럭션을 메모리 내에 저장하는 인스트럭션과,

iii) 상기 저장된 하드웨어 인스트럭션을 호스트 동작 시스템에 실행 가능한 프로그램으로 정의하는 인스트럭션

을 포함하는 것인 컴퓨터로 사용 가능한 기록 매체.
제9항에 있어서, 상기 하드웨어 인스트럭션은 사용자가 특정한 파라미터를 기본적인 렌더링 함수의 집합으로부터 획득된 기본적인 렌더링 함수로 전달함으로써 발생되는 것인 컴퓨터로 사용 가능한 기록 매체.
제9항에 있어서, 상기 코드는 그래픽 프로세서를 제어하여 상기 포착된 하드웨어 인스트럭션을 상기 메모리로부터 그래픽 가속기로 발행하는 인스트럭션을 포함하는 것인 컴퓨터로 사용 가능한 기록 매체.
a) 응용 프로그램에 의해 발행된 하이 레벨의 인스트럭션에 의해 발생된 서브시스템에 대한 하드웨어 인스트럭션을 메모리 내에 실행 가능한 프로그램으로 포착하는 단계와,

b) 상기 포착된 하드웨어 인스트럭션을 요청시에 서브시스템상에서 실행하는 단계

를 포함하고,

요청시에 호스트 동작 시스템의 서브시스템상에서 실행 가능하고 재사용 가능한 하드웨어 레벨의 인스트럭션을 사용하여 하이 레벨의 컴퓨터 프로그램 인스트럭션 시퀀스를 수행하는 하이 레벨의 컴퓨터 프로그램 인스트럭션 시퀀스의 수행 방법.
제1항 또는 제13항에 있어서, 상기 포착 단계 a)는

a1) 상기 렌더링 함수에 해당하는 하드웨어 인스트럭션을 발생함으로써, 기본적인 렌더링 함수의 시퀀스를 한정하는 그래픽 응용 프로그램 내의 인스트럭션에 응답하는 단계와,

a2) 상기 하드웨어 인스트럭션을 메모리 내에 저장하는 단계와,

a3) 상기 저장된 하드웨어 인스트럭션을 호스트 동작 시스템(host operating system)에 실행 가능한 프로그램으로 정의하는 단계

를 포함하는 것인 방법.
제1항 또는 제13항에 있어서, 상기 하드웨어 인스트럭션은 사용자가 특정한 파라미터를 기본적인 렌더링 함수의 집합으로부터 획득된 기본적인 렌더링 함수로 전달함으로써 발생되는 것인 방법.
그래픽 렌더링을 수행하는 방법으로서,

a) 그래픽 응용 프로그램 내의 기본적인 렌더링 함수의 시퀀스를 메모리 내에 하드웨어 인스트럭션으로 포착될 시퀀스로서 정의하는 단계와,

b) 포착된 하드웨어 인스트럭션을 발생하기 위하여, 상기 정의된 시퀀스를 포함하는 그래픽 응용 프로그램을 실행하는 단계와,

c) 이미지를 렌더링하기 위하여 상기 포착된 하드웨어 인스트럭션을 실행하는 단계

를 포함하는 그래픽 렌더링의 수행 방법.
제16항에 있어서, 상기 정의 단계 a)는 기본적인 렌더링 함수의 시퀀스를 포착 처리 단계를 호출하는 식별자 사이에 한정하는 단계를 포함하는 것인 방법.
제17항에 있어서, 상기 그래픽 응용 프로그램의 실행 단계 b)는 그래픽 서브시스템을 가지며,

i) 상기 렌더링 함수에 해당하는 하드웨어 인스트럭션을 발생함으로써 기본적인 렌더링 함수의 시퀀스를 한정하는 상기 그래픽 응용 프로그램 내의 인스트럭션에 응답하는 인스트럭션과,

ii) 상기 하드웨어 인스트럭션을 메모리 내에 저장하는 인스트럭션과,

iii) 상기 저장된 하드웨어 인스트럭션을 호스트 동작 시스템에 실행 가능한 프로그램으로 정의하는 인스트럭션

을 포함하는 소프트웨어를 포함하는 호스트 동작 시스템상에서 수행되는 것인 방법.
그래픽 렌더링을 수행하는 방법으로서,

a) 부장면(subscene)을 정의하는 그래픽 응용 프로그램에 의해 호출된 기본적인 렌더링 함수의 시퀀스에 의해 발생되는 하드웨어 인스트럭션을 메모리 내에 실행 가능한 프로그램으로 포착하는 단계와,

b) 주장면 내에 렌더링될 상기 부장면의 위치를 특정하는 단계와,

c) 상기 특정된 위치에서 상기 부장면을 렌더링하도록 상기 포착된 인스트럭션을 실행하는 단계

를 포함하는 그래픽 렌더링의 수행 방법.
그래픽 렌더링을 수행하는 방법을 구현한 컴퓨터로 실행 가능한 프로그램 코드를 구체화한 컴퓨터로 사용 가능한 기록 매체로서, 상기 방법은

a) 부장면을 정의하는 그래픽 응용 프로그램에 의해 호출된 기본적인 렌더링 함수의 시퀀스에 의해 발생되는 하드웨어 인스트럭션을 메모리 내에 실행 가능한 프로그램으로 포착하는 단계와,

b) 주장면 내에 렌더링될 상기 부장면의 위치를 특정하는 단계와,

c) 상기 특정된 위치에서 상기 부장면을 렌더링하도록 상기 포착된 인스트럭션을 실행하는 단계

를 포함하는 것인 컴퓨터로 사용 가능한 기록 매체.