varying vec3 lightDir,normal;
uniform sampler2D tex,l3d;

void main()
{
    vec3 ct,cf;
    vec4 texel;
    float intensity,at,af;
		
    intensity = max(dot(lightDir,normalize(normal)),0.0);
	
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
         gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
	
    texel = texture2D(tex,gl_TexCoord[0].st)+
            texture2D(l3d,gl_TexCoord[0].st);

    ct = texel.rgb;
    at = texel.a;
	
    gl_FragColor = vec4(ct * cf, at * af);	
}

genType smoothStep(genType edge0, genType edge1, genType x);

coef = smoothStep(1.0, 0.2, intensity);

varying vec3 lightDir,normal;
uniform sampler2D tex,l3d;

void main()
{
    vec3 ct,cf,c;
    vec4 texel;
    float intensity,at,af,a;
	
    intensity = max(dot(lightDir,normalize(normal)),0.0);
	
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
             gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
	
    texel = texture2D(tex,gl_TexCoord[0].st);
		
    ct = texel.rgb;
    at = texel.a;
	
    c = cf * ct;
    a = af * at;
		
    float coef = smoothstep(1.0,0.2,intensity);
    c += coef *  vec3(texture2D(l3d,gl_TexCoord[0].st));
	
    gl_FragColor = vec4(c, a);	
}

GL_REPLACE      C = Ct                           A = At 
GL_MODULATE     C = Ct*Cf                        A = At*Af 
GL_DECAL        C = Cf * (1 - At) + Ct * At      A = Af

varying vec3 lightDir,normal;
	
void main()
{
    normal = normalize(gl_NormalMatrix * gl_Normal);
    lightDir = normalize(vec3(gl_LightSource[0].position));
		
    gl_TexCoord[0] = gl_MultiTexCoord0;
    gl_Position = ftransform();
}

varying vec3 lightDir,normal;
uniform sampler2D tex;
	
void main()
{
    vec3 ct,cf;
    vec4 texel;
    float intensity,at,af;
		
    intensity = max(dot(lightDir,normalize(normal)),0.0);
		
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
              gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
		
    texel = texture2D(tex,gl_TexCoord[0].st);
    ct = texel.rgb;
    at = texel.a;
		
    gl_FragColor = vec4(ct * cf, at * af);	
}

attribute vec4 gl_MultiTexCoord0;
attribute vec4 gl_MultiTexCoord1;
attribute vec4 gl_MultiTexCoord2;
attribute vec4 gl_MultiTexCoord3;
attribute vec4 gl_MultiTexCoord4;
attribute vec4 gl_MultiTexCoord5;
attribute vec4 gl_MultiTexCoord6;
attribute vec4 gl_MultiTexCoord7;

uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];

void main() {
    gl_TexCoord[0] = gl_MultiTexCoord0;
    gl_Position = ftransform();
}

void main() {
    gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
    gl_Position = ftransform();
}

uniform sampler2D tex;

vec4 texture2D(sampler2D, vec2);

uniform sampler2D tex;
	
void main()
{
    vec4 color = texture2D(tex,gl_TexCoord[0].st);
    gl_FragColor = color;
}

• Spot Light는 방향을 가지고 있으며(spotDirection) 이 방향은 Spot Light의 Cone의 축이다.
• Cone의 각도가 있다. GLSL은 어플리케이션에서 지정되어진 것으로써와 spotCosCutoff라는 cosine 변수로써, 이둘 모두를 제공한다.
• 마지막으로 감쇄 비율이 있다(spotExponent). 예를들어서, 빛의 강도가 Cone의 원 모양의 밑바닥의 중심점으로부터 어떤식으로 감소하는지를 측정하는 것이다.

    ...

    n = normalize(normal);

    /* compute the dot product between normal and ldir */
    NdotL = max(dot(n,normalize(lightDir)),0.0);

    if (NdotL > 0.0) {
        spotEffect = dot(normalize(gl_LightSource[0].spotDirection), 
                         normalize(-lightDir));
        if (spotEffect > gl_LightSource[0].spotCosCutoff) {
	
            /* compute the illumination in here */

        }
    }
	
gl_FragColor = ...

spotEffect = pow(spotEffect, gl_LightSource[0].spotExponent);
att = spotEffect / (gl_LightSource[0].constantAttenuation +
      gl_LightSource[0].linearAttenuation * dist +
      gl_LightSource[0].quadraticAttenuation * dist * dist);

color += att * (diffuse * NdotL + ambient);

halfV = normalize(halfVector);
NdotHV = max(dot(n,halfV),0.0);
color += att * gl_FrontMaterial.specular * 
         gl_LightSource[0].specular * 
         pow(NdotHV,gl_FrontMaterial.shininess);

• 광원의 위치 필드중 w 요소 : Directional Light에서는 이 값은 0이지만 Point Light에서는 1이다.
• 빛의 감쇄는 세개의 계수에 기반한다 : 상수항, 1차항, 2차항

varying vec4 diffuse,ambientGlobal,ambient;
varying vec3 normal,lightDir,halfVector;
varying float dist;
	
