OpenGL - Tessellation Shader 【转】

http://blog.sina.com.cn/s/blog_8c7d49f20102v4qm.html

Patch is just an ordered list of vertices (在tessellation shader里面比较重要的概念就是这个patch，patch是一系列的顶点，OpenGL规定patch的vertex数量必须至少大于等于3)

The tessellation process doesn’t operate on OpenGL’s classic geometric primitives: points, lines, and triangles, but uses a new primitive called a patch （Tessellation shader就是针对patch来进行处理的而并非点，县，三角形）

Patch – are processed by all of active shading stage in the pipeline （patch可被所有的shader处理）

Two shading stages of Tessellation shading:
1. Tessellation Control Shader (optional)

In tessellation control shader, gl_PatchVerticesIn provides the number of elements in gl_in （gl_in 用于在tessellation control shader里面访问传进的来patch里面的顶点）

gl_out 用于控制patch里面的vertex从tessellation control shader输出后的属性

gl_InvocationID is used to access the specific vertex of a patch (gl_InvocationID 用于访问传入patch里的特定顶点)

Layout (vertices = *) out; （用于指定输出的patch里面有多少个顶点）

gl_TessLevelInner

Specify how the interior of the domain is subdivided and stored in
a two element array named gl_TessLevelInner（指定多边形内部如何细分）

gl_TessLevelOuter：

Control how the perimeter of the domain is subdivided, and is
stored in an implicitly declared four-element array named
gl_TessLevelOuter（指定多边形边界上的边被如何细分）

gl_TessLevelInner & gl_TessLevelOuter
根据多边形内部区域的类型会有不同的分割法

Tessellation Evaluation Shader (optional)

The TES is executed on all
generated domain
locations.Positions each of the
vertices in the final mesh （TES是针对从tessellation control shader
里面通过细分生成的顶点来进行运算，通过gl_in和gl_VocationID来访问我们传入的patch的一系列顶点信息，结合gl_TessCoord访问我们生成的新顶点的纹理信息来计算新的坐标位置，从而实现细分多边形的效果）

layout (quads, equal_spacing, ccw) in;
（指定新生成的多边形类型等信息）

glPatchParameteri() -- 告诉程序我们定义多少个顶点为一个patch

barrier() – .....
If you have additional per-vertex attribute values, either for
input or output, these need to be declared as either in or out
arrays in your tessellation control shader （需要传入TCS额外的顶点信息，需要定义额外in
& out array）

glPatchParameterfv() -- can be used to set the inner and
outer-tessellation levels（可以用于指定inner和outer的数值，当然我们也可以在tessellation
control shader里面通过gl_TessLevelInner &
gl_TessLevelOuter直接指定）

三中不同类型的domain -- 会决定我们inner和outer的具体含义：

Quad Tessellation:

…..

Isoline Tessellation:

Use only two of the outer-tessellation levels to determine the
amount of subdivision

…..

Triangle Tessellation:

Triangular domains use barycentric coordinates to specify their
Tessellation coordinates

…..

最终渲染效果：

- Tessellation Shader" title="OpenGL - Tessellation Shader" height="291" width="452">

- Tessellation Shader" title="OpenGL - Tessellation Shader" height="318" width="448">

- Tessellation Shader" title="OpenGL - Tessellation Shader" height="291" width="455">

- Tessellation Shader" title="OpenGL - Tessellation Shader" height="298" width="444">

Main.cpp Source Code below:

#include

#include

#include

// TODO: 在此处引用程序需要的其他头文件

#include

#include "vgl.h"

#include "mat.h"

#include "LoadShaders.h"

#include "Shapes/Teapot.h"

using namespace std;

GLuint PM; // Projection
matrix

GLuint
MVM;
// Model view matrix

GLuint InnerL; // Inner
tessellation paramter

GLuint OuterL; // Outer
tessellation paramter

GLfloat Inner = 1.0;

GLfloat Outer = 1.0;

#define SQUARE_VERTEX_NUMBER 4

//----------------------------------------------------------------------------

void init( void )

