곡선 및 곡면을 다루는 굉장한 신기술에 대하여 들어봤으리라 생각합니다. 2차 베지어 패치, 3차 베지어 곡선, NURBS... 여러분은 이 모든 미친 것들을 이해하려고 시도한적이 있을겁니다. 아마도 이들 기술을 여러분이 만들고있는 게임 또는 데모에 넣으려고 했을 수도 있겠지요.

이 아티클은 이들에 대한 미스테리를 푸는데 있어 좋은 시작점이 될 것입니다.

이 아티클에서는, 이들 베지어 곡선뒤에 깔려있는 수학원리와 (곡선중에서 가장 간단한) 2차 베지어 곡선을 그리기위한 코드, 그리고 3차, 4차, 5차 또는 그 이상의 여러분이 필요한 수준의 베지어 곡선을 만들기위한 방법들을 유추하기위해 사용하는 몇가지 기술을 설명할 것입니다.

좋습니다. 가장먼저 짚고 넘어가야할 것은 번스타인(Bernstein) 정리 공식"들"입니다. 자, 이제 공식하나를 보여줄 예정인데, 초조해할 필요는 없습니다. 단지 이 공식을 보면 정말로 간단하다는 것을 금방 알 수 있을거니까요.

1 = t + (1 - t)

t는 어떠한 상수라도 될 수 있으며 이 공식은 모든 경우의 수에 대하여 언제나 참입니다. 그러나 이 아티클에서는 t가 0과 1사이일 경우만 고려하도록 하겠습니다.

이제 번스타인 정리 공식을 알았습니다. 그러나 이전에 제가 공식"들"이라고 복수형으로 말했던 것을 기억하세요! 자, 잘 동작하는 곡선을 얻기위한 다음 단계는 우리의 자그마한 데모에서 어떤 종류의 곡선을 사용할 것인지 선택하는 것입니다. 초심자를 위해서, 여기서는 가장 쉬운 형태인 2차 베지어 곡선을 사용하도록 하겠습니다.

자, 그리하여 2차 베지어 곡선을 택하게 되었습니다. 이제 전지전능한 정리 공식으로부터 몇가지 공식들을 끌어내야할 필요가 있습니다. 2차 베지어 곡선을 위해서는, 우선 번스타인 정리 공식의 양변을 제곱합니다. 3차 베지어 곡선을 얻으려면, 양변을 3제곱합니다. 그 이상의 차수에도 마찬가지입니다. 양변을 제곱하면 다음과 같은 결과가 나올겁니다.

1^2 = (t + (1 - t))^2
1 = t^2 + 2*t*(1-t) + (1-t)*(1-t)

You'll notice that a lot of this I didn't simplify, that's because it's easier to understand and code if you leave it this way.

Ok, now we have our 3 functions, which we derived from our basis. But where you ask. Well, right in front of you! Our functions are each of the terms to the right side of the equation. We'll call our functions Bx(t). It should be noted that the code is in bold.

#define	B1(t)		(t*t)
#define	B2(t)		(2*t*(1-t))
#define	B3(t)		((1-t)*(1-t))

2차 베지어 곡선인 경우에는 위 3개의 공식만 알고 있으면 됩니다.

참고로 3차(cubic) 곡선인 경우는 아래와 같습니다.

B1(t) = t * t * t
B2(t) = 3 * t * t * (1 - t)
B3(t) = 3 * t * (1 - t) * (1 - t)
B4(t) = (1 - t) * (1 - t) * (1 - t)

4차(quartic) 곡선인 경우입니다.

B1(t) = t * t * t * t
B2(t) = 4 * t * t * t * (1 - t)
B3(t) = 6 * t * t * (1 - t) * (1 - t)
B4(t) = 4 * t * (1 - x) * (1 - t) * (1 - t)
B5(t) = (1 - t) * (1 - t) * (1 - t) * (1 - t)

이렇게 분해해놓은 공식만있으면 수학공식정리를 하지 않아도 됩니다! 이제 베지어 곡선뒤에 숨은 간단한 수학을 건너뛰었습니다. 이들을 가지고 프로그램을 논하도록 하죠!

자, 이제 우리는 기본 공식들을 얻었습니다. 이제 이들을 적당하게 사용하면 됩니다.

I think that now would be a really good time to mention that along with these functions, you should also have 3 control points, which we'll call Cx. You can save these control points in a structure that looks like this:

typedef struct sCPoint
{
	int x;
	int y;
}  C_POINT;

주의 : 여기서는 2D에서의 베지어 곡선을 논할 것입니다만, 3D를 구현하고자 한다면 이 구조체에 z 요소만 추가하면 됩니다.

물론 이러한 제어점이 3개가 필요하므로, 배열을 선언하도록 하겠습니다.

C_POINT controlP[3];

이제 화면에 베지어 곡선을 실제로 그리는 단계에 와있습니다. Right now, our curve is only imaginary, and only exists as math equations. 해야할일이라면, 얻어낸 공식을 사용하여 곡선을 따라 진행하고, 만들어진 곡선 경로를 따라 점을 찍으면 화면에 곡선이 나타날 겁니다.