void main()
{	
    vec4 ecPos;
    vec3 aux;
		
    normal = normalize(gl_NormalMatrix * gl_Normal);
		
    /* these are the new lines of code to compute the light's direction */
    ecPos = gl_ModelViewMatrix * gl_Vertex;
    aux = vec3(gl_LightSource[0].position-ecPos);
    lightDir = normalize(aux);
    dist = length(aux);
	
    halfVector = normalize(gl_LightSource[0].halfVector.xyz);
		
    /* Compute the diffuse, ambient and globalAmbient terms */
    diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
		
    /* The ambient terms have been separated since one of them */
    /* suffers attenuation */
    ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
    ambientGlobal = gl_LightModel.ambient * gl_FrontMaterial.ambient;
	
    gl_Position = ftransform();
}

varying vec4 diffuse,ambientGlobal, ambient;
varying vec3 normal,lightDir,halfVector;
varying float dist;	
	
void main()
{
    vec3 n,halfV,viewV,ldir;
    float NdotL,NdotHV;
    vec4 color = ambientGlobal;
    float att;

    /* a fragment shader can't write a varying variable, hence we need
       a new variable to store the normalized interpolated normal */
    n = normalize(normal);

    /* compute the dot product between normal and normalized lightdir */
    NdotL = max(dot(n,normalize(lightDir)),0.0);
	
    if (NdotL > 0.0) {
        att = 1.0 / (gl_LightSource[0].constantAttenuation +
              gl_LightSource[0].linearAttenuation * dist +
              gl_LightSource[0].quadraticAttenuation * dist * dist);
        color += att * (diffuse * NdotL + ambient);
		
        halfV = normalize(halfVector);
        NdotHV = max(dot(n,halfV),0.0);
        color += att * gl_FrontMaterial.specular * 
                 gl_LightSource[0].specular * 
                 pow(NdotHV,gl_FrontMaterial.shininess);
    }

    gl_FragColor = color;
}

• 법선벡터
• Half 벡터
• 빛의 방향

varying vec4 diffuse,ambient;
varying vec3 normal,lightDir,halfVector;
	
void main()
{	
    /* first transform the normal into eye space and 
    normalize the result */
    normal = normalize(gl_NormalMatrix * gl_Normal);
		
    /* now normalize the light's direction. Note that 
       according to the OpenGL specification, the light 
       is stored in eye space. Also since we're talking about 
       a directional light, the position field is actually direction */
    lightDir = normalize(vec3(gl_LightSource[0].position));
	
    /* Normalize the halfVector to pass it to the fragment shader */
    halfVector = normalize(gl_LightSource[0].halfVector.xyz);
					
    /* Compute the diffuse, ambient and globalAmbient terms */
    diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
    ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
    ambient += gl_LightModel.ambient * gl_FrontMaterial.ambient;
	
    gl_Position = ftransform();
}

varying vec4 diffuse,ambient;
varying vec3 normal,lightDir,halfVector;

void main()
{
    vec3 n,halfV;
    float NdotL,NdotHV;
		
    /* The ambient term will always be present */
    vec4 color = ambient;
		
    /* a fragment shader can't write a varying variable, hence we need
       a new variable to store the normalized interpolated normal */
    n = normalize(normal);
		
    /* compute the dot product between normal and ldir */
    NdotL = max(dot(n,lightDir),0.0);
	
    ....
}

    ....

    if (NdotL > 0.0) {
        color += diffuse * NdotL;
        halfV = normalize(halfVector);
        NdotHV = max(dot(n,halfV),0.0);
        color += gl_FrontMaterial.specular * 
        gl_LightSource[0].specular * 
        pow(NdotHV, gl_FrontMaterial.shininess);
    }
	
    gl_FragColor = color;
}

/* compute the specular term if NdotL is larger than zero */
if (NdotL > 0.0) {
    // normalize the half-vector, and then compute the 
    // cosine (dot product) with the normal
    NdotHV = max(dot(normal, gl_LightSource[0].halfVector.xyz),0.0);
    specular = gl_FrontMaterial.specular * gl_LightSource[0].specular * 
        pow(NdotHV,gl_FrontMaterial.shininess);
}

void main() {
    vec3 normal, lightDir;
    vec4 diffuse;
    float NdotL;

    /* 먼저 법선벡터를 Eye 공간좌표계로 변환하고 정규화한다 */
    normal = normalize(gl_NormalMatrix * gl_Normal);
		
    /* 이제 빛의 방향 벡터를 정규화한다. OpenGL의 소펙을 보면, 빛은 Eye 공간좌표계이다.
    또한 우리가 지금 Directional Light에 대해 이야기하고 있으므로, 빛의 위치 필드는
     실제 빛의 방향이다. */
    lightDir = normalize(vec3(gl_LightSource[0].position));

    /* 법선벡터와 빛의 방향 사이의 각도에 대한 Cos 값을 계산한다. 빛은 Directional이므로
     모든 좌표에 대해서 빛의 방향은 일정하다. 이 두벡터는 정규화되었으므로 내적을 구하면된다.
    결과는 0~1 범위 사이로 맞춘다. */
    NdotL = max(dot(normal, lightDir), 0.0);

    /* Diffuse를 계산한다. */
    diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
		
    gl_FrontColor =  NdotL * diffuse;
		
    gl_Position = ftransform();
}

void main()
{
    gl_FragColor = gl_Color;
}