{

//create
shader and link program first

ShaderInfo
shaders[] = {

{
GL_VERTEX_SHADER,
"square.vert" },

{
GL_TESS_CONTROL_SHADER,
"square.cont" },

{
GL_TESS_EVALUATION_SHADER, "square.eval" },

{
GL_FRAGMENT_SHADER,
"square.frag" },

{ GL_NONE,
NULL }

};

//Shader
program

GLuint
program;

//load
shaders

program =
LoadShaders(shaders);

//link
shader program and use it

glUseProgram(program);

//vertex
array

GLuint
VA;

glGenVertexArrays(1, &VA);

glBindVertexArray(VA);

//Vertex
buffer

GLuint
VB;

glGenBuffers(1, &VB);

glBindBuffer(GL_ARRAY_BUFFER, VB);

//define
square vertex data

const
GLfloat square_vertex_data[SQUARE_VERTEX_NUMBER][2] = {

{ 1.0, 1.0
},

{ -1.0,
1.0},

{ -1.0,
-1.0},

{ 1.0,
-1.0}

};

//vertex
buffer data

glBufferData(GL_ARRAY_BUFFER, sizeof(square_vertex_data),
square_vertex_data, GL_STATIC_DRAW);

//Obtain
vertex position in program

GLint
vPostionIndex = glGetAttribLocation(program, "vPosition");

//Enable
vertex attribute

glEnableVertexAttribArray( vPostionIndex );

//define an
array of generic vertex attribute data for shader
（让shader知道怎么去读取我们传入的vertex 信息）

glVertexAttribPointer(vPostionIndex, 2, GL_FLOAT, GL_FALSE, 0,
BUFFER_OFFSET(0));

//Obtain
uniform variable of program

PM =
glGetUniformLocation(program, "PJ");

MVM =
glGetUniformLocation(program, "MV");

InnerL =
glGetUniformLocation(program, "inner");

OuterL =
glGetUniformLocation(program, "outer");

//Set some
default value for uniform variable

glUniform1f(InnerL, Inner);

glUniform1f(OuterL, Outer);

mat4 modelview = Translate( 0.0, 0.0, -2.0 )
* RotateX(
-50.0 );

glUniformMatrix4fv( MVM, 1, GL_TRUE, modelview );

//Define how
many vertices composed one patch （定义多少个vertices定义一个patch）

glPatchParameteri(GL_PATCH_VERTICES, 4);

//Enable
some relative setting

glEnable(GL_DEPTH_TEST);

glClearColor( 0.0, 0.0, 0.0, 1.0 );

}

//----------------------------------------------------------------------------

void display( void )

{

glClear(
GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

glUniform1f(InnerL, Inner);

glUniform1f(OuterL, Outer);

glDrawArrays(GL_PATCHES, 0, SQUARE_VERTEX_NUMBER);

glutSwapBuffers();

}

//----------------------------------------------------------------------------

void reshape( int width, int height )

{

glViewport(
0, 0, width, height );

GLfloat aspect = GLfloat(width)/height;

mat4 projection = Perspective( 60.0, aspect, 1, 3
);

glUniformMatrix4fv( PM, 1, GL_TRUE, projection );

glutPostRedisplay();

}

//----------------------------------------------------------------------------

void keyboard( unsigned char key, int x, int y )

{

switch ( key
) {

case 'q':
case 'Q': case 033 :

exit(
EXIT_SUCCESS );

break;

case
'i':

Inner--;

if ( Inner
< 1.0 ) Inner = 1.0;

glUniform1f(
InnerL, Inner );

break;

case
'I':

Inner++;

if ( Inner
> 64 ) Inner = 64.0;

glUniform1f(
InnerL, Inner );

break;

case
'o':

Outer--;

if ( Outer
< 1.0 ) Outer = 1.0;

glUniform1f(
OuterL, Outer );

break;

case
'O':

Outer++;

if ( Outer
> 64 ) Outer = 64.0;

glUniform1f(
OuterL, Outer );

break;

case
'r':

Inner =
1.0;

Outer =
1.0;

glUniform1f(
InnerL, Inner );

glUniform1f(
OuterL, Outer );

break;

case 'm':
{

static
GLenum mode = GL_FILL;

mode = (
mode == GL_FILL ? GL_LINE : GL_FILL );

glPolygonMode( GL_FRONT_AND_BACK, mode );

} break;

}

glutPostRedisplay();

}

//----------------------------------------------------------------------------

int main( int argc, char *argv[] )

{

glutInit(
&argc, argv );

glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );

glutInitWindowSize( 512, 512 );

glutInitContextVersion( 3, 2 );

glutInitContextProfile( GLUT_CORE_PROFILE );

glutCreateWindow( "teapot" );

glewExperimental =
GL_TRUE;
//注意这里有个坑 --
这一句很关键，不加这一句gl_GenVertexArray()会报错，好像说是GLEW对openGL的core
context有一些问题

//
http://stackoverflow.com/questions/22813625/0xc0000005-access-violation-executing-location-0x00000000-opengl
GLenum error
= glewInit();

if( error !=
GLEW_OK )

{

cout<<"glewInit failed, aborting"<<endl;

}

if (
GLEW_ARB_vertex_array_object == NULL )

{

cout<<"GLEW_ARB_vertex_array_object =
NULL"<<endl;

}

cout<<"Error info:"<<glGetError()<<endl;

init();

glutDisplayFunc( display );

glutReshapeFunc( reshape );

glutKeyboardFunc( keyboard );

glutMainLoop();

return
0;

}