Which brings us to the last thing that I want to talk about; Detail Biases. Basically what a detail bias is, is a number that tells us how far we want to move along our curve each time we want to put a pixel along it's path. Detail biases are always decimals, and are most easily thought of as percentages. A detail bias of 0.5 would say "Ok, start at the beginning of our curve, put a point there, move 50% along our curve and put a point there, then move 50% more and put a point there (at the end of our curve).", this would put a point at the start of our curve, in the exact middle, and at the very end. We would need a counter to keep track of how much of the curve we've rendered, and we would increase this counter by 0.5 each time we put a point until it reaches 1, at which point we would stop. The smaller your detail bias, the more points you'll have on your curve, and the more solid it will look. Ok, without further adieu, the code to render a quadratic bézier spline. It should be noted that the macros Bx() where already defined up top, as were the controlP structures.

//주의: 각각의 controlP는 이미 x, y좌표로 채워져있다고 가정합니다.

double count;  // 카운터 임시변수
double detailBias; //곡선안에 얼마나 많은 점들을 찍을 것인가를 결정합니다

double x,y; //코드의 가독성을 높이기위한 변수

detailBias = 1 / 50; //곡선에 51개의 점을 찍습니다(0.02 정밀도)

do
{
   x = controlP[0].x*B1(count) + controlP[1].x*B2(count) + controlP.x[2]*B2(count);
   y = controlP[0]*B1.y(count) + controlP[1].y*B2(count) + controlP.y[2]*B2(count);

   PutPixel(x,y,RGB(255,255,255));

   count += detailBias;
}while( count <= 1);

Notice how we get our x and y values. We multiply each control point by the coresponding basis function (B1 with control point 1, B2 with control point 2, etc.), and add them all together. We do this for both the x and y coordinates, and if we're working in the third dimension, the z coordinate as well.

I'm just going to scratch the surface (pun intended) of how to make curved surfaces out of Bézier curves, because this subject is big enough to fit in an article by it's self, and is beyond the scope of this article. I will only discuss quadratic bézier patches, and I will supply no code for you to look at. I will tell you how to generate points from this surface, which you can then turn into triangles or quads quite easliy.

http://www.gamedev.net/reference/programming/features/unrav_bezier/curves.gif

This image is the basic idea of how a patch, made out of quadratic bézier splines, would look like. It would have 9 control points, and you can think of the surfaces x-axis running along 7,8, and 9. The y would run along 7,4, and 1. To make things simple, we'll say that the detail bias will be 0.25, which we know will generate 5 points along a spline ((1/deatil bias) + 1), but since this is a surface, it will generate 5*5 points, which is 25 points in total. It's nice to think of these points in terms of x and y, so our data structure to hold these data points will be an array that looks like this:

C_POINT points[5][5];

We will also be deriving other control points as we go along, from points on other splines. I'll walk you now, step by step, the process of generating points from this surface. This is probably the most confusing part of this article, and you don't need to know this to get the basic Bézier spline working. It should be noted that when I say evaluate a spline, I mean take it's control points and create points with our equations and our detail bias, which is always 0.25. Ok here we go.

1. Use points 1,4, and 7 and evaluate them.
2. Derive 3 new control points by evaluating and taking the first point generated by spline 7,8,9, this will be our first control point, we'll call it f1. Do the same with 4,5,6, which will be f2, and 1,2,3 will be f3.
3. Evaluate spline f1, f2, and f3, and generate points from this spline.
4. Do the same as 2, except f1, f2, and f3 will now be the second point generated by 7-8-9, 4-5-6, and 1-2-3 respectfully.
5. Do steps three and four over and over (just make sure that instead of the second point, it's the third, then the fourth etc.) until you fill up our array.
   
   

I hope that this article gave you a good understanding of what bézier splines are and how you can use them in your games and demos. I also hope that I took out some of the mystery of what these things can do for you. Before I go, I would like to leave you with a few pro's and con's about Bézier splines and curved surfaces.

곡면은 랜더링되는 폴리곤의 양을 줄이기위해 LOD 기술을 사용하는 엔진의 훌륭한 애드온이 될 수 있습니다. It's easy to bump these surfaces down to only 4 polygons (for quadratics), and you can do this quite easily (by changing the detail bias). It's also easier to make smooth surfaces, and more organic looking environments with curved surfaces. 또한 움직이는 카메라 기능을 지원할 계획이라면, 베지어 곡선은 카메라 경로, 애니메이션 경로를 부드럽게 만드는데 필수적인 요소입니다.

곡면을 사용하는 대부분의 엔진들이 고통받는 단 한가지 핵심 단점은 tesselate작업(폴리곤으로 변환하기)을 하는데 시간이 오래걸린다는 점입니다. 이것은 로딩때 처리한다면 크게 차이를 느낄 수 없겠지만, 프레임당 실시간으로 이 처리를 수행하면 아마도 엄청난 성능상의 부하라는 것을 알 수 있을 겁니다. That's about the only major beef that most engine developers have with curved surfaces.