void main()
{
    vec3 normal, lightDir;
    vec4 diffuse, ambient, globalAmbient;
    float NdotL;
		
    normal = normalize(gl_NormalMatrix * gl_Normal);
    lightDir = normalize(vec3(gl_LightSource[0].position));
    NdotL = max(dot(normal, lightDir), 0.0);
    diffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
		
    /* Compute the ambient and globalAmbient terms */
    ambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
    globalAmbient = gl_LightModel.ambient * gl_FrontMaterial.ambient;
		
    gl_FrontColor =  NdotL * diffuse + globalAmbient + ambient;
		
    gl_Position = ftransform();
}

struct gl_LightSourceParameters {
    vec4 ambient;
    vec4 diffuse;
    vec4 specular;
    vec4 position;
    vec4 halfVector;
    vec3 spotDirection;
    float spotExponent;
    float spotCutoff; // (range: [0.0, 90.0], 180.0)
    float spotCosCutoff; // (range: [1.0, 0.0], -1.0)
    float constantAttenuation;
    float linearAttenuation;
    float quadraticAttenuation;
};

uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];

struct gl_LightModelParameters {
    vec4 ambient;
};

uniform gl_LightModelParameters gl_LightModel;

struct gl_MaterialParameters {
    vec4 emission;
    vec4 ambient;
    vec4 diffuse;
    vec4 specular;
    float shiness;
};

uniform gl_MaterialParameters gl_FrontMaterial;
uniform gl_MaterialParameters gl_BackMaterial;

GLSL 예제 - 툰쉐이딩 마지막 장.. (4/4)
원본 : http://www.lighthouse3d.com/opengl/glsl/index.php?toon3

툰쉐이딩을 끝내기 전에 한가지 더 살펴보자 : lightDir 변수를 사용하는 대신에 OpenGL 빛을 사용한 것. OpenGL에서 빛을 하나 정의하고 이 빛의 방향을 쉐이더에서 사용하는 방법이다. 주의: glEnable을 사용해서 빛을 활성화할 필요가 없는데, OpenGL에서 이 빛을 실제로 사용하지는 않을 것이기 때문이다.

우리는 OpenGL에서 첫번째 빛(GL_LIGHT0)이 Directional 빛이라고 가정하겠다.

GLSL은 OpenGL 상태의 일부에 접근할 수 있는데, 바로 빛과 같은 속성에 접근할 수 있다. GLSL은 빛의 속성에 대한 C언어 형식의 구조체를 정의하고 있는데 각 빛에 대한 속성을 정의하기 위한 배열로 존재한다.

struct gl_LightSourceParameters {
    vec4 ambient;
    vec4 diffuse;
    vec4 specular;
    vec4 position;
};

uniform gl_LightSourceParamters gl_LightSource[gl_MaxLights];

varying vec3 normal;

void main()
{
    normal = gl_NormalMatrix * gl_Normal;
    gl_Position = ftransform();
}

varying vec3 normal;