square.vert source code below:

#version 400 core

in vec4 vPosition;

void main()

{

//gl_Position is used to access the vertex position that is input
from application

gl_Position
= vPosition;

}

square.cont source code below:

#version 400 core

//The main purpose of tessellation control shader is:

//Generate the tessellation output patch vertices that are passed
to the tessellation

//evaluation shader, as well as update any per-vertex

//Define how many vertices will be used as one patch

layout (vertices = 4) out;

//uniform type is used to define the variable that can be used to
communicate between shader and application

uniform float inner;

uniform float outer;

void main()

{

//gl_TessLevelInner is used to define:

//how the
interior of the domain is subdivided and stored in a two element
array named

gl_TessLevelInner[0] = inner;

gl_TessLevelInner[1] = inner;

//gl_TessLevelOuter is used to define:

//how the
perimeter of the domain is subdivided, and is stored in an

//implicitly
declared four-element array

gl_TessLevelOuter[0] = outer;

gl_TessLevelOuter[1] = outer;

gl_TessLevelOuter[2] = outer;

gl_TessLevelOuter[3] = outer;

//gl_in is
used to access the number of elements that are define by
glPatchParameteri()

//glPatchParameteri() define how many vertices as a patch

//gl_out is
used to access the output vertex position of tessellation control
shader

//gl_in
vertex shader structure below:

//in
gl_PerVertex {

//
vec4
gl_Position;

//
float
gl_PointSize;

//
float
gl_ClipDistance[]

//}
gl_in[gl_PatchVerticesIn];

//gl_out
vertex shader structure is similar to gl_in structure

//gl_InvocationID is used to access the specific vertex of a
patch

gl_out[gl_InvocationID].gl_Position =
gl_in[gl_InvocationID].gl_Position;

}

square.eval source code below:

#version 400 core

//The main purpose of tessellation evaluation shader is:

//configure the primitive generator, which is done using a layout
directive

//Specifying the face winding for generated primitives

//(the order the vertices are issued determines the facedness of
the primitive)

layout (quads, equal_spacing, ccw) in;

//The TES is executed on all generated domain locations.

//The bound tessellation evaluation shader is

//executed one for each tessellation coordinate that the primitive
generator

//Tessellation Shaders emits, and is responsible for determining
the position

//of the vertex derived from the tessellation coordinate.

uniform mat4 PJ;

uniform mat4 MV;

#define M_PI

3.14159265358979323846

//----------------------------------------------------------------------------

float Hanning( vec2 p )

{

p -= 0.5; //
map unit square to [-.5, .5]

float r =
length( p );

r = cos(
M_PI * r / 2.0 );

r *=
r;

return
r;

}

void main()

{

//gl_TessCoord is used to access the Tessellation coordinates that
are

//generated
by tessellation control shader

float u =
gl_TessCoord.x;

float v =
gl_TessCoord.y;

//use
Tessellation coordinates to calculate position for new vertex
that

//is
generated by tessellation control shader

#define
p(i) gl_in[i].gl_Position

vec4 pos =
v*(u*p(0) + (1-u)*p(1)) + (1-v)*(u*p(3) + (1-u)*p(2));

pos.z =
Hanning( gl_TessCoord.xy );

gl_Position
= PJ * MV * pos;

}

square.frag source code below:

#version 400 core

out vec4 fColor;

void main()

{

fColor = (1
- gl_FragCoord.z) * vec4( 1.0, 0.0, 0.0, 1.0 );

}

总结：

tessellation shader是可选的shader，不是必须的

tessellation shader与vertex shader不一样，tessellation
shader是针对patch（一系列顶点）来处理而不是一个顶点 （因为tessellation
shader需要通过传入的patch（一系列顶点）来计算新顶点的位置信息）

tessellation control shader负责对patch的细分设定

tessellation evaluation
shader负责对TCS细分出来的顶点进行位置等信息运算从而实现LOD（level of detail --
根据与camera的距离不同而细分程度不同）等效果

Bezier曲线在这里是一种细分后位置的计算方法来实现曲面的平滑效果

tessellation shader有个重要的应用就是LOD(Level of
Detail)，通过在判断物体与视线的距离来设定tessellation control里面的factor
level从而实现近细分多，远细分少的效果

还有一个应用叫displacement mapping，在tessellation evaluation
shader里面通过tessellation coordinate的值来映射纹理（sample a texture）