static void
Init(void)
{
static const char *fragShaderText =
"void main() {\n"
" gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_Position = gl_Vertex;\n"
"}\n";
if (!ShadersSupported())
exit(1);
fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
assert(glGetError() == 0);
glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
glColor3f(1, 0, 0);
}
static void
Init(void)
{
if (!ShadersSupported())
exit(1);
vertShader = CompileShaderText(GL_VERTEX_SHADER, VertShaderText);
fragShader = CompileShaderText(GL_FRAGMENT_SHADER, FragShaderText);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
SetUniformValues(program, Uniforms);
PrintUniforms(Uniforms);
assert(glGetError() == 0);
glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
glColor3f(1, 0, 0);
}
std::string cGL::GetShadingLanguageVersion() {
if ( ShadersSupported() ) {
#ifdef GL_SHADING_LANGUAGE_VERSION
const char * str = GetString( GL_SHADING_LANGUAGE_VERSION );
if ( NULL != str )
return std::string( str );
#endif
}
return std::string( "Shaders not supported" );
}
static void
Init(void)
{
/* Fragment shader: modulate raster color by texture, discard fragments
* with alpha < 1.0
*/
static const char *fragShaderText =
"uniform sampler2D tex2d; \n"
"void main() {\n"
" vec4 c = texture2D(tex2d, gl_TexCoord[0].xy); \n"
" if (c.w < 1.0) \n"
" discard; \n"
" gl_FragColor = c * gl_Color; \n"
"}\n";
/* Vertex shader: compute new vertex position based on incoming vertex pos,
* texcoords and special scale factor.
*/
static const char *vertShaderText =
"uniform vec2 scale; \n"
"void main() {\n"
" vec4 p = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
" gl_Position.xy = p.xy + gl_MultiTexCoord0.xy * scale * p.w; \n"
" gl_Position.zw = p.zw; \n"
" gl_TexCoord[0] = gl_MultiTexCoord0; \n"
" gl_FrontColor = gl_Color; \n"
"}\n";
if (!ShadersSupported())
exit(1);
VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
Program = LinkShaders(VertShader, FragShader);
glUseProgram(Program);
uScale = glGetUniformLocation(Program, "scale");
uTex = glGetUniformLocation(Program, "tex2d");
if (uTex != -1) {
glUniform1i(uTex, 0); /* tex unit 0 */
}
glUseProgram(0);
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_LIGHT0);
MakeBitmapTextures();
}
static void
Init(void)
{
static const char *fragShaderText =
"uniform ivec2 WinSize; \n"
"void main() {\n"
" vec2 d = dFdy(gl_TexCoord[0].xy) * vec2(WinSize); \n"
" gl_FragColor = vec4(d.x, d.y, 0.0, 1.0);\n"
" // gl_FragColor = gl_TexCoord[0];\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
" gl_TexCoord[0] = gl_MultiTexCoord0;\n"
"}\n";
if (!ShadersSupported())
exit(1);
vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
WinSizeUniform = glGetUniformLocation(program, "WinSize");
/*assert(glGetError() == 0);*/
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
glEnable(GL_DEPTH_TEST);
MakeSphere();
MakeRect();
CurList = SphereList;
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
glColor3f(1, 0, 0);
}
static void
Init(void)
{
if (!ShadersSupported())
exit(1);
vertShader = CompileShaderFile(GL_VERTEX_SHADER, VertProgFile);
fragShader = CompileShaderFile(GL_FRAGMENT_SHADER, FragProgFile);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
SetUniformValues(program, Uniforms);
PrintUniforms(Uniforms);
assert(glGetError() == 0);
glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
glEnable(GL_DEPTH_TEST);
glColor3f(1, 0, 0);
}
static void init(void)
{
static const char *fragShaderText =
"void main() {\n"
" gl_FragColor = gl_Color;\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_FrontColor = gl_Color;\n"
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
"}\n";
static const char *geoShaderText =
"#version 120\n"
"#extension GL_ARB_geometry_shader4 : enable\n"
"void main()\n"
"{\n"
" for(int i = 0; i < gl_VerticesIn; ++i)\n"
" {\n"
" gl_FrontColor = gl_FrontColorIn[i];\n"
" gl_Position = gl_PositionIn[i];\n"
" EmitVertex();\n"
" }\n"
"}\n";
if (!ShadersSupported())
exit(1);
if (!glutExtensionSupported("GL_ARB_geometry_shader4")) {
printf("This demo requires GL_ARB_geometry_shader4\n");
exit(1);
}
menu_init();
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
load_and_compile_shader(fragShader, fragShaderText);
vertShader = glCreateShader(GL_VERTEX_SHADER);
load_and_compile_shader(vertShader, vertShaderText);
geoShader = glCreateShader(GL_GEOMETRY_SHADER_ARB);
if (filename)
read_shader(geoShader, filename);
else
load_and_compile_shader(geoShader,
geoShaderText);
program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, geoShader);
glAttachShader(program, fragShader);
glProgramParameteriARB(program, GL_GEOMETRY_INPUT_TYPE_ARB,
GL_LINES_ADJACENCY_ARB);
glProgramParameteriARB(program, GL_GEOMETRY_OUTPUT_TYPE_ARB,
GL_LINE_STRIP);
{
int temp;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,&temp);
glProgramParameteriARB(program,GL_GEOMETRY_VERTICES_OUT_ARB,temp);
}
glLinkProgram(program);
check_link(program);
glUseProgram(program);
SetUniformValues(program, Uniforms);
PrintUniforms(Uniforms);
assert(glGetError() == 0);
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_COLOR_ARRAY );
glVertexPointer( 3, GL_FLOAT, sizeof(vertices[0]), vertices );
glColorPointer( 4, GL_FLOAT, sizeof(color[0]), color );
}
static void
Init(void)
{
static const char *fragShaderText =
"uniform float StipplePattern[16]; \n"
"varying float stippleCoord; \n"
"void main() \n"
"{ \n"
" // check the stipple pattern and discard if value is zero \n"
" // TODO: we should really undo the perspective interpolation here \n"
" // so that it's linear. \n"
" float stip = StipplePattern[int(fract(stippleCoord) * 16.0)]; \n"
" if (stip == 0.0) \n"
" discard; \n"
" gl_FragColor = gl_Color; \n"
"} \n";
static const char *vertShaderText =
"void main() \n"
"{ \n"
" gl_FrontColor = gl_Color; \n"
" gl_Position = ftransform(); \n"
"} \n";
static const char *geomShaderText =
"#version 120 \n"
"#extension GL_ARB_geometry_shader4: enable \n"
"uniform vec2 ViewportSize; \n"
"uniform float StippleFactor; \n"
"varying float stippleCoord; \n"
"void main() \n"
"{ \n"
" vec4 pos0 = gl_PositionIn[0]; \n"
" vec4 pos1 = gl_PositionIn[1]; \n"
" // Convert eye coords to window coords \n"
" // Note: we're off by a factor of two here, make up for that below \n"
" vec2 p0 = pos0.xy / pos0.w * ViewportSize; \n"
" vec2 p1 = pos1.xy / pos1.w * ViewportSize; \n"
" float len = length(p0.xy - p1.xy); \n"
" // Emit first vertex \n"
" gl_FrontColor = gl_FrontColorIn[0]; \n"
" gl_Position = pos0; \n"
" stippleCoord = 0.0; \n"
" EmitVertex(); \n"
" // Emit second vertex \n"
" gl_FrontColor = gl_FrontColorIn[1]; \n"
" gl_Position = pos1; \n"
" stippleCoord = len / StippleFactor / 32.0; // Note: not 16, see above \n"
" EmitVertex(); \n"
"} \n";
if (!ShadersSupported())
exit(1);
if (!glutExtensionSupported("GL_ARB_geometry_shader4")) {
fprintf(stderr, "Sorry, GL_ARB_geometry_shader4 is not supported.\n");
exit(1);
}
VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
GeomShader = CompileShaderText(GL_GEOMETRY_SHADER_ARB, geomShaderText);
assert(GeomShader);
Program = LinkShaders3(VertShader, GeomShader, FragShader);
assert(Program);
CheckError(__LINE__);
/*
* The geometry shader accepts lines and produces lines.
*/
glProgramParameteriARB(Program, GL_GEOMETRY_INPUT_TYPE_ARB,
GL_LINES);
glProgramParameteriARB(Program, GL_GEOMETRY_OUTPUT_TYPE_ARB,
GL_LINE_STRIP);
glProgramParameteriARB(Program, GL_GEOMETRY_VERTICES_OUT_ARB, 4);
CheckError(__LINE__);
glLinkProgramARB(Program);
/* check link */
{
GLint stat;
GetProgramiv(Program, GL_LINK_STATUS, &stat);
if (!stat) {
GLchar log[1000];
GLsizei len;
GetProgramInfoLog(Program, 1000, &len, log);
fprintf(stderr, "Shader link error:\n%s\n", log);
}
}
glUseProgram(Program);
uViewportSize = glGetUniformLocation(Program, "ViewportSize");
uStippleFactor = glGetUniformLocation(Program, "StippleFactor");
uStipplePattern = glGetUniformLocation(Program, "StipplePattern");
glUniform1f(uStippleFactor, StippleFactor);
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(Program));
assert(glIsShader(FragShader));
assert(glIsShader(VertShader));
assert(glIsShader(GeomShader));
glLineStipple(StippleFactor, StipplePattern);
SetStippleUniform(StippleFactor, StipplePattern);
MakePointsVBO();
}
static void
Init(void)
{
static const char *fragShaderText =
"void main() \n"
"{ \n"
" gl_FragColor = gl_Color; \n"
"} \n";
static const char *vertShaderText =
"void main() \n"
"{ \n"
" gl_FrontColor = gl_Color; \n"
" gl_Position = ftransform(); \n"
"} \n";
static const char *geomShaderText =
"#version 120 \n"
"#extension GL_ARB_geometry_shader4: enable \n"
"uniform vec2 InverseViewportSize; \n"
"uniform float LineWidth; \n"
"void main() \n"
"{ \n"
" vec4 pos0 = gl_PositionIn[0]; \n"
" vec4 pos1 = gl_PositionIn[1]; \n"
" vec4 dir = abs(pos1 - pos0); \n"
" vec2 d0 = vec2(LineWidth * pos0.w) * InverseViewportSize; \n"
" vec2 d1 = vec2(LineWidth * pos1.w) * InverseViewportSize; \n"
" // this conditional could be avoided \n"
" if (dir.x > dir.y) { \n"
" // X-major line \n"
" d0.x = 0.0; \n"
" d1.x = 0.0; \n"
" } \n"
" else { \n"
" // Y-major line \n"
" d0.y = 0.0; \n"
" d1.y = 0.0; \n"
" } \n"
" gl_FrontColor = gl_FrontColorIn[0]; \n"
" gl_TexCoord[0] = vec4(0, 0, 0, 1); \n"
" gl_Position = pos0 + vec4( d0.x, -d0.y, 0, 0); \n"
" EmitVertex(); \n"
" gl_FrontColor = gl_FrontColorIn[1]; \n"
" gl_TexCoord[0] = vec4(1, 0, 0, 1); \n"
" gl_Position = pos1 + vec4( d1.x, -d1.y, 0, 0); \n"
" EmitVertex(); \n"
" gl_FrontColor = gl_FrontColorIn[0]; \n"
" gl_TexCoord[0] = vec4(0, 1, 0, 1); \n"
" gl_Position = pos0 + vec4(-d0.x, d0.y, 0, 0); \n"
" EmitVertex(); \n"
" gl_FrontColor = gl_FrontColorIn[1]; \n"
" gl_TexCoord[0] = vec4(1, 1, 0, 1); \n"
" gl_Position = pos1 + vec4(-d1.x, d1.y, 0, 0); \n"
" EmitVertex(); \n"
"} \n";
if (!ShadersSupported())
exit(1);
if (!glutExtensionSupported("GL_ARB_geometry_shader4")) {
fprintf(stderr, "Sorry, GL_ARB_geometry_shader4 is not supported.\n");
exit(1);
}
VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
GeomShader = CompileShaderText(GL_GEOMETRY_SHADER_ARB, geomShaderText);
assert(GeomShader);
Program = LinkShaders3(VertShader, GeomShader, FragShader);
assert(Program);
CheckError(__LINE__);
/*
* The geometry shader will convert incoming lines to quads (4-vertex
* triangle strips).
*/
glProgramParameteriARB(Program, GL_GEOMETRY_INPUT_TYPE_ARB,
GL_LINES);
glProgramParameteriARB(Program, GL_GEOMETRY_OUTPUT_TYPE_ARB,
GL_TRIANGLE_STRIP);
glProgramParameteriARB(Program,GL_GEOMETRY_VERTICES_OUT_ARB, 4);
CheckError(__LINE__);
glLinkProgramARB(Program);
/* check link */
{
GLint stat;
GetProgramiv(Program, GL_LINK_STATUS, &stat);
if (!stat) {
GLchar log[1000];
GLsizei len;
GetProgramInfoLog(Program, 1000, &len, log);
fprintf(stderr, "Shader link error:\n%s\n", log);
}
}
CheckError(__LINE__);
glUseProgram(Program);
CheckError(__LINE__);
uInverseViewportSize = glGetUniformLocation(Program, "InverseViewportSize");
uLineWidth = glGetUniformLocation(Program, "LineWidth");
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(Program));
assert(glIsShader(FragShader));
assert(glIsShader(VertShader));
assert(glIsShader(GeomShader));
glEnable(GL_DEPTH_TEST);
{
GLfloat r[2];
glGetFloatv(GL_LINE_WIDTH_RANGE, r);
MaxLineWidth = r[1];
}
MakePointsVBO();
}
static void
Init(void)
{
const GLubyte *version;
static const char *vertShaderText =
"#version 150 \n"
"uniform mat4 ModelViewProjection; \n"
"in vec4 Vertex; \n"
"void main() \n"
"{ \n"
" gl_Position = ModelViewProjection * Vertex; \n"
"} \n";
static const char *geomShaderText =
"#version 150 \n"
"layout(triangles) in; \n"
"layout(triangle_strip, max_vertices = 3) out; \n"
"uniform vec2 ViewportSize; \n"
"out vec2 Vert0, Vert1, Vert2; \n"
"\n"
"// Transform NDC coord to window coord \n"
"vec2 vpxform(vec4 p) \n"
"{ \n"
" return (p.xy / p.w + 1.0) * 0.5 * ViewportSize; \n"
"} \n"
"\n"
"void main() \n"
"{ \n"
" Vert0 = vpxform(gl_in[0].gl_Position); \n"
" Vert1 = vpxform(gl_in[1].gl_Position); \n"
" Vert2 = vpxform(gl_in[2].gl_Position); \n"
" gl_Position = gl_in[0].gl_Position; \n"
" EmitVertex(); \n"
" gl_Position = gl_in[1].gl_Position; \n"
" EmitVertex(); \n"
" gl_Position = gl_in[2].gl_Position; \n"
" EmitVertex(); \n"
"} \n";
static const char *fragShaderText =
"#version 150 \n"
"#define LINE_WIDTH 2.5 \n"
"uniform vec4 Color; \n"
"in vec2 Vert0, Vert1, Vert2; \n"
"out vec4 FragColor; \n"
"// Compute distance from a point to a line \n"
"float point_line_dist(vec2 p, vec2 v1, vec2 v2) \n"
"{ \n"
" float s = (v2.x - v1.x) * (v1.y - p.y) - (v1.x - p.x) * (v2.y - v1.y); \n"
" float t = length(v2 - v1); \n"
" return abs(s) / t; \n"
"} \n"
"\n"
"void main() \n"
"{ \n"
" float d0 = point_line_dist(gl_FragCoord.xy, Vert0, Vert1); \n"
" float d1 = point_line_dist(gl_FragCoord.xy, Vert1, Vert2); \n"
" float d2 = point_line_dist(gl_FragCoord.xy, Vert2, Vert0); \n"
" float m = min(d0, min(d1, d2)); \n"
" FragColor = Color * smoothstep(0.0, LINE_WIDTH, m); \n"
"} \n";
static const GLfloat verts[3][2] = {
{ -1, -1 },
{ 1, -1 },
{ 0, 1 }
};
if (!ShadersSupported())
exit(1);
if (!GLEW_VERSION_3_2) {
fprintf(stderr, "Sorry, OpenGL 3.2 or later required.\n");
exit(1);
}
VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
GeomShader = CompileShaderText(GL_GEOMETRY_SHADER, geomShaderText);
Program = LinkShaders3(VertShader, GeomShader, FragShader);
assert(Program);
CheckError(__LINE__);
glBindAttribLocation(Program, 0, "Vertex");
glBindFragDataLocation(Program, 0, "FragColor");
/* relink */
glLinkProgram(Program);
assert(glIsProgram(Program));
assert(glIsShader(FragShader));
assert(glIsShader(VertShader));
assert(glIsShader(GeomShader));
glUseProgram(Program);
uViewportSize = glGetUniformLocation(Program, "ViewportSize");
uModelViewProj = glGetUniformLocation(Program, "ModelViewProjection");
uColor = glGetUniformLocation(Program, "Color");
glUniform4fv(uColor, 1, Orange);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
glEnable(GL_DEPTH_TEST);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
}