void main()
{
    float intensity;
    vec3 color;
    vec3 n = normalize(normal);

    intensity = dot(vec3(gl_LightSource[0].position, n);

    if(intensity > 0.95)
        color = vec4(1.0, 0.5, 0.5, 1.0);
    else if(intensity > 0.5)
        color = vec4(0.6, 0.3, 0.3, 1.0);
    else if(intensity > 0.25)
        color = vec4(0.4, 0.2, 0.2, 1.0);
    else
        color = vec4(0.2, 0.1, 0.1, 1.0);

    gl_FragColor = color;
}

toonglut.zip

GLUT 예제

toonglut_2.0.zip

OpenGL 2.0 예제

varying vec3 normal;

void main()
{
    normal = gl_Normal;
    gl_Position = ftransform();
}

uniform vec3 lightDir;
varying vec3 normal;

void main()
{
    float intensity;
    vec4 color;

    intensity = dot(lightDir, normal);

    if(intensity > 0.95)
        color = vec4(1.0, 0.5, 0.5, 1.0);
    if(intensity > 0.5)
        color = vec4(0.6, 0.3, 0.3, 1.0);
    if(intensity > 0,25)
        color = vec4(0.4, 0.2, 0.2, 1.0);
    else
        color = vec4(0.2, 0.1, 0.1, 1.0);

    gl_FragColor = color;
}

uniform vec3 lightDir;
varying vec3 normal;
	
void main()
{
	float intensity;
	vec4 color;

	intensity = dot(lightDir, normalize(normal));
		
	if (intensity > 0.95)
		color = vec4(1.0,0.5,0.5,1.0);
	else if (intensity > 0.5)
		color = vec4(0.6,0.3,0.3,1.0);
	else if (intensity > 0.25)
		color = vec4(0.4,0.2,0.2,1.0);
	else
		color = vec4(0.2,0.1,0.1,1.0);
	
	gl_FragColor = color;
}

GLSL 예제 - 툰 쉐이딩(Toon Shading) - 2장(총4장)
원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?toon1

이 장에서 보일 첫번째 툰 쉐이딩은 버텍스에 대한 명도를 계산한다. 다음으로 프레그먼트 쉐이더는 프레그먼트에 대한 톤을 계산하기 위해 버텍스에 대한 보간된 명도를 사용한다. 그래서 버텍스 쉐이더는 반드시 명도를 저장하는 변수를 Varying으로 선언해야 한다. 프레그먼트 쉐이더는 같은 변수를 선언해야하며 Varying 지정자를 사용하여 버텍스 쉐이더에서 계산된 명도값을 받을 수 있다.

빛의 방향은 지역변수나 상수로써 버텍스 쉐이더 안에 정의될 수 있다. 그러나 Uniform 변수로써 정의되면 융통성이 좋은데, OpenGL 어플리케이션에서 자유롭게 설정할 수 있기 때문이다. 빛의 방향에 대한 변수는 다음과 같이 쉐이더 안에서 정의된다.

uniform vec3 lightDir;

cos(lightDir, normal) = (lightDir dot-product normal) / ( |lightDir| * |normal| )

cos(빛과 법선벡터의 사이각) = lightDir dot-product normal

intensity = dot(lightDir, gl_Normal);

uniform vec3 lightDir;
varying float intensity;

void main()
{
    intensity = dot(lightDir, gl_Normal);

    gl_Position = ftransform();
}

vec4 color;

if(intensity > 0.95)
    color = vec4(1.0, 0.5, 0.5, 1.0);
else if(intensity > 0.5)
    color = vec4(0.6, 0.3, 0.3, 1.0);
else if(intensity > 0.25)
    color = vec4(0.4, 0.2, 0.2, 1.0);
else
    color = vec4(0.2, 0.1, 0.1, 1.0);

varying float intensity;

void main()
{
    vec4 color;

    if(intensity > 0.95)
        color = vec4(1.0, 0.5, 0.5, 1.0);
    else if(intensity > 0.5)
        color = vec4(0.6, 0.3, 0.3, 1.0);
    else if(intensity > 0.25)
        color = vec4(0.2, 0.1, 0.1, 1.0);

    gl_FragColor = color;
}

void main(void)
{
    vec4 v = vec4(gl_Vertex);
    v.z = 0.0;

    gl_Position = gl_ModelViewProjectionMatrix * v;
}

void main(void)
{
    vec4 v = vec4(gl_Vertex);
    v.z = sin(5.0 * v.x) * 0.25;

    gl_Position = gl_ModelViewProjectionMatrix * v;
}

uniform float time;

void main(void)
{
    vec4 v = vec4(gl_Vertex);

    v.z = sin(5.0*v.x + time*0.01)*0.25;

    gl_Position = gl_ModelViewProjectionMatrix * v;
}

• setup : Uniform 변수의 위치를 얻는다.
• render : Uniform 변수를 갱신한다.

setup 부분은 다음 코드와 같다.

loc = glGetUniformLocationARB(p, "time");

void renderScene(void) 
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();
    gluLootAt(0, 0, 5, 0, 0, 0, 0, 1, 0);

    glUniform1fARB(loc, time);

    glutSolidTeaport(1);
    time += 0.1;

    glutSwapBuffers();
}

flatten.zip

ARB Extension

flatten_2.0.zip

OpenGL 2.0

GLSL 예제 : Color Shader
원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?color

GLSL은 OpenGL 상태의 일부분에 접근할 수 있다. 이 섹션에서는 glColor를 사용하는 OpenGL 어플리케이션의 색상에 어떻게 접근하는지를 살펴보겠다.

GLSL은 현재의 색상에 대한  Attribute 변수를 가지고 있다. 또한 버텍스 쉐이더로부터 프레그먼트 쉐이더로 전달되는 색상을 얻기 위한 Varying 변수를 가지고 있다.

attribute vec4 gl_Color;

varying vec4 gl_FrontColor; // 버텍스 쉐이더에서 쓰기 가능
varying vec4 gl_BackColor; // 버텍스 쉐이더에서 쓰기 가능

varying vec4 gl_Color; // 프레그먼트 쉐이더에서 읽기 가능

1. OpenGL 어플리케이션은 glColor 함수를 사용해서 색상값을 보낸다.
2. 버텍스 쉐이더는 gl_Color Attribute 변수로 색상값을 받는다.
3. 버텍스 쉐이더는 앞면과 뒷면의 색상을 계산하고, gl_FrontColor과 gl_BackColor에 저장한다.
4. 프레그먼트 쉐이더는 gl_Color Varying 변수로 보간된 색상을 받는데, 이 색상은 현재의 프리미티브의 방향에 따라 다르다. 예를들어 보간은 gl_FrontColor나 gl_BackColor 값을 사용해서 보간된다.
5. 프레그먼트 쉐이더는 gl_Color 값에 기반해서 gl_FragColor를 설정한다.

void main()
{
    gl_FrontColor = gl_Color;
    gl_Position = ftransform();
}

void main()
{
    gl_FragColor = gl_Color;
}

colorglut.zip

ARB 확장방식

colorglut_2.0.zip

OpenGL 2.0 방식

uniform mat4 gl_ModelViewMatrix;
uniform mat4 gl_ProjectionMatrix;

attribute vec4 gl_Vertex;

void main()
{
    gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
}

void main()
{
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

vec4 ftransform(void);

void main()
{
    gl_Position = ftransform();
}

void main()
{
	gl_FragColor = vec4(0.4, 0.4, 0.8, 1.0);
}

varying float intensity;

제어문
제어문은 C언어와 매우 비슷하다. if-else, for, do-while문과 같은 조건문과 반복문이 있다.

if (bool expression)
    ...
else
    ...

for(initialization; bool expression; loop expression)
    ...

while(bool expression)
    ...

do
    ...
while(bool expression)

• continue - 반복문에서 사용 가능하며, 바로 다음 반복의 단계로 간다.
• break - 반복문에서 사용 가능하며, 반복문을 종료한다.
• discard

void main()

• in - 오직 입력 인자로써 사용됨
• out - 어떤 값을 반환하는 용도로 사용됨. 함수의 결과를 보내기 위한 또 다른 방법
• inout - 입력 및 값 반환의 두가지 용도로 사용됨

1. 함수는 인자를 다르게 해서 오버로드될 수 있다.
2. GLSL 스펙상 재귀호출은 가능하지 않다.

vec4 toonify(in float intensity) {
    vec4 color;

    if(intensity > 0.98)
        color = vec4(0.8, 0.8, 0.8, 1.0);
    else if(intensity > 0.5)
        color = vec4(0.5)
    else if(intensity > 0.25)
        color = vec4(0.2, 0.2, 0.4, 1.0);
    else
        color = vec4(0.1, 0.1, 0.1, 1.0);

    return(color);
}

GLSL에서의 데이터 타입과 변수
원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?data

타입(Type)

GLSL에서 사용가능한 간단한 데이터 타입은 다음과 같다.

• float
• bool
• int

float와 int는 C언어와 동일하며 bool은 true와 false 값을 취한다.

2, 3 또는 4개의 요소를 가지는 벡터 타입이 있으며, 벡터 요소의 타입은 위에서 언급한 것이 될 수 있다. 벡터 타입의 선언은,

• vec{2,3,4} : 2, 3 또는 4개의 요소를 가지는 실수 벡터
• bvec{2,3,4} : 2, 3 또는 4개의 요소를 가지는 블린 벡터
• ivec{2,3,4} : 정수 벡터

그래픽에서 매우 중요한 2x2, 3x3 또는 4x4 행렬 타입이 있으며 아래와 같다.

• mat2
• mat3
• mat4

텍스쳐 접근이 가능하는 특별한 타입들이 있다. 이 타입들은 샘플러(Sampler)라고 불리며, 텍스쳐 값(텍셀;texel)에 접근하는데 사용된다. 이 텍스쳐 샘플링을 위한 데이터 타입은 아래와 같다.

• sampler1D - 1D 텍스쳐을 위한 샘플러
• sampler2D - 2D 텍스쳐를 위한 샘플러
• sampler3D - 3D 텍스쳐를 위한 샘플러
• samplerCube - 큐브맵 텍스쳐를 위한 샘플러
• sampler1DShadow - 그림자맵을 위한 샘플러
• sampler2DShadow - 그림자맵을 위한 샘플러

GLSL에서 배열은 C언어에서처럼 선언할 수 있다. 그러나 배열은 선언할때 초기화할 수가 없다. 배열의 요소에 접근하는 방법은 C언어와 동일하다.

구조체 역시 GLSL에서 가능하며, C언어와 동일하다.

struct dirlight {
	vec3 direction;
	vec3 color;
};

float a, b; // 2개의 실수형 변수(C언어처럼 주석이 가능하다)
int c = 2 // c변수는 2로 초기화되었다
bool d = true; // d는 true 값이다

float b = 2; // 옳지않아~ =_=; GLSL에는 자동형변환이 않되~
float e = (float)2; // 옳지않아~ 형변환 생성자가 필요해~

int a = 2;
float c = float(a); // 옳다! ^^* c는 2.0

vec3 f; // f는 vec3로 선언
vec3 g = vec3(1.0, 2.0, 3.0); // 선언과 동시에 초기화

vec2 a = vec2(1.0, 2.0);
vec2 b = vec2(3.0, 4.0);

vec4 c = vec4(a, b); // c=vec4(1.0, 2.0, 3.0, 4.0)

vec2 g = vec2(1.0, 2.0);
float h = 3.0;
vec3 j = vec3(g, h);

mat4 m = mat4(1.0); // 행렬의 대각요소를 1.0으로 초기화

vec2 a = vec2(1.0, 2.0);
vec2 b = vec2(3.0, 4.0);
mat2 n = mat2(a, b); // 컬럼 방향으로 값이 지정된 행렬

mat2 k = mat2(1.0, 0.0, 1.0, 0.0); // 모든 요소를 지정

struct dirlight { // 타입정의
	vec3 direction;
	vec3 color;
};

dirlight d1;
dirlight d2 = 
	dirlight(vec(1.0, 1.0, 0.0), vec3(0.8, 0.8, 0.4));

vec4 a = vec4(1.0, 2.0, 3.0, 4.0);

float posX = a.x;
float posY = a[1];

vec2 posXY = a.xy;

float depth = a.w;

d1.direction = vec3(1.0, 1.0, 1.0);

GLSL을 위한 OpenGL 설정 - Attribute 변수
원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?oglattribute

이전의 Uniform 변수 섹션에서 언급했듯이,  Uniform 변수는 오직 프리미티브에 의해서만 설정할 수 있다. 즉, Uniform 변수는 glBegin~glEnd 사이에서는 설정할 수 없다.

만약에 프리미티브를 구성하는 버텍스 당위로 변수를 설정하려고 한다면 Attribute 변수를 사용해야만 한다. 사실 Attribute 변수는 아무때나 설정될 수 있다. Attribute 변수는 버텍스 쉐이더에서만 읽힐 수(쓸수는 없다) 있다. 왜냐하면 Attribute 변수는 버텍스 데이터를 가지고 있어서, 프레그먼트 쉐이더에 사용하기는 적당하지 않다. (이 부분에 대해서는 추후에 varying 변수를 살펴보겠다) uniform 변수처럼, 변수에 대한 메모리 주소값을 읽어오는 것이 필요하다. 쉐이더 프로그램은 먼저 링크되어져야하며 몇몇 그래픽 카드는 쉐이더 프로그램이 사용중이여야 변수에 대한 주소값을 읽어올 수 있다.

다음은 OpenGL 2.0에서 Attribute 변수의 메모리 주소를 얻어오는 함수이다.

GLint glGetAttribLocation(GLuint program, char *name);
Parameters:
  program -  쉐이더 프로그램의 핸들
  name - 변수의 이름

ARB 확장 형태는 다음과 같다.

GLint glGetAttribLocationARB(GLhandleARB program, char *name);
Parameters:
  program - 쉐이더 프로그램의 핸들
  name - 변수의 이름

메모리의 변수 위치는 위의 함수의 리턴값으로 알수있다. 다음 단계는 값을 지정하는 것인데, uniform 변수처럼, 각 데이터 타입에 대한 함수가 있다.

OpenGL 2.0 문법은 아래와 같다.

void glVertexAttrib1f(GLint location, GLfloat v0);
void glVertexAttrib2f(GLint location, GLfloat v0, GLfloat v1);
void glVertexAttrib3f(GLint location, GLfloat v0, GLfloat v2);
void glVertexAttrib4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

또는...

GLint glVertexAttrib{1,2,3,4}fv(GLint location, GLfloat *v);

Parameter:
  location -  이전에 질의해서 얻은 변수의 메모리 위치
  v0, v1, v2, v3 - 실수값
  v - 실수 배열

ARB 확장에 대한 문법은 아래와 같다.

void glVertexAttrib1fARB(GLint location, GLfloat v0);
void glVertexAttrib2fARB(GLint location, GLfloat v0, GLfloat v1);
void glVertexAttrib3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
void glVertexAttrib4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

또는...

GLint glVertexAttrib{1,2,3,4}fvARB(GLint location, GLfloat *v);

Parameter:
  location - 이전에 질의한 변수의 위치
  v0, v1, v2, v3 - 실수 변수
  v - 실수 배열

정수와 몇몇 다른 데이터 타입에 대한 유사한 함수군이 제공되어진다. uniform 변수의 경우에서처럼 벡터 버전에 대한 설정 함수는 제공되지 않는다. 벡터에 대한 경우는 하나의 Attribute 변수의 값으로 지정할 수 있는데, 이것은 OpenGL에서 glColor3f와 glColor3fv 함수의 예와 비슷하다.

아래 간단한 예를 살펴보자. 이 예는 버텍스 쉐이더가 실수형 Attribute 변수로써 "height" 이름으로 선언된 경우이다. 쉐이더 프로그램이 링크된 후에 의미가 있는 예라는 점을 염두해 두길 바란다.

loc = glGetAttribLocation(p, "height");

glBegin(GL_TRIANGLE_STRIP);
    glVertexAttrib1f(loc,2.0);
    glVertex2f(-1,1);

    glVertexAttrib1f(loc,2.0);
    glVertex2f(1,1);

    glVertexAttrib1f(loc,-2.0);
    glVertex2f(-1,-1);

    glVertexAttrib1f(loc,-2.0);
    glVertex2f(1,-1);
glEnd();

glutglsl3.zip

ARB 확장에 대한 샘플

glutglsl3_2.0.zip

OpenGL 2.0에 대한 샘플

float vertices[8] = {-1,1, 1,1, -1,-1, 1,-1};
float heights[4] = {2,2,-2,-2};
	
...
	
loc = glGetAttribLocationARB(p,"height");

glEnableClientState(GL_VERTEX_ARRAY);
glEnableVertexAttribArrayARB(loc);

glVertexPointer(2,GL_FLOAT,0,vertices);
glVertexAttribPointerARB(loc,1,GL_FLOAT,0,0,heights);

glutglsl4.zip

ARB 확장의 경우

glutglsl4_2.0.zip

OpenGL 2.0의 경우

GLSL을 위한 OpenGL 설정 - Uniform 변수
원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?ogluniform

Uniform 변수는 오로지 Primitive에 의해 변경될 수 있는 변수인데, glBegin과 glEnd 사이에서는 변경될 수 없다. 이러한 이유로해서 버텍스의 속성을 위해서는 사용될 수 없다. 만약 버텍스의 속성에 대한 변수를 원한다면, 이 섹선 바로 다음 섹션인 Attribute 변수를 보면된다. Uniform 변수는 Primitive나 프레임 또는 전체 장면 동안에 유지해야할 변수에 적당하다. Uniform 변수는 버텍스 쉐이더나 프레그먼트 쉐이더에서 읽을 수 있지만 쓸수는 없다.

Uniform 변수를 정의하는 가장 먼저 해야할 일은 변수에 대한 메모리 위치를 얻는 것이다. 쉐이더 프로그램이 링크된 후에야 변수에 대한 메모리 정보를 얻어오는 것이 가능하다는 점에 주의하기 바란다. 몇몇의 그래픽 카드 드라이버에서는 메모리의 위치를 얻어오기 위해 먼저 glUseProgram(OpenGL 2.0) 또는 glUseProgramObjectARB(ARB 확장)을 호출해야할 경우도 있다는 점을 주의하자.

변수를 처리할때 OpenGL 2.0과 ARB 확장은 매우 유사한 문법을 가지고 있다. 기본적으로 OpenGL 2.0 함수의 뒤에 ARB를 붙이면 ARB 확장 함수가 되는 경우가 많다.

다음 OpenGL 2.0형태의 함수는 주어진 이름에 대한 Uniform 변수(쉐이더 안에서 정의)의 위치를 얻어온다.

GLint glGetUniformLocation(GLuint program, const char *name);
Parameters:
  program - 프로그램의 핸들
  name - 변수의 이름

ARB 확장의 형태는 다음과 같다.

GLint glGetUniformLocationARB(GLhandleARB program, const char *name);
Parameters:
  program - 프로그램의 핸들
  name - 변수의 이름

반환값이 바로 변수의 위치인데, 이 변수에 값을 할당할 수 있다. Uniform 변수에 값을 할당하는 함수군은 다음과 같다.

void glUniform1f(GLint location, GLfloat v0);
void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

또는

GLint glUnform{1,2,3,4}fv(GLint location, GLsizei count, GLfloat *v);

Parameters:
  location - 이전에 구한 변수의 위치
  v0, v1, v2, v3 - 실수값
  count - 배열에서 요소의 수
  v - 실수 배열

ARB 확장의 경우는 다음과 같다.

void glUniform1fARB(GLint location, GLfloat v0);
void glUniform2fARB(GLint location, GLfloat v0, GLfloat v1);
void glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
void glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

또는

GLint glUnform{1,2,3,4}fvARB(GLint location, GLsizei count, GLfloat *v);

Parameters:
  location - 이전에 구한 변수의 위치
  v0, v1, v2, v3 - 실수값
  count - 배열에서 요소의 수
  v - 실수 배열

위의 함수는 실수타입의 경우이고 정수타입도 가능한데,  "f"를 "i"로 바꾸기만하면된다. 하지만  boolean 타입에 대한 함수는 없다. Boolean에 대한 경우가 필요하다면 실수나 정수형 함수에 대해서 false의 경우 0으로 할당하여 사용하면 된다. uniform 변수의 배열을 가질 경우, 벡터로 사용될 수 있다.

sampler 변수에 대해서는 OpenGL 2.0에서는 sampler의 배열을 설정하여 glUniform1i나 glUniform1iv를 사용할 수 있으며 ARB 확장의 경우 glUniform1iARB나 glUniform1ivARB를 사용하면 된다.

GLSL에서 매트릭스 데이터 타입도 사용이 가능하며 이 타입에 대한 함수는 다음과 같다.

GLint glUniformMatrix{2,3,4}fv(GLint location, GLsizei count, GLboolean transpose, GLfloat *v);
Parameters:
  location - 이전에 질의한 위치
  count - 행렬의 개수. 단일 매트릭스라면 1이고 n 매트릭스 배열이라면 n
  transpose - 전치 행렬인지 여부이며 1인 경우 Row 방향으로 배열된 행렬이며 0인 경우 Column 방향으로 정렬된 행렬을 의미함
  v - 실수 배열

ARB 확장의 경우는 아래와 같다.

GLint glUniformMatrix{2,3,4}fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat *v);
Parameters:
  location - 이전에 질의한 위치
  count - 행렬의 개수. 단일 매트릭스라면 1이고 n 매트릭스 배열이라면 n
  transpose - 전치 행렬인지 여부이며 1인 경우 Row 방향으로 배열된 행렬이며 0인 경우 Column 방향으로 정렬된 행렬을 의미함
  v - 실수 배열

주의할 것은 위의 함수들을 통해 설정된 Uniform 변수의 값들은 쉐이더 프로그램이 다시 링크될동안 유지된다. 일단 새로운 링크 처리가 수행되면 이 값들은 모두 0으로 재설정된다.

간단한 소스코드를 살펴보자.  만약 다음과 같은 변수를 사용하는 쉐이더가 있다고 해보자.

uniform float specIntensity;
uniform vec4 specColor;
uniform float t[2];
uniform vec4 colors[3];

GLint loc1,loc2,loc3,loc4;
float specIntensity = 0.98;
float sc[4] = {0.8,0.8,0.8,1.0};
float threshold[2] = {0.5,0.25};
float colors[12] = {0.4,0.4,0.8,1.0,
                    0.2,0.2,0.4,1.0,
                    0.1,0.1,0.1,1.0};

loc1 = glGetUniformLocation(p,"specIntensity");
glUniform1f(loc1,specIntensity);

loc2 = glGetUniformLocation(p,"specColor");
glUniform4fv(loc2,1,sc);

loc3 = glGetUniformLocation(p,"t");
glUniform1fv(loc3,2,threshold);

loc4 = glGetUniformLocation(p,"colors");
glUniform4fv(loc4,3,colors);

GLint loc1,loc2,loc3,loc4;
float specIntensity = 0.98;
float sc[4] = {0.8,0.8,0.8,1.0};
float threshold[2] = {0.5,0.25};
float colors[12] = {0.4,0.4,0.8,1.0,
                    0.2,0.2,0.4,1.0,
                    0.1,0.1,0.1,1.0};

loc1 = glGetUniformLocationARB(p,"specIntensity");
glUniform1fARB(loc1,specIntensity);

loc2 = glGetUniformLocationARB(p,"specColor");
glUniform4fvARB(loc2,1,sc);

loc3 = glGetUniformLocationARB(p,"t");
glUniform1fvARB(loc3,2,threshold);

loc4 = glGetUniformLocationARB(p,"colors");
glUniform4fvARB(loc4,3,colors);

glutglsl2_2.0.zip

OpenGL 2.0

glutglsl2.zip

ARB 확장

loc2 = glGetUniformLocation(p,"specColor");
glUniform4f(loc2,sc[0],sc[1],sc[2],sc[3]);

loct0 = glGetUniformLocation(p,"t[0]");
glUniform1f(loct0,threshold[0]);

loct1 = glGetUniformLocation(p,"t[1]");
glUniform1f(loct1,threshold[1]);

• Uniform
• Attribute

void printShaderInfoLog(GLuint obj)
{
  int infologLength = 0;
  int charsWritten  = 0;
  char *infoLog;

  glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infologLength);

  if (infologLength > 0)
  {
       infoLog = (char *)malloc(infologLength);
       glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
       printf("%s\n",infoLog);
       free(infoLog);
  }
}

void printProgramInfoLog(GLuint obj)
{
  int infologLength = 0;
  int charsWritten  = 0;
  char *infoLog;

  glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);

  if (infologLength > 0)
  {
       infoLog = (char *)malloc(infologLength);
glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
       printf("%s\n",infoLog);
       free(infoLog);
  }
}

void printInfoLog(GLhandleARB obj)
{
    int infologLength = 0;
    int charsWritten = 0;
    char *infoLog;

    glGetObjectParameterivARB(obj, 
        GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);

    if(infologLength > 0)
    {
        info = (char *)malloc(infologLength);
        glGetInfoLogARB(obj,infologLength, &charsWritten, infoLog);
        printf("%s\n", infoLog);
        free(infoLog);
    }
}

void setShaders() {
    char *vs,*fs;
	
    v = glCreateShader(GL_VERTEX_SHADER);
    f = glCreateShader(GL_FRAGMENT_SHADER);	
	
    vs = textFileRead("toon.vert");
    fs = textFileRead("toon.frag");
	
    const char * vv = vs;
    const char * ff = fs;
	
    glShaderSource(v, 1, &vv, NULL);
    glShaderSource(f, 1, &ff, NULL);
	
    free(vs);
    free(fs);
	
    glCompileShader(v);
    glCompileShader(f);
	
    p = glCreateProgram();
		
    glAttachShader(p,v);
    glAttachShader(p,f);
	
    glLinkProgram(p);
    glUseProgram(p);
}

void setShaders() {
    char *vs,*fs;
	
    v = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    f = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);	
	
    vs = textFileRead("toon.vert");
    fs = textFileRead("toon.frag");
	
    const char * vv = vs;
    const char * ff = fs;
	
    glShaderSourceARB(v, 1, &vv,NULL);
    glShaderSourceARB(f, 1, &ff,NULL);
	
    free(vs);
    free(fs);
	
    glCompileShaderARB(v);
    glCompileShaderARB(f);
	
    p = glCreateProgramObjectARB();
		
    glAttachObjectARB(p,v);
    glAttachObjectARB(p,f);
	
    glLinkProgramARB(p);
    glUseProgramObjectARB(p);
}

glutglsl.zip

glutglsl_2.0.zip

• GL_ARB_fragment_shader
• GL_ARG vertex_shader

#include <GL/glew.h>
#include <GL/glut.h>
	
void main(int argc, char **argv) {
    glutInit(&argc, argv);
		
    ...
	
    glewInit();
    if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
        printf("Ready for GLSL\n");
    else {
        printf("Not totally ready :( \n");
        exit(1);
    }
	
    setShaders();
	
    glutMainLoop();
}

#include <GL/glew.h>
#include <GL/glut.h>

void main(int argc, char **argv) {

    glutInit(&argc, argv);
		
    ...
	
    glewInit();
    if (glewIsSupported("GL_VERSION_2_0"))
        printf("Ready for OpenGL 2.0\n");
    else {
        printf("OpenGL 2.0 not supported\n");
        exit(1);
    }

    setShaders();
	
    glutMainLoop();
}

• 색상 및 픽셀에 대한 텍스쳐 좌표 계산
• 텍스쳐 적용
• 안개 계산
• 픽셀에 대한 조명이 필요할 경우에 노멀 계산

• 프레그먼트를 무시하므로 출력은 없음
• 여러개의 메시를 렌더링할때 gl_FragColor(프레그먼트의 최종 색상)이나 gl_FragData 둘중에 하나를 계산

glBegin(...);
    glColor3f(0.2,0.4,0.6);
    glVertex3f(-1.0,1.0,2.0);

    glColor3f(0.2,0.4,0.8);
    glVertex3f(1.0,-1.0,2.0);
glEnd();

• 모델뷰 행렬과 프로젝션 행렬을 이용해서 버텍스의 위치를 이동
• 노말 벡터의 변환, 그리고 필요하다면 노말 벡터의 정규화
• 텍스쳐 좌표 생성과 변환
• 버텍스에 대한 빛 또는 픽셀에 대한 빛 계산
• 색상 계